540 lines
22 KiB
TypeScript
540 lines
22 KiB
TypeScript
import { SessionMessage } from "@opencode-ai/schema/session-message"
|
|
import { SessionInput } from "@opencode-ai/schema/session-input"
|
|
import { PromptInput } from "@opencode-ai/schema/prompt-input"
|
|
import { Session } from "@opencode-ai/schema/session"
|
|
import { SessionContextEntry } from "@opencode-ai/schema/session-context-entry"
|
|
import { Project } from "@opencode-ai/schema/project"
|
|
import { AbsolutePath, PositiveInt, RelativePath, statics } from "@opencode-ai/schema/schema"
|
|
import { Event } from "@opencode-ai/schema/event"
|
|
import { Workspace } from "@opencode-ai/schema/workspace"
|
|
import { Context, Effect, Encoding, Result, Schema, SchemaGetter, Struct } from "effect"
|
|
import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi"
|
|
import {
|
|
ConflictError,
|
|
CommandEvaluationError,
|
|
CommandNotFoundError,
|
|
InvalidCursorError,
|
|
InvalidRequestError,
|
|
MessageNotFoundError,
|
|
ServiceUnavailableError,
|
|
SessionBusyError,
|
|
SessionNotFoundError,
|
|
SkillNotFoundError,
|
|
UnknownError,
|
|
} from "../errors.js"
|
|
import { Agent } from "@opencode-ai/schema/agent"
|
|
import { Model } from "@opencode-ai/schema/model"
|
|
import { Location } from "@opencode-ai/schema/location"
|
|
import { Revert } from "@opencode-ai/schema/revert"
|
|
import { SessionEvent } from "@opencode-ai/schema/session-event"
|
|
import { EventLog } from "@opencode-ai/schema/event-log"
|
|
|
|
const SessionsQueryFields = {
|
|
workspace: Workspace.ID.pipe(Schema.optional),
|
|
limit: Schema.NumberFromString.pipe(Schema.decodeTo(PositiveInt), Schema.optional).annotate({
|
|
description: "Maximum number of sessions to return. Defaults to the newest 50 sessions.",
|
|
}),
|
|
order: Schema.optional(Schema.Union([Schema.Literal("asc"), Schema.Literal("desc")])).annotate({
|
|
description: "Session order for the first page. Use desc for newest first or asc for oldest first.",
|
|
}),
|
|
search: Schema.optional(Schema.String),
|
|
}
|
|
|
|
const SessionsDirectoryQuery = Schema.Struct({
|
|
...SessionsQueryFields,
|
|
directory: AbsolutePath,
|
|
})
|
|
|
|
const SessionsProjectQuery = Schema.Struct({
|
|
...SessionsQueryFields,
|
|
project: Project.ID,
|
|
subpath: RelativePath.pipe(Schema.optional),
|
|
})
|
|
|
|
const SessionsAllQuery = Schema.Struct(SessionsQueryFields)
|
|
|
|
const withCursor = <Fields extends Schema.Struct.Fields>(schema: Schema.Struct<Fields>) =>
|
|
schema.mapFields((fields) => ({
|
|
...Struct.omit(fields, ["limit"]),
|
|
anchor: Session.ListAnchor,
|
|
}))
|
|
|
|
const SessionsCursorInput = Schema.Union([
|
|
withCursor(SessionsDirectoryQuery),
|
|
withCursor(SessionsProjectQuery),
|
|
withCursor(SessionsAllQuery),
|
|
])
|
|
const SessionsCursorJson = Schema.fromJsonString(SessionsCursorInput)
|
|
const encodeSessionsCursor = Schema.encodeSync(SessionsCursorJson)
|
|
const decodeSessionsCursor = Schema.decodeUnknownEffect(SessionsCursorJson)
|
|
const invalidCursor = "Invalid cursor" as const
|
|
|
|
export const SessionsCursor = Schema.String.pipe(
|
|
Schema.brand("SessionsCursor"),
|
|
statics((schema) => {
|
|
const make = schema.make.bind(schema)
|
|
return {
|
|
make: (input: typeof SessionsCursorInput.Type) => make(Encoding.encodeBase64Url(encodeSessionsCursor(input))),
|
|
parse: (input: string) =>
|
|
Effect.suspend(() => {
|
|
const result = Encoding.decodeBase64UrlString(input)
|
|
return Result.isFailure(result)
|
|
? Effect.fail(invalidCursor)
|
|
: decodeSessionsCursor(result.success).pipe(Effect.mapError(() => invalidCursor))
|
|
}),
|
|
}
|
|
}),
|
|
)
|
|
export type SessionsCursor = typeof SessionsCursor.Type
|
|
|
|
const SessionActive = Schema.Struct({
|
|
type: Schema.Literal("running"),
|
|
}).annotate({ identifier: "SessionActive" })
|
|
|
|
const SessionWatermarks = Schema.Record(Session.ID, Event.Seq).annotate({
|
|
identifier: "SessionWatermarks",
|
|
description:
|
|
"Durable log seq each session's snapshot was computed at. Attach a live log read after the watermark to compose fetch and stream gap-free; apply a snapshot only where its watermark is at or beyond already-applied events. Sessions without durable events are absent.",
|
|
})
|
|
|
|
const BooleanFromString = Schema.Literals(["true", "false"]).pipe(
|
|
Schema.decodeTo(Schema.Boolean, {
|
|
decode: SchemaGetter.transform((value) => value === "true"),
|
|
encode: SchemaGetter.transform((value): "true" | "false" => (value ? "true" : "false")),
|
|
}),
|
|
)
|
|
|
|
const SessionsQueryCursor = SessionsCursor.annotate({
|
|
description: "Opaque pagination cursor returned as cursor.previous or cursor.next in the previous response.",
|
|
})
|
|
|
|
export const SessionsQuery = Schema.Struct({
|
|
...SessionsQueryFields,
|
|
directory: AbsolutePath.pipe(Schema.optional),
|
|
project: Project.ID.pipe(Schema.optional),
|
|
subpath: RelativePath.pipe(Schema.optional),
|
|
cursor: SessionsQueryCursor.pipe(Schema.optional),
|
|
}).annotate({ identifier: "SessionsQuery" })
|
|
|
|
export const makeSessionGroup = <I extends HttpApiMiddleware.AnyId, S>(sessionLocationMiddleware: Context.Key<I, S>) =>
|
|
HttpApiGroup.make("server.session")
|
|
.add(
|
|
HttpApiEndpoint.get("session.list", "/api/session", {
|
|
query: SessionsQuery,
|
|
success: Schema.Struct({
|
|
data: Schema.Array(Session.Info),
|
|
watermarks: SessionWatermarks,
|
|
cursor: Schema.Struct({
|
|
previous: SessionsCursor.pipe(Schema.optional),
|
|
next: SessionsCursor.pipe(Schema.optional),
|
|
}),
|
|
}).annotate({ identifier: "SessionsResponse" }),
|
|
error: [InvalidCursorError, InvalidRequestError],
|
|
}).annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.list",
|
|
summary: "List sessions",
|
|
description:
|
|
"Retrieve sessions in the requested order. Items keep that order across pages; use cursor.next or cursor.previous to move through the ordered list.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.create", "/api/session", {
|
|
payload: Schema.Struct({
|
|
id: Session.ID.pipe(Schema.optional),
|
|
agent: Agent.ID.pipe(Schema.optional),
|
|
model: Model.Ref.pipe(Schema.optional),
|
|
location: Location.Ref.pipe(Schema.optional),
|
|
}),
|
|
success: Schema.Struct({ data: Session.Info }),
|
|
}).annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.create",
|
|
summary: "Create session",
|
|
description: "Create a session at the requested location.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.get("session.active", "/api/session/active", {
|
|
success: Schema.Struct({ data: Schema.Record(Session.ID, SessionActive), watermarks: SessionWatermarks }),
|
|
}).annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.active",
|
|
summary: "List active sessions",
|
|
description:
|
|
"Retrieve foreground Session drains currently owned by this OpenCode process. Sessions absent from the result are inactive. Watermarks are the durable log positions read alongside the activity snapshot; activity itself is process state, so the pairing is advisory rather than transactional.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.get("session.get", "/api/session/:sessionID", {
|
|
params: { sessionID: Session.ID },
|
|
success: Schema.Struct({ data: Session.Info }),
|
|
error: SessionNotFoundError,
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.get",
|
|
summary: "Get session",
|
|
description: "Retrieve a session by ID.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.fork", "/api/session/:sessionID/fork", {
|
|
params: { sessionID: Session.ID },
|
|
payload: Schema.Struct({ messageID: SessionMessage.ID.pipe(Schema.optional) }),
|
|
success: Schema.Struct({ data: Session.Info }),
|
|
error: [SessionNotFoundError, MessageNotFoundError],
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.fork",
|
|
summary: "Fork session",
|
|
description:
|
|
"Create a child session by copying projected history from the parent. When messageID is supplied, copy messages before that boundary.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.switchAgent", "/api/session/:sessionID/agent", {
|
|
params: { sessionID: Session.ID },
|
|
payload: Schema.Struct({ agent: Agent.ID }),
|
|
success: HttpApiSchema.NoContent,
|
|
error: SessionNotFoundError,
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.switchAgent",
|
|
summary: "Switch session agent",
|
|
description: "Switch the agent used by subsequent provider turns.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.switchModel", "/api/session/:sessionID/model", {
|
|
params: { sessionID: Session.ID },
|
|
payload: Schema.Struct({ model: Model.Ref }),
|
|
success: HttpApiSchema.NoContent,
|
|
error: SessionNotFoundError,
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.switchModel",
|
|
summary: "Switch session model",
|
|
description: "Switch the model used by subsequent provider turns.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.rename", "/api/session/:sessionID/rename", {
|
|
params: { sessionID: Session.ID },
|
|
payload: Schema.Struct({ title: Schema.String }),
|
|
success: HttpApiSchema.NoContent,
|
|
error: SessionNotFoundError,
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.rename",
|
|
summary: "Rename session",
|
|
description: "Update the session title.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.prompt", "/api/session/:sessionID/prompt", {
|
|
params: { sessionID: Session.ID },
|
|
payload: Schema.Struct({
|
|
id: SessionMessage.ID.pipe(Schema.optional),
|
|
prompt: PromptInput.Prompt,
|
|
delivery: SessionInput.Delivery.pipe(Schema.optional),
|
|
resume: Schema.Boolean.pipe(Schema.optional),
|
|
}),
|
|
success: Schema.Struct({ data: SessionInput.Admitted }),
|
|
error: [ConflictError, SessionNotFoundError],
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.prompt",
|
|
summary: "Send message",
|
|
description: "Durably admit one session input and schedule agent-loop execution unless resume is false.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.command", "/api/session/:sessionID/command", {
|
|
params: { sessionID: Session.ID },
|
|
payload: Schema.Struct({
|
|
id: SessionMessage.ID.pipe(Schema.optional),
|
|
command: Schema.String,
|
|
arguments: Schema.String.pipe(Schema.optional),
|
|
agent: Schema.String.pipe(Schema.optional),
|
|
model: Model.Ref.pipe(Schema.optional),
|
|
files: PromptInput.Prompt.fields.files,
|
|
agents: PromptInput.Prompt.fields.agents,
|
|
delivery: SessionInput.Delivery.pipe(Schema.optional),
|
|
resume: Schema.Boolean.pipe(Schema.optional),
|
|
}),
|
|
success: Schema.Struct({ data: SessionInput.Admitted }),
|
|
error: [ConflictError, SessionNotFoundError, CommandNotFoundError, CommandEvaluationError],
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.command",
|
|
summary: "Run command",
|
|
description:
|
|
"Resolve a slash command into prompt input, admit it durably, and schedule execution unless resume is false.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.skill", "/api/session/:sessionID/skill", {
|
|
params: { sessionID: Session.ID },
|
|
payload: Schema.Struct({
|
|
id: SessionMessage.ID.pipe(Schema.optional),
|
|
skill: Schema.String,
|
|
resume: Schema.Boolean.pipe(Schema.optional),
|
|
}),
|
|
success: HttpApiSchema.NoContent,
|
|
error: [SessionNotFoundError, SkillNotFoundError],
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.skill",
|
|
summary: "Activate skill",
|
|
description: "Activate a skill for a session by appending a skill message and resuming execution.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.synthetic", "/api/session/:sessionID/synthetic", {
|
|
params: { sessionID: Session.ID },
|
|
payload: Schema.Struct({
|
|
text: Schema.String,
|
|
description: Schema.String.pipe(Schema.optional),
|
|
metadata: SessionMessage.Synthetic.fields.metadata,
|
|
}),
|
|
success: HttpApiSchema.NoContent,
|
|
error: SessionNotFoundError,
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.synthetic",
|
|
summary: "Add synthetic message",
|
|
description: "Append a synthetic message to a session and resume execution.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.compact", "/api/session/:sessionID/compact", {
|
|
params: { sessionID: Session.ID },
|
|
success: HttpApiSchema.NoContent,
|
|
error: [SessionNotFoundError, SessionBusyError, ServiceUnavailableError, UnknownError],
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.compact",
|
|
summary: "Compact session",
|
|
description: "Compact a session conversation.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.wait", "/api/session/:sessionID/wait", {
|
|
params: { sessionID: Session.ID },
|
|
success: HttpApiSchema.NoContent,
|
|
error: [SessionNotFoundError, ServiceUnavailableError],
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.wait",
|
|
summary: "Wait for session",
|
|
description: "Wait for a session agent loop to become idle.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.revert.stage", "/api/session/:sessionID/revert/stage", {
|
|
params: { sessionID: Session.ID },
|
|
payload: Schema.Struct({ messageID: SessionMessage.ID, files: Schema.Boolean.pipe(Schema.optional) }),
|
|
success: Schema.Struct({ data: Revert.State }),
|
|
error: [MessageNotFoundError, SessionNotFoundError, SessionBusyError, UnknownError],
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.revert.stage",
|
|
summary: "Stage session revert",
|
|
description: "Stage or move a reversible session boundary and optionally apply its file changes.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.revert.clear", "/api/session/:sessionID/revert/clear", {
|
|
params: { sessionID: Session.ID },
|
|
success: HttpApiSchema.NoContent,
|
|
error: [SessionNotFoundError, SessionBusyError, UnknownError],
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(OpenApi.annotations({ identifier: "v2.session.revert.clear", summary: "Clear staged revert" })),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.revert.commit", "/api/session/:sessionID/revert/commit", {
|
|
params: { sessionID: Session.ID },
|
|
success: HttpApiSchema.NoContent,
|
|
error: [SessionNotFoundError, SessionBusyError],
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({ identifier: "v2.session.revert.commit", summary: "Commit staged revert" }),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.get("session.context", "/api/session/:sessionID/context", {
|
|
params: { sessionID: Session.ID },
|
|
success: Schema.Struct({ data: Schema.Array(SessionMessage.Message) }),
|
|
error: [SessionNotFoundError, UnknownError],
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.context",
|
|
summary: "Get session context",
|
|
description: "Retrieve the active context messages for a session (all messages after the last compaction).",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.get("session.context.entry.list", "/api/session/:sessionID/context-entry", {
|
|
params: { sessionID: Session.ID },
|
|
success: Schema.Struct({ data: Schema.Array(SessionContextEntry.Info) }),
|
|
error: SessionNotFoundError,
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.context.entry.list",
|
|
summary: "List context entries",
|
|
description: "List API-managed context entries attached to the session's system context.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.put("session.context.entry.put", "/api/session/:sessionID/context-entry/:key", {
|
|
params: { sessionID: Session.ID, key: SessionContextEntry.Key },
|
|
payload: Schema.Struct({ value: Schema.Json }),
|
|
success: HttpApiSchema.NoContent,
|
|
error: SessionNotFoundError,
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.context.entry.put",
|
|
summary: "Put context entry",
|
|
description:
|
|
"Attach or replace one durable context entry. The value is rendered into the session's system context; changes announce as updates at the next turn boundary.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.delete("session.context.entry.remove", "/api/session/:sessionID/context-entry/:key", {
|
|
params: { sessionID: Session.ID, key: SessionContextEntry.Key },
|
|
success: HttpApiSchema.NoContent,
|
|
error: SessionNotFoundError,
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.context.entry.remove",
|
|
summary: "Remove context entry",
|
|
description: "Remove one context entry; the removal is announced to the model at the next turn boundary.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.get("session.log", "/api/session/:sessionID/log", {
|
|
params: { sessionID: Session.ID },
|
|
query: {
|
|
after: Schema.NumberFromString.pipe(Schema.decodeTo(Event.Seq), Schema.optional),
|
|
follow: BooleanFromString.pipe(Schema.optional),
|
|
},
|
|
success: HttpApiSchema.StreamSse({
|
|
data: Schema.Union([SessionEvent.Durable, EventLog.CaughtUp]).annotate({ identifier: "SessionLogItem" }),
|
|
}),
|
|
error: SessionNotFoundError,
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.log",
|
|
summary: "Read the session log",
|
|
description:
|
|
"Durable, ordered, gap-free read of public session events after an exclusive aggregate sequence. Emits a caught-up marker once the replay reaches the end of the log, then completes; with follow=true it continues with live events instead. The only event API that promises reliability: attach after a snapshot watermark to compose fetch and stream without a race window.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.interrupt", "/api/session/:sessionID/interrupt", {
|
|
params: { sessionID: Session.ID },
|
|
success: HttpApiSchema.NoContent,
|
|
error: SessionNotFoundError,
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.interrupt",
|
|
summary: "Interrupt session execution",
|
|
description: "Interrupt active execution owned by this OpenCode process. Idle interruption is a no-op.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.post("session.background", "/api/session/:sessionID/background", {
|
|
params: { sessionID: Session.ID },
|
|
success: HttpApiSchema.NoContent,
|
|
error: SessionNotFoundError,
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.background",
|
|
summary: "Background blocking session tools",
|
|
description:
|
|
"Move active foreground backgroundable tools for this session into background observation. Idle requests are a no-op.",
|
|
}),
|
|
),
|
|
)
|
|
.add(
|
|
HttpApiEndpoint.get("session.message", "/api/session/:sessionID/message/:messageID", {
|
|
params: { sessionID: Session.ID, messageID: SessionMessage.ID },
|
|
success: Schema.Struct({ data: SessionMessage.Message }),
|
|
error: [SessionNotFoundError, MessageNotFoundError],
|
|
})
|
|
.middleware(sessionLocationMiddleware)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
identifier: "v2.session.message",
|
|
summary: "Get session message",
|
|
description: "Retrieve one projected message owned by the Session.",
|
|
}),
|
|
),
|
|
)
|
|
.annotateMerge(
|
|
OpenApi.annotations({
|
|
title: "sessions",
|
|
description: "Experimental session routes.",
|
|
}),
|
|
)
|