@zq-silk/yui 0.6.8 → 0.6.10

package/dist/runtime/agentDriverObservation.js

@@ -1,23 +1,29 @@
 import { createHash } from "node:crypto";
-import { createRuntimeObservation } from "./runtimeObservation.js";
+import { createRuntimeObservation, runtimeObservationSemanticKey } from "./runtimeObservation.js";
 export function mapAgentDriverHook(input) {
+    return mapAgentDriverHooks(input)[0];
+}
+export function mapAgentDriverHooks(input) {
     requireMatchingDriver(input);
-    const mapped = input.driver.runtime.mapHook({
+    const raw = input.driver.runtime.mapHook({
         hookEventName: input.hookEventName,
         payload: input.payload,
         ...(input.occurrenceId === undefined ? {} : { occurrenceId: input.occurrenceId })
     });
-    const source = mapped.kind === "turn.accepted"
+    const mapped = Array.isArray(raw) ? raw : [raw];
+    if (mapped.length === 0)
+        throw new Error("Agent Driver Hook must map at least one observation.");
+    const source = mapped.some((entry) => entry.kind === "turn.accepted")
         ? input.driver.runtime.observer?.source({
             hookEventName: input.hookEventName,
             payload: input.payload,
             ...(input.occurrenceId === undefined ? {} : { occurrenceId: input.occurrenceId })
         }) ?? null
         : null;
-    return observation(input, source === null ? mapped : {
-        ...mapped,
-        payload: Object.freeze({ ...mapped.payload, observerSource: source })
-    });
+    return Object.freeze(mapped.map((entry, index) => observation({ ...input, ordinal: (input.ordinal ?? 0) + index }, source === null || entry.kind !== "turn.accepted" ? entry : {
+        ...entry,
+        payload: Object.freeze({ ...entry.payload, observerSource: source })
+    })));
 }
 export function mapAgentDriverUsage(input, usage) {
     requireMatchingDriver(input);
@@ -27,16 +33,25 @@ export function mapAgentDriverUsage(input, usage) {
     });
 }
 function observation(input, mapped) {
+    const eventId = hookEventId(input, mapped);
+    const fence = { ...input.fence, ...mapped.fence };
     return createRuntimeObservation({
-        schemaVersion: 1,
-        eventId: hookEventId(input, mapped),
+        schemaVersion: 2,
+        eventId,
+        semanticKey: runtimeObservationSemanticKey({
+            eventId,
+            kind: mapped.kind,
+            fence,
+            ...(input.sequence === undefined ? {} : { sequence: input.sequence }),
+            payload: mapped.payload
+        }),
         kind: mapped.kind,
         authority: "provider-structured",
         receivedAt: input.receivedAt,
         ...(input.observedAt === undefined ? {} : { observedAt: input.observedAt }),
         ...(input.sequence === undefined ? {} : { sequence: input.sequence }),
         ...(input.ordinal === undefined ? {} : { ordinal: input.ordinal }),
-        fence: input.fence,
+        fence,
         payload: mapped.payload
     });
 }

package/dist/runtime/builtinAgentDrivers.js

@@ -14,6 +14,24 @@ const STRUCTURED_CLI_CAPABILITIES = Object.freeze({
         interrupt: true,
         stop: true
     }),
+    conversation: Object.freeze({
+        persistentIdentity: "exact",
+        crossProcessResume: true,
+        readback: "partial"
+    }),
+    input: Object.freeze({
+        startTurn: true,
+        steer: "unavailable",
+        inject: "unavailable",
+        acceptance: "exact",
+        idempotency: "unavailable"
+    }),
+    descendants: Object.freeze({
+        lineage: "partial",
+        detachedQuery: "partial",
+        resultRouting: "partial"
+    }),
+    bounded: Object.freeze({ structuredTerminal: true }),
     observation: Object.freeze({
         sessionIdentity: "exact",
         sessionBootstrap: "discovered",
@@ -50,7 +68,11 @@ export const BUILTIN_AGENT_DRIVERS = Object.freeze([
                 ...(hookEventName === "SessionStart" && payload.source === "startup"
                     ? { startupSession: "preallocated" }
                     : {}),
-                terminal: isTerminalHook(hookEventName)
+                terminal: isTerminalHook(hookEventName),
+                ...(hookEventName !== "SubagentStop" ? {} : {
+                    continuationId: subagentId(payload),
+                    continuationGeneration: continuationGeneration(payload)
+                })
             }),
             observer: Object.freeze({
                 source: (input) => transcriptObserverSource(CLAUDE_CODE_DRIVER_ID, input),
@@ -63,16 +85,40 @@ export const BUILTIN_AGENT_DRIVERS = Object.freeze([
         label: "Codex",
         protocolVersion: 1,
         adapterId: "codex",
-        capabilities: STRUCTURED_CLI_CAPABILITIES,
+        capabilities: Object.freeze({
+            ...STRUCTURED_CLI_CAPABILITIES,
+            surfaces: Object.freeze(["interactive-cli", "managed-protocol"]),
+            conversation: Object.freeze({
+                persistentIdentity: "exact",
+                crossProcessResume: true,
+                readback: "exact"
+            }),
+            input: Object.freeze({
+                startTurn: true,
+                steer: "fenced",
+                inject: "fenced",
+                acceptance: "exact",
+                idempotency: "unavailable"
+            }),
+            descendants: Object.freeze({
+                lineage: "partial",
+                detachedQuery: "partial",
+                resultRouting: "partial"
+            })
+        }),
         runtime: Object.freeze({
             nativeSessionId: ({ payload }) => (optionalIdentityFrom(payload, ["session_id"])),
             nativeTurnId: ({ payload }) => (optionalIdentityFrom(payload, ["turn_id", "prompt_id"])),
             mapHook: ({ hookEventName, payload, occurrenceId }) => (mapCodexHook(hookEventName, payload, occurrenceId)),
-            classifyHook: ({ hookEventName }) => Object.freeze({
+            classifyHook: ({ hookEventName, payload }) => Object.freeze({
                 ...(hookEventName === "SessionStart"
                     ? { startupSession: "discovered" }
                     : {}),
-                terminal: isTerminalHook(hookEventName)
+                terminal: isTerminalHook(hookEventName),
+                ...(hookEventName !== "SubagentStop" ? {} : {
+                    continuationId: subagentId(payload),
+                    continuationGeneration: continuationGeneration(payload)
+                })
             }),
             observer: Object.freeze({
                 source: (input) => transcriptObserverSource(CODEX_DRIVER_ID, input),
@@ -90,9 +136,13 @@ export function builtinAgentDriverRegistry() {
 function mapClaudeHook(name, payload, occurrenceId) {
     switch (name) {
         case "SessionStart":
-            return payload.source === "startup"
-                ? mapped("session.ready")
-                : mapped("session.started");
+            return [
+                payload.source === "startup"
+                    ? mapped("session.ready")
+                    : mapped("session.started"),
+                mapped("conversation.observed", { recoverability: "recoverable" }),
+                mapped("activation.started")
+            ];
         case "UserPromptSubmit":
             return mapped("turn.accepted");
         case "PreToolUse":
@@ -119,15 +169,51 @@ function mapClaudeHook(name, payload, occurrenceId) {
             });
         }
         case "SubagentStart":
-            return operation("operation.started", "subagent", subagentId(payload));
+            return [
+                operation("operation.started", "subagent", subagentId(payload)),
+                continuationObservation("continuation.started", payload, {
+                    execution: "active",
+                    outcome: "pending",
+                    attachment: "attached",
+                    observationQuality: "exact",
+                    mayWriteWorkspace: true
+                })
+            ];
         case "SubagentStop":
-            return operation("operation.completed", "subagent", subagentId(payload));
+            return [
+                operation("operation.completed", "subagent", subagentId(payload)),
+                ...(optionalSummary(payload).summary === undefined ? [] : [
+                    continuationObservation("continuation.reported", payload, {
+                        execution: "quiescent",
+                        outcome: "succeeded",
+                        attachment: "attached",
+                        observationQuality: "exact",
+                        mayWriteWorkspace: false,
+                        reportId: reportId(payload),
+                        ...optionalSummary(payload)
+                    })
+                ]),
+                continuationObservation("continuation.settled", payload, {
+                    execution: "quiescent",
+                    outcome: continuationOutcome(payload),
+                    attachment: "attached",
+                    observationQuality: "exact",
+                    mayWriteWorkspace: false,
+                    ...optionalSummary(payload)
+                })
+            ];
         case "Stop":
-            return mapped("turn.completed", optionalSummary(payload));
+            return [
+                mapped("turn.completed", optionalSummary(payload)),
+                mapped("native-work.snapshot", {
+                    snapshotComplete: payload.background_tasks_complete === true,
+                    observationQuality: payload.background_tasks_complete === true ? "exact" : "partial"
+                })
+            ];
         case "StopFailure":
             return mapped("turn.failed", claudeFailure(payload));
         case "SessionEnd":
-            return mapped("session.ended");
+            return [mapped("session.ended"), mapped("activation.ended")];
         default:
             throw new Error(`Claude Code Driver does not support Hook event: ${name}.`);
     }
@@ -135,7 +221,11 @@ function mapClaudeHook(name, payload, occurrenceId) {
 function mapCodexHook(name, payload, occurrenceId) {
     switch (name) {
         case "SessionStart":
-            return mapped("session.started");
+            return [
+                mapped("session.started"),
+                mapped("conversation.observed", { recoverability: "recoverable" }),
+                mapped("activation.started")
+            ];
         case "UserPromptSubmit":
             return mapped("turn.accepted");
         case "PreToolUse":
@@ -151,19 +241,76 @@ function mapCodexHook(name, payload, occurrenceId) {
                     ?? requireOccurrence(occurrenceId)
             });
         case "SubagentStart":
-            return operation("operation.started", "subagent", subagentId(payload));
+            return [
+                operation("operation.started", "subagent", subagentId(payload)),
+                continuationObservation("continuation.started", payload, {
+                    execution: "active",
+                    outcome: "pending",
+                    attachment: "attached",
+                    observationQuality: "partial",
+                    mayWriteWorkspace: true
+                })
+            ];
         case "SubagentStop":
-            return operation("operation.completed", "subagent", subagentId(payload));
+            return [
+                operation("operation.completed", "subagent", subagentId(payload)),
+                continuationObservation("continuation.reported", payload, {
+                    execution: "unknown",
+                    outcome: "unknown",
+                    attachment: "attached",
+                    observationQuality: "partial",
+                    mayWriteWorkspace: true,
+                    reportId: reportId(payload),
+                    ...optionalSummary(payload)
+                })
+            ];
         case "Stop":
             return mapped("turn.completed", optionalSummary(payload));
         case "SessionEnd":
-            return mapped("session.ended");
+            return [mapped("session.ended"), mapped("activation.ended")];
         default:
             throw new Error(`Codex Driver does not support Hook event: ${name}.`);
     }
 }
-function mapped(kind, payload = {}) {
-    return Object.freeze({ kind, payload: Object.freeze({ ...payload }) });
+function mapped(kind, payload = {}, fence) {
+    return Object.freeze({
+        kind,
+        payload: Object.freeze({ ...payload }),
+        ...(fence === undefined ? {} : { fence: Object.freeze({ ...fence }) })
+    });
+}
+function continuationObservation(kind, native, payload) {
+    const continuationId = subagentId(native);
+    const generation = continuationGeneration(native);
+    return mapped(kind, payload, {
+        continuationId,
+        continuationGeneration: generation,
+        ...(optionalIdentityFrom(native, ["parent_agent_id", "parent_subagent_id"]) === undefined
+            ? {}
+            : {
+                parentContinuationId: optionalIdentityFrom(native, ["parent_agent_id", "parent_subagent_id"])
+            })
+    });
+}
+function continuationGeneration(native) {
+    return typeof native.generation === "number"
+        && Number.isSafeInteger(native.generation) && native.generation >= 1
+        ? native.generation
+        : 1;
+}
+function reportId(payload) {
+    return optionalIdentityFrom(payload, ["report_id", "message_id", "agent_id", "subagent_id"])
+        ?? subagentId(payload);
+}
+function continuationOutcome(payload) {
+    if (payload.cancelled === true || payload.status === "cancelled")
+        return "cancelled";
+    if (payload.error !== undefined || payload.status === "failed")
+        return "failed";
+    if (payload.status === undefined || payload.status === "completed" || payload.status === "succeeded") {
+        return "succeeded";
+    }
+    return "unknown";
 }
 function operation(kind, operationKind, operationId) {
     return mapped(kind, { operationId, operation: operationKind });
@@ -209,7 +356,10 @@ function claudeFailure(payload) {
         failure: {
             code,
             ...(details === undefined ? {} : { details }),
-            ...(lastOutput === undefined ? {} : { lastOutput })
+            ...(lastOutput === undefined ? {} : { lastOutput }),
+            ...(payload.run_terminal === true || payload.unrecoverable === true
+                ? { runTerminal: true }
+                : {})
         },
         summary: [
             "Agent turn failed.",

package/dist/runtime/codexAppServerRuntime.js

@@ -0,0 +1,355 @@
+export class CodexAppServerRequestError extends Error {
+    code;
+    data;
+    name = "CodexAppServerRequestError";
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+}
+/**
+ * Continuable Codex integration over App Server. A transport connection is
+ * deliberately not an Activation identity: callers supply the persisted
+ * Conversation/Activation fence on every state-changing request.
+ */
+export class CodexAppServerRuntime {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async openConversation(input) {
+        const result = await this.transport.request("thread/start", {
+            cwd: text(input.cwd, "Codex thread cwd"),
+            ...(input.model === undefined ? {} : { model: input.model }),
+            ...(input.approvalPolicy === undefined ? {} : { approvalPolicy: input.approvalPolicy }),
+            ...(input.sandbox === undefined ? {} : { sandbox: input.sandbox }),
+            ...(input.developerInstructions === undefined
+                ? {}
+                : { developerInstructions: input.developerInstructions }),
+            ...(input.runtimeWorkspaceRoots === undefined
+                ? {}
+                : { runtimeWorkspaceRoots: [...input.runtimeWorkspaceRoots] })
+        });
+        return { conversationId: threadId(result) };
+    }
+    async resumeConversation(conversationId) {
+        const id = text(conversationId, "Codex thread id");
+        const result = await this.transport.request("thread/resume", { threadId: id });
+        return parseThreadSnapshot(result, id, true);
+    }
+    async readConversation(conversationId) {
+        const id = text(conversationId, "Codex thread id");
+        const result = await this.transport.request("thread/read", {
+            threadId: id,
+            includeTurns: true
+        });
+        return parseThreadSnapshot(result, id, "unknown");
+    }
+    async startTurn(input) {
+        const snapshot = await this.readConversation(input.conversationId);
+        if (input.expectedNoActiveTurn && snapshot.activeTurnId !== undefined) {
+            return { status: "not-accepted", reason: `active-turn:${snapshot.activeTurnId}` };
+        }
+        try {
+            const result = await this.transport.request("turn/start", {
+                threadId: snapshot.threadId,
+                ...(input.clientUserMessageId === undefined
+                    ? {}
+                    : { clientUserMessageId: text(input.clientUserMessageId, "Codex input attempt id") }),
+                input: [{ type: "text", text: text(input.text, "Codex Turn input") }]
+            });
+            const turnId = optionalId(result.turnId)
+                ?? optionalId(objectMember(result, "turn")?.id);
+            return turnId === undefined
+                ? { status: "unknown", reason: "turn/start returned no durable turn id" }
+                : { status: "accepted", turnId };
+        }
+        catch (error) {
+            return classifyMutationError(error);
+        }
+    }
+    async steerTurn(input) {
+        const threadId = text(input.conversationId, "Codex thread id");
+        const expectedTurnId = text(input.expectedTurnId, "Codex expected Turn id");
+        const snapshot = await this.readConversation(threadId);
+        if (snapshot.activeTurnId !== expectedTurnId) {
+            return {
+                status: "not-accepted",
+                reason: snapshot.activeTurnId === undefined
+                    ? "expected Turn is no longer active"
+                    : `active Turn changed to ${snapshot.activeTurnId}`
+            };
+        }
+        try {
+            const result = await this.transport.request("turn/steer", {
+                threadId,
+                expectedTurnId,
+                ...(input.clientUserMessageId === undefined
+                    ? {}
+                    : { clientUserMessageId: text(input.clientUserMessageId, "Codex input attempt id") }),
+                input: [{ type: "text", text: text(input.text, "Codex steer input") }]
+            });
+            const acceptedTurnId = optionalId(result.turnId);
+            if (acceptedTurnId === expectedTurnId)
+                return { status: "accepted", turnId: acceptedTurnId };
+            return acceptedTurnId === undefined
+                ? { status: "unknown", reason: "turn/steer returned no acceptance Turn id" }
+                : { status: "unknown", reason: `turn/steer returned mismatched Turn ${acceptedTurnId}` };
+        }
+        catch (error) {
+            return classifyMutationError(error);
+        }
+    }
+    async injectItems(input) {
+        const threadId = text(input.conversationId, "Codex thread id");
+        try {
+            await this.transport.request("thread/inject_items", {
+                threadId,
+                items: [{ type: "text", text: text(input.text, "Codex injected input") }]
+            });
+            return "accepted";
+        }
+        catch (error) {
+            const classified = classifyMutationError(error);
+            if (classified.status === "unknown")
+                return "unknown";
+            return isNotLoaded(error) ? "unavailable" : "not-accepted";
+        }
+    }
+    async interruptTurn(input) {
+        try {
+            await this.transport.request("turn/interrupt", {
+                threadId: text(input.conversationId, "Codex thread id"),
+                turnId: text(input.turnId, "Codex Turn id")
+            });
+            return "interrupted";
+        }
+        catch (error) {
+            const classified = classifyMutationError(error);
+            return classified.status === "not-accepted" ? "not-active" : "unknown";
+        }
+    }
+    async listKnownDescendants(input) {
+        const threadId = text(input.conversationId, "Codex thread id");
+        const result = await this.transport.request("thread/list", {
+            ancestorThreadId: threadId
+        });
+        const candidates = arrayMember(result, "threads")
+            .flatMap((entry) => optionalId(object(entry)?.id) === undefined
+            ? []
+            : [optionalId(object(entry)?.id)]);
+        // Ancestor filters are experimental: absence is never exact settlement.
+        return { quality: "partial", threadIds: Object.freeze([...new Set(candidates)]) };
+    }
+    /** Exact readback for child thread IDs already persisted by Yui. */
+    async queryKnownContinuations(input) {
+        if (input.providerNamespace !== "openai/codex") {
+            return { quality: "unavailable", continuations: [], detail: "provider mismatch" };
+        }
+        const observed = [];
+        try {
+            for (const continuation of input.continuations) {
+                const snapshot = await this.readConversation(continuation.continuationId);
+                const state = codexContinuationState(snapshot);
+                observed.push({
+                    key: [
+                        input.providerNamespace,
+                        input.accountScope,
+                        input.conversationId,
+                        input.activationId,
+                        continuation.continuationId,
+                        continuation.generation
+                    ].join("\u0000"),
+                    ...state
+                });
+            }
+        }
+        catch (error) {
+            return {
+                quality: "unavailable",
+                continuations: [],
+                detail: error instanceof Error ? error.message : String(error)
+            };
+        }
+        return { quality: "exact", continuations: Object.freeze(observed) };
+    }
+    async route(input) {
+        if (input.binding.adapterId !== "codex"
+            || input.binding.nativeSessionId !== input.fence.conversationId
+            || input.binding.launchId !== input.fence.activationId)
+            return "unsafe";
+        if (input.mode === "inject") {
+            return this.injectItems({
+                conversationId: input.fence.conversationId,
+                text: input.text
+            });
+        }
+        if (input.fence.nativeTurnId === undefined)
+            return "unsafe";
+        const outcome = await this.steerTurn({
+            conversationId: input.fence.conversationId,
+            expectedTurnId: input.fence.nativeTurnId,
+            text: input.text,
+            clientUserMessageId: input.attemptId
+        });
+        return outcome.status === "accepted" ? "accepted"
+            : outcome.status === "not-accepted" ? "not-accepted"
+                : "unknown";
+    }
+    async reconcile(input) {
+        if (input.binding.adapterId !== "codex"
+            || input.binding.nativeSessionId !== input.fence.conversationId
+            || input.binding.launchId !== input.fence.activationId)
+            return "unavailable";
+        // inject_items has no client receipt/idempotency field in the App Server
+        // protocol. A lost response therefore remains unknown and is never resent.
+        if (input.mode === "inject")
+            return "unknown";
+        try {
+            const snapshot = await this.readConversation(input.fence.conversationId);
+            return threadContainsClientInput(snapshot.raw, input.attemptId)
+                ? "accepted"
+                : "not-accepted";
+        }
+        catch (error) {
+            return isNotLoaded(error) ? "unavailable" : "unknown";
+        }
+    }
+}
+/** thread/closed means the loaded Activation ended; the durable thread remains resumable. */
+export function codexNotificationBoundary(input) {
+    const conversationId = optionalId(input.params.threadId)
+        ?? optionalId(objectMember(input.params, "thread")?.id);
+    const turnId = optionalId(input.params.turnId)
+        ?? optionalId(objectMember(input.params, "turn")?.id);
+    if (input.method === "thread/closed")
+        return { kind: "activation-ended", conversationId };
+    if (input.method === "turn/started")
+        return { kind: "turn-started", conversationId, turnId };
+    if (input.method === "turn/completed")
+        return { kind: "turn-completed", conversationId, turnId };
+    return { kind: "other", conversationId, turnId };
+}
+function parseThreadSnapshot(result, expectedThreadId, loaded) {
+    const thread = objectMember(result, "thread") ?? result;
+    const id = optionalId(thread.id) ?? expectedThreadId;
+    if (id !== expectedThreadId)
+        throw new Error("Codex App Server returned a different thread.");
+    const turns = arrayMember(thread, "turns").map(object).filter((entry) => (entry !== null));
+    const active = [...turns].reverse().find((turn) => (["inProgress", "in_progress", "running", "active"].includes(String(turn.status))));
+    const latestStatus = optionalTurnStatus(turns.at(-1)?.status);
+    return {
+        threadId: id,
+        loaded,
+        status: threadStatus(thread.status),
+        ...(optionalId(active?.id) === undefined ? {} : { activeTurnId: optionalId(active?.id) }),
+        ...(latestStatus === undefined ? {} : { latestTurnStatus: latestStatus }),
+        ...(optionalId(thread.parentThreadId) === undefined
+            ? {}
+            : { parentThreadId: optionalId(thread.parentThreadId) }),
+        ancestorThreadIds: Object.freeze(arrayMember(thread, "ancestorThreadIds").flatMap((entry) => (optionalId(entry) === undefined ? [] : [optionalId(entry)]))),
+        raw: result
+    };
+}
+function codexContinuationState(snapshot) {
+    if (snapshot.status === "active" || snapshot.latestTurnStatus === "inProgress") {
+        return {
+            execution: "active",
+            outcome: "pending",
+            mayWriteWorkspace: true
+        };
+    }
+    switch (snapshot.latestTurnStatus) {
+        case "completed":
+            return {
+                execution: "quiescent",
+                outcome: "succeeded",
+                resultRef: snapshot.threadId,
+                mayWriteWorkspace: false
+            };
+        case "interrupted":
+            return {
+                execution: "quiescent",
+                outcome: "cancelled",
+                resultRef: snapshot.threadId,
+                mayWriteWorkspace: false
+            };
+        case "failed":
+            return {
+                execution: "quiescent",
+                outcome: "failed",
+                resultRef: snapshot.threadId,
+                mayWriteWorkspace: false
+            };
+        default:
+            // notLoaded and thread/closed describe App Server attachment only. An
+            // idle thread without a terminal Turn is therefore still unknown.
+            return {
+                execution: "unknown",
+                outcome: "unknown",
+                mayWriteWorkspace: true
+            };
+    }
+}
+function threadStatus(value) {
+    const record = object(value);
+    const type = record?.type;
+    return type === "active" || type === "idle" || type === "systemError" || type === "notLoaded"
+        ? type
+        : "unknown";
+}
+function optionalTurnStatus(value) {
+    return value === "completed" || value === "interrupted"
+        || value === "failed" || value === "inProgress"
+        ? value
+        : undefined;
+}
+function threadContainsClientInput(raw, attemptId) {
+    const thread = objectMember(raw, "thread") ?? raw;
+    const turns = Array.isArray(thread.turns) ? thread.turns : [];
+    return turns.some((rawTurn) => {
+        const turn = object(rawTurn);
+        const items = turn === null || !Array.isArray(turn.items) ? [] : turn.items;
+        return items.some((rawItem) => {
+            const item = object(rawItem);
+            return item?.type === "userMessage" && item.clientId === attemptId;
+        });
+    });
+}
+function classifyMutationError(error) {
+    if (error instanceof CodexAppServerRequestError) {
+        if (["INVALID_PARAMS", "NOT_FOUND", "TURN_NOT_ACTIVE", -32602].includes(error.code)) {
+            return { status: "not-accepted", reason: error.message };
+        }
+    }
+    return { status: "unknown", reason: error instanceof Error ? error.message : String(error) };
+}
+function isNotLoaded(error) {
+    return error instanceof CodexAppServerRequestError
+        && (String(error.code).toLowerCase().includes("not_loaded")
+            || error.message.toLowerCase().includes("not loaded"));
+}
+function threadId(result) {
+    return text(optionalId(result.threadId) ?? optionalId(objectMember(result, "thread")?.id), "Codex thread id");
+}
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function objectMember(value, key) {
+    return object(value[key]);
+}
+function arrayMember(value, key) {
+    return Array.isArray(value[key]) ? value[key] : [];
+}
+function optionalId(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function text(value, label) {
+    if (typeof value !== "string" || value.includes("\0") || value.trim().length === 0) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return value.trim();
+}