@openshain/agent 0.2.0 → 0.3.1

package/dist/session.js

@@ -1,375 +1,424 @@
-import { buildProjection, compileInputValidator, isOpenshainError, isTerminal, parseWorkId, SESSION_WORK_TYPE, } from "@openshain/core";
-import { countToolCalls, pendingQuestions, RUNTIME_PROVIDER_ID, runWork } from "./loop.js";
+import { ASK_USER_TOOL_NAME, buildProjection, eventToFile, isTerminal, newEventId, SESSION_WORK_TYPE, } from "@openshain/core";
+import { jsonOf } from "./client.js";
 import { pickAgentName } from "./names.js";
-/** How much one turn of a session may do before the person hears back. */
-export const TURN_LIMITS = { modelCalls: 5, toolCalls: 10 };
-/** What the session's model may do: hand work out and look work up. It never touches files itself. */
-export const SESSION_TOOLS = Object.freeze([
-    {
-        name: "work_run",
-        description: "Start a work for the person's request and drive it until it completes, fails or stops to ask the person a question. Write the objective in the person's own words and add what the conversation established that the work needs to know. Returns the work's id, status, summary, artifacts and usage, or the question it is waiting on.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                objective: {
-                    type: "string",
-                    minLength: 1,
-                    description: "The request, in the person's words.",
-                },
-                type: {
-                    type: "string",
-                    description: "A short label for the kind of work. Defaults to request.",
-                },
-            },
-            required: ["objective"],
-            additionalProperties: false,
-        },
-        effect: "mutate",
-    },
-    {
-        name: "work_list",
-        description: "The most recent works in this workspace, newest first, without sessions.",
-        inputSchema: { type: "object", properties: {}, additionalProperties: false },
-        effect: "observe",
-    },
-    {
-        name: "work_show",
-        description: "One work by id: its status, summary, artifacts, usage, and who has to act next.",
-        inputSchema: {
-            type: "object",
-            properties: { id: { type: "string", minLength: 1 } },
-            required: ["id"],
-            additionalProperties: false,
-        },
-        effect: "observe",
-    },
-]);
-const validators = new Map(SESSION_TOOLS.map((tool) => [tool.name, compileInputValidator(tool.inputSchema)]));
-const ROLE = "あなたはこの会社の社員エージェントとして、受付の役で、この人と話す。作業が要るときは work_run に objective を渡して Work にする。objective は人の言葉で書き、会話で分かった前提を添える。会社のファイルは自分では変更しない。ファイルの中身を見ないと答えられない質問も、work_run で Work にして調べる。作業の結果は要約して伝える。件数や金額は Work の結果の数字をそのまま書き、計算し直さない。返答は端末の画面に出るので、Markdown の記法や絵文字は使わず、短い文で書く。過去の作業は work_list と work_show で答える。";
-/** Opens a conversation, recorded as a work of type "session", between the person and the model. */
-export async function createSession(runtime, options = {}) {
-    const model = options.model ?? runtime.model;
-    const { principal, profession } = runtime.config;
-    const agentName = options.agentName ?? pickAgentName(runtime.config.company.language, await namesInUse(runtime));
-    const created = await runtime.works.create({
+/** How much one turn of the conversation may do before it stops and the person is told. */
+export const TURN_LIMITS = { modelCalls: 25, toolCalls: 40 };
+/** The tools of the runtime that the loop itself drives; the model never sees them. */
+const LOOP_ONLY_TOOLS = new Set(["work_record", "work_answer"]);
+const ROLE = "あなたはこの会社の社員エージェントとして、受付の役で、この人と話す。作業が要るときは work_create で Work を作り(objective は人の言葉で書き、会話で分かった前提を添える)、その Work の中で Tool を呼び、終わったら work_complete で summary を人の言葉で書いて閉じる。会話の中では Tool を呼べないので、ファイルの中身を見ないと答えられない質問も Work を作って調べる。件数や金額は Tool が返した値をそのまま書き、計算し直さない。/work resume で候補として示された Work は、人の依頼がその objective に沿うときだけ work_select で続ける。沿わなければ続けず、その旨を伝えて新しい Work を作るか work_list で探し直す。返答は端末の画面に出るので、Markdown の記法や絵文字は使わず、短い文で書く。過去の作業は work_list と work_get で答える。";
+/**
+ * Opens a conversation, recorded as a work of type "session", between the person and the model.
+ * The loop is a client of the runtime: it creates works, calls tools and closes works through
+ * the same MCP tools any other agent uses, and records its own model calls with work_record.
+ */
+export async function createSession(client, options) {
+    const { model, config } = options;
+    const agentName = options.agentName ?? pickAgentName(config.company.language, await namesInUse(client));
+    const opened = await client.call("work_create", {
         objective: "会話",
-        principal: principal.id,
-        profession: profession.id,
         type: SESSION_WORK_TYPE,
-        agentName,
+        agent_name: agentName,
     });
-    await withHandle(runtime, created.id, options, (handle) => handle.transition("in_progress", "session opened"));
-    return {
-        id: created.id,
+    if (opened.isError)
+        throw new Error(`could not open a session: ${opened.text}`);
+    const session = jsonOf(opened);
+    const id = session.id;
+    /** The session's events as the projection needs them, kept in memory; the runtime holds the record. */
+    const events = [];
+    let seq = 0;
+    const local = (type, payload) => {
+        const now = new Date().toISOString();
+        seq += 1;
+        return {
+            v: 1,
+            id: newEventId(),
+            workId: id,
+            seq,
+            type,
+            payload,
+            occurredAt: now,
+            recordedAt: now,
+        };
+    };
+    events.push(local("work.created", {
+        objective: "会話",
+        principal: config.principal.id,
+        profession: config.profession.id,
+        type: SESSION_WORK_TYPE,
         agentName,
-        turn: (text, turnOptions = {}) => withHandle(runtime, created.id, options, async (handle) => {
-            await handle.append({ type: "human.message", payload: { text } });
-            return runTurn(runtime, handle, model, options, turnOptions.signal);
-        }),
-        close: () => withHandle(runtime, created.id, options, async (handle) => {
-            if (isTerminal((await handle.current()).status))
-                return handle.current();
-            await handle.append({
-                type: "evidence.recorded",
-                payload: { claim: "会話を終了", refs: [], artifacts: [] },
-            });
-            await handle.append({ type: "work.completed", payload: { summary: "会話を終了" } });
-            return handle.current();
-        }),
+    }));
+    let task;
+    let candidate;
+    /** Records one of the client's own events on a work through the runtime, and reports it. */
+    const record = async (workId, type, payload) => {
+        const event = local(type, payload);
+        const file = eventToFile({ ...event, workId });
+        const result = await client.call("work_record", {
+            work_id: workId,
+            type,
+            payload: file.payload,
+        });
+        if (result.isError)
+            throw new Error(`work_record failed: ${result.text}`);
+        await options.onEvent?.(workId, { ...event, workId });
     };
-}
-/** The names of the sessions still open, so two people talking at once do not get the same one. */
-async function namesInUse(runtime) {
-    const { works } = await runtime.works.list();
-    return works
-        .filter((w) => w.type === SESSION_WORK_TYPE && !isTerminal(w.status))
-        .flatMap((w) => (w.agentName ? [w.agentName] : []));
-}
-async function withHandle(runtime, id, options, fn) {
-    const opened = await runtime.works.open(id);
-    const handle = options.onEvent ? observed(opened, options.onEvent) : opened;
-    try {
-        return await fn(handle);
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function runTurn(runtime, handle, model, options, signal) {
-    const description = model.describe();
-    const config = {
-        ...runtime.config,
+    /** Records a model event on the session and, while a work is open, on that work as well. */
+    const recordModelEvent = async (type, payload) => {
+        events.push(local(type, payload));
+        await record(id, type, payload);
+        if (task)
+            await record(task.id, type, payload);
+    };
+    const describedTools = async () => (await client.listTools()).filter((t) => !LOOP_ONLY_TOOLS.has(t.name));
+    const promptConfig = {
+        ...config,
         profession: {
-            ...runtime.config.profession,
-            instructions: `${runtime.config.profession.instructions.trim()}\n\n${ROLE}`,
+            ...config.profession,
+            instructions: `${config.profession.instructions.trim()}\n\n${ROLE}`,
         },
     };
-    const turnStart = (await handle.events()).length;
-    const tools = [...SESSION_TOOLS];
-    let modelCalls = 0;
-    let toolCalls = 0;
-    for (;;) {
-        if (signal?.aborted)
-            return { reply: "", stopped: "aborted" };
-        if (modelCalls >= TURN_LIMITS.modelCalls) {
-            return {
-                reply: "",
-                stopped: "turn_limit",
-                detail: `model calls in one turn (${TURN_LIMITS.modelCalls})`,
-            };
-        }
-        const events = await handle.events();
-        const projection = buildProjection({
-            events,
-            config,
-            tools,
-            providerId: model.id,
-            budget: {
-                modelCallsLeft: TURN_LIMITS.modelCalls - modelCalls,
-                toolCallsLeft: TURN_LIMITS.toolCalls - toolCalls,
-            },
-        });
-        await handle.append({
-            type: "model.requested",
-            payload: {
+    async function runTurn(signal) {
+        const description = model.describe();
+        const tools = await describedTools();
+        let modelCalls = 0;
+        let toolCalls = 0;
+        for (;;) {
+            if (signal?.aborted)
+                return { reply: "", stopped: "aborted" };
+            if (modelCalls >= TURN_LIMITS.modelCalls) {
+                return {
+                    reply: "",
+                    stopped: "turn_limit",
+                    detail: `model calls in one turn (${TURN_LIMITS.modelCalls})`,
+                };
+            }
+            const projection = buildProjection({
+                events,
+                config: promptConfig,
+                tools,
+                providerId: model.id,
+                budget: {
+                    modelCallsLeft: TURN_LIMITS.modelCalls - modelCalls,
+                    toolCallsLeft: TURN_LIMITS.toolCalls - toolCalls,
+                },
+            });
+            if (task && task.modelCalls >= config.limits.maxModelCalls) {
+                await callTool({
+                    id: `call_limit_${task.id}`,
+                    name: "work_fail",
+                    input: {
+                        reason: "limit_reached",
+                        detail: `${config.limits.maxModelCalls} model calls`,
+                    },
+                }, signal);
+                return {
+                    reply: "",
+                    stopped: "turn_limit",
+                    detail: `model calls in one work (${config.limits.maxModelCalls})`,
+                };
+            }
+            await recordModelEvent("model.requested", {
                 provider: model.id,
                 model: description.model,
                 messageCount: projection.messages.length,
                 toolNames: tools.map((t) => t.name),
-            },
-        });
-        modelCalls += 1;
-        let response;
-        try {
-            response = await model.generate({
-                system: projection.system,
-                messages: projection.messages,
-                tools: projection.tools,
-                maxOutputTokens: runtime.config.limits.maxOutputTokens,
-                budget: projection.budget,
-                stableMessages: projection.messages.length - 1,
-                ...(runtime.config.model.options && { providerOptions: runtime.config.model.options }),
-            }, signal);
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            await handle.append({
-                type: "model.failed",
-                payload: { code: isOpenshainError(err) ? err.code : "model_error", message },
             });
-            return { reply: "", stopped: signal?.aborted ? "aborted" : "model_error", detail: message };
-        }
-        await handle.append({
-            type: "model.completed",
-            payload: {
+            modelCalls += 1;
+            if (task)
+                task.modelCalls += 1;
+            let response;
+            try {
+                response = await model.generate({
+                    system: projection.system,
+                    messages: projection.messages,
+                    tools: projection.tools,
+                    maxOutputTokens: config.limits.maxOutputTokens,
+                    budget: projection.budget,
+                    stableMessages: projection.messages.length - 1,
+                    ...(config.model?.options && { providerOptions: config.model.options }),
+                }, signal);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                await recordModelEvent("model.failed", { code: "model_error", message });
+                return { reply: "", stopped: signal?.aborted ? "aborted" : "model_error", detail: message };
+            }
+            await recordModelEvent("model.completed", {
                 stopReason: response.stopReason,
                 content: response.message.content,
-                ...(runtime.config.debug.persistRaw && response.raw !== undefined && { raw: response.raw }),
-            },
-        });
-        await handle.append({
-            type: "usage.recorded",
-            payload: {
+                ...(config.debug?.persistRaw && response.raw !== undefined && { raw: response.raw }),
+            });
+            await recordModelEvent("usage.recorded", {
                 kind: "model_inference",
                 provider: model.id,
                 model: description.model,
                 usage: response.usage,
-            },
-        });
-        const text = textOf(response.message.content);
-        switch (response.stopReason) {
-            case "end_turn":
-                return { reply: text };
-            case "tool_call": {
-                const calls = response.message.content.filter((p) => p.type === "tool_call");
-                for (const call of calls) {
-                    if (signal?.aborted)
-                        return { reply: text, stopped: "aborted" };
-                    if (toolCalls >= TURN_LIMITS.toolCalls) {
-                        return {
-                            reply: text,
-                            stopped: "turn_limit",
-                            detail: `tool calls in one turn (${TURN_LIMITS.toolCalls})`,
-                        };
+            });
+            const text = textOf(response.message.content);
+            switch (response.stopReason) {
+                case "end_turn":
+                    return { reply: text };
+                case "tool_call": {
+                    const calls = response.message.content.filter((p) => p.type === "tool_call");
+                    for (const call of calls) {
+                        if (signal?.aborted)
+                            return { reply: text, stopped: "aborted" };
+                        if (toolCalls >= TURN_LIMITS.toolCalls) {
+                            return {
+                                reply: text,
+                                stopped: "turn_limit",
+                                detail: `tool calls in one turn (${TURN_LIMITS.toolCalls})`,
+                            };
+                        }
+                        toolCalls += 1;
+                        const outcome = await callTool(call, signal);
+                        if (outcome === "withdrawn")
+                            return { reply: text, stopped: "aborted" };
                     }
-                    toolCalls += 1;
-                    await callSessionTool(runtime, handle, model, options, signal, call);
+                    break;
                 }
-                break;
+                case "max_tokens":
+                    return { reply: text, stopped: "max_tokens" };
+                case "refusal":
+                    return { reply: text, stopped: "refusal" };
+                default:
+                    return {
+                        reply: text,
+                        stopped: "model_error",
+                        detail: `unexpected stop reason "${response.stopReason}"`,
+                    };
             }
-            case "max_tokens":
-                return { reply: text, stopped: "max_tokens" };
-            case "refusal":
-                return { reply: text, stopped: "refusal" };
-            default:
-                return {
-                    reply: text,
-                    stopped: "model_error",
-                    detail: `unexpected stop reason "${response.stopReason}"`,
-                };
         }
-        // Nothing of the turn's own events is needed below; the projection rebuilds from the log.
-        void turnStart;
-    }
-}
-async function callSessionTool(runtime, handle, model, options, signal, call) {
-    const validate = validators.get(call.name);
-    if (!validate) {
-        await handle.append({
-            type: "tool.rejected",
-            payload: {
-                callId: call.id,
-                name: call.name,
-                code: "unknown_tool",
-                reason: `no tool named "${call.name}"; the session offers ${SESSION_TOOLS.map((t) => t.name).join(", ")}`,
-            },
-        });
-        return;
-    }
-    const validation = validate(call.input);
-    if (!validation.ok) {
-        await handle.append({
-            type: "tool.rejected",
-            payload: {
-                callId: call.id,
-                name: call.name,
-                code: "schema_mismatch",
-                reason: `input does not match the schema of ${call.name}: ${validation.reason}`,
-            },
-        });
-        return;
-    }
-    await handle.append({
-        type: "tool.called",
-        payload: { callId: call.id, provider: RUNTIME_PROVIDER_ID, name: call.name, input: call.input },
-    });
-    let result;
-    try {
-        result = await runSessionTool(runtime, handle, model, options, signal, call.name, call.input);
     }
-    catch (err) {
-        result = {
-            content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
-            isError: true,
-        };
-    }
-    await handle.append({
-        type: "tool.completed",
-        payload: { callId: call.id, content: result.content, isError: result.isError ?? false },
-    });
-}
-async function runSessionTool(runtime, handle, model, options, signal, name, input) {
-    switch (name) {
-        case "work_run": {
-            const type = typeof input.type === "string" && input.type !== "" ? input.type : "request";
-            if (type === SESSION_WORK_TYPE) {
-                return {
+    /**
+     * One tool call of the model, through the runtime. Keeps track of the work the model is on,
+     * asks the person when the runtime says a question is pending, and mirrors the call and its
+     * result into the session's projection.
+     */
+    async function callTool(call, signal) {
+        const workId = task?.id ?? id;
+        // The loop drives these itself; a model that calls them is refused before the runtime sees it.
+        const refusal = LOOP_ONLY_TOOLS.has(call.name)
+            ? `${call.name} is the loop's own; it is not a tool for the model`
+            : !task && (call.name === "work_complete" || call.name === "work_fail")
+                ? `${call.name} needs a work of its own: no work is open; start one with work_create`
+                : undefined;
+        if (refusal) {
+            finish(call.id, { content: [{ type: "text", text: refusal }], isError: true, text: "" });
+            return "done";
+        }
+        events.push(local("tool.called", {
+            callId: call.id,
+            provider: "runtime",
+            name: call.name,
+            input: call.input,
+        }));
+        await options.onEvent?.(workId, events.at(-1));
+        const input = call.name === "work_create" && call.input && typeof call.input === "object"
+            ? { ...call.input, parent: id, agent_name: agentName }
+            : call.input;
+        let result;
+        try {
+            result = await client.call(call.name, input, signal);
+        }
+        catch (err) {
+            result = {
+                content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+                isError: true,
+                text: "",
+            };
+        }
+        task?.callIds.add(call.id);
+        const data = result.isError
+            ? undefined
+            : jsonOf(result);
+        if (!result.isError &&
+            (call.name === "work_create" || call.name === "work_select") &&
+            data?.id) {
+            const workId = data.id;
+            const history = data.history;
+            task = {
+                id: workId,
+                modelCalls: typeof history?.modelCalls === "number" ? history.modelCalls : 0,
+                callIds: new Set([call.id]),
+            };
+            candidate = undefined;
+            await options.onEvent?.(workId, local("work.status_changed", {
+                from: "queued",
+                to: String(data.status ?? "in_progress"),
+                reason: call.name,
+            }));
+            // A selected work that waits for an answer gets it now, oldest question first.
+            if (call.name === "work_select" && data.status === "waiting_input") {
+                const answered = await answerPending(workId, signal);
+                if (answered === "withdrawn") {
+                    finish(call.id, result);
+                    return "withdrawn";
+                }
+                if (answered.length > 0) {
+                    result = {
+                        ...result,
+                        text: "",
+                        content: [
+                            ...result.content,
+                            { type: "text", text: `answers recorded: ${JSON.stringify(answered)}` },
+                        ],
+                    };
+                }
+            }
+        }
+        if (!result.isError && call.name === ASK_USER_TOOL_NAME && data?.pending === true && task) {
+            const asked = task.id;
+            const question = String(data.question ?? "");
+            if (!options.onInput) {
+                result = {
+                    ...result,
+                    text: "",
                     content: [
                         {
                             type: "text",
-                            text: `type "${SESSION_WORK_TYPE}" is reserved for conversations; use another label, such as request`,
+                            text: "the work waits for the person's answer; it can be resumed later",
                         },
                     ],
-                    isError: true,
                 };
             }
-            const agentName = (await handle.current()).agentName;
-            const child = await runtime.works.create({
-                objective: String(input.objective),
-                principal: runtime.config.principal.id,
-                profession: runtime.config.profession.id,
-                type,
-                parent: handle.id,
-                ...(agentName !== undefined && { agentName }),
-            });
-            const done = await runWork(runtime, child.id, {
-                model,
-                ...(options.onInput && {
-                    onInput: (q) => options.onInput?.(child.id, q),
-                }),
-                ...(options.onWorkEvent && {
-                    onEvent: (e) => options.onWorkEvent?.(child.id, e),
-                }),
-                ...(signal && { signal }),
-            });
-            return {
-                content: [
-                    { type: "json", value: await describeWork(runtime, done, signal?.aborted === true) },
-                ],
-            };
+            else {
+                let answer;
+                try {
+                    answer = await options.onInput(asked, question);
+                }
+                catch {
+                    // The person took the question back: the work stays waiting_input.
+                    finish(call.id, {
+                        content: [{ type: "text", text: "the person withdrew the question; the work waits" }],
+                        isError: true,
+                        text: "",
+                    });
+                    return "withdrawn";
+                }
+                const answered = await client.call("work_answer", { call_id: data.call_id, answer }, signal);
+                result = answered.isError
+                    ? answered
+                    : { content: [{ type: "text", text: answer }], isError: false, text: answer };
+            }
         }
-        case "work_list": {
-            const { works } = await runtime.works.list();
-            const recent = works
-                .filter((w) => w.type !== SESSION_WORK_TYPE)
-                .sort((a, b) => (a.createdAt < b.createdAt ? 1 : a.createdAt > b.createdAt ? -1 : 0))
-                .slice(0, 20)
-                .map((w) => ({
-                id: w.id,
-                status: w.status,
-                type: w.type,
-                objective: w.objective,
-                createdAt: w.createdAt,
-            }));
-            return { content: [{ type: "json", value: { works: recent } }] };
+        finish(call.id, result);
+        if (!result.isError && (call.name === "work_complete" || call.name === "work_fail") && task) {
+            const closed = task;
+            task = undefined;
+            foldAway(closed, call.id);
+            await options.onEvent?.(closed.id, local(call.name === "work_complete" ? "work.completed" : "work.failed", call.name === "work_complete"
+                ? { summary: String(call.input?.summary ?? "") }
+                : { reason: String(call.input?.reason ?? ""), detail: "" }));
         }
-        case "work_show": {
-            let id;
+        return "done";
+    }
+    /** Asks the person every question the work still waits on and records the answers. */
+    async function answerPending(workId, signal) {
+        if (!options.onInput)
+            return [];
+        const got = await client.call("work_get", { id: workId, history: true }, signal);
+        const history = jsonOf(got)?.history;
+        const answers = [];
+        for (const { callId, question } of history?.pending ?? []) {
+            let answer;
             try {
-                id = parseWorkId(String(input.id));
+                answer = await options.onInput(workId, question);
             }
             catch {
-                return {
-                    content: [{ type: "text", text: `"${String(input.id)}" is not a work id` }],
-                    isError: true,
-                };
+                return "withdrawn";
             }
-            const work = await runtime.works.get(id);
-            return { content: [{ type: "json", value: await describeWork(runtime, work, false) }] };
+            const recorded = await client.call("work_answer", { call_id: callId, answer }, signal);
+            if (recorded.isError)
+                throw new Error(recorded.text);
+            answers.push({ question, answer });
         }
-        default:
-            return { content: [{ type: "text", text: `no tool named "${name}"` }], isError: true };
+        return answers;
     }
-}
-/** A work as the session's model needs to see it: outcome, cost, and who acts next. */
-async function describeWork(runtime, work, interrupted) {
-    const events = await runtime.works.events(work.id);
-    const usage = {
-        modelCalls: 0,
-        toolCalls: countToolCalls(events),
-        inputTokens: 0,
-        outputTokens: 0,
-    };
-    for (const event of events) {
-        if (event.type === "model.requested")
-            usage.modelCalls += 1;
-        if (event.type === "usage.recorded") {
-            const { payload } = event;
-            if (payload.kind === "model_inference") {
-                usage.inputTokens += payload.usage.inputTokens;
-                usage.outputTokens += payload.usage.outputTokens;
-            }
+    function finish(callId, result) {
+        const event = local("tool.completed", {
+            callId,
+            content: result.content,
+            isError: result.isError,
+        });
+        events.push(event);
+        void options.onEvent?.(task?.id ?? id, event);
+    }
+    /** Once a work is closed, only its summary stays in the conversation: the tool results are folded away. */
+    function foldAway(closed, closingCallId) {
+        for (const event of events) {
+            if (event.type !== "tool.completed")
+                continue;
+            const payload = event.payload;
+            if (!closed.callIds.has(payload.callId) || payload.callId === closingCallId)
+                continue;
+            payload.content = [
+                {
+                    type: "text",
+                    text: `(この結果は Work ${closed.id} を閉じたので省略。要点は work_complete の summary にある)`,
+                },
+            ];
         }
     }
-    const question = work.status === "waiting_input" ? pendingQuestions(events).map((q) => q.question) : [];
     return {
-        id: work.id,
-        status: work.status,
-        ...(work.outcome && { summary: work.outcome.summary, artifacts: work.outcome.artifacts }),
-        ...(work.failure && { failure: work.failure }),
-        ...(question.length > 0 && { waitingFor: question }),
-        ...(interrupted &&
-            work.status === "in_progress" && {
-            interrupted: "the person stopped this work; it can be resumed",
-        }),
-        nextActor: isTerminal(work.status)
-            ? "nobody"
-            : work.status === "waiting_input"
-                ? "person"
-                : "model",
-        usage,
+        id,
+        agentName,
+        async turn(text, turnOptions = {}) {
+            events.push(local("human.message", { text }));
+            await record(id, "human.message", { text });
+            if (candidate) {
+                const note = `候補の Work: ${candidate.id}(status: ${candidate.status}、objective: ${candidate.objective})。この依頼がその objective に沿うなら work_select で続ける。沿わなければ続けず、その旨を伝えて新しい Work を作るか work_list で探し直す。`;
+                events.push(local("prompt.expanded", { name: "work resume", source: "builtin", text: note }));
+                await record(id, "prompt.expanded", { name: "work resume", source: "builtin", text: note });
+            }
+            try {
+                const result = await runTurn(turnOptions.signal);
+                return task ? { ...result, work: task.id } : result;
+            }
+            finally {
+                // Whatever the turn did, the next one starts from the conversation: a work it left open
+                // stays as it is and comes back as a candidate through select; a declined candidate is dropped.
+                candidate = undefined;
+                if (task) {
+                    task = undefined;
+                    await client.call("work_select", { id }).catch(() => undefined);
+                }
+            }
+        },
+        async select(workId) {
+            const got = await client.call("work_get", { id: workId });
+            if (got.isError)
+                throw new Error(got.text);
+            const work = jsonOf(got);
+            if (isTerminal(work.status))
+                throw new Error(`${work.id} は ${work.status} で、続けられません`);
+            candidate = { id: work.id, objective: work.objective, status: work.status };
+            return work;
+        },
+        currentWork: () => task?.id,
+        async close() {
+            const selected = await client.call("work_select", { id });
+            if (selected.isError) {
+                const got = await client.call("work_get", { id });
+                return jsonOf(got);
+            }
+            const closed = await client.call("work_complete", { summary: "会話を終了" });
+            if (closed.isError)
+                throw new Error(closed.text);
+            return jsonOf(closed);
+        },
     };
 }
+/** The names of the sessions still open, so two people talking at once do not get the same one. */
+async function namesInUse(client) {
+    const listed = await client.call("work_list", {});
+    if (listed.isError)
+        return [];
+    const { works } = jsonOf(listed);
+    return works
+        .filter((w) => w.type === SESSION_WORK_TYPE && !isTerminal(w.status))
+        .flatMap((w) => (w.agentName ? [w.agentName] : []));
+}
 function textOf(content) {
     return content
         .filter((p) => p.type === "text")
@@ -377,18 +426,3 @@ function textOf(content) {
         .join("\n")
         .trim();
 }
-function observed(handle, onEvent) {
-    return {
-        ...handle,
-        async append(event) {
-            const recorded = await handle.append(event);
-            await onEvent(recorded);
-            return recorded;
-        },
-        async transition(to, reason) {
-            const recorded = await handle.transition(to, reason);
-            await onEvent(recorded);
-            return recorded;
-        },
-    };
-}