@zq-silk/yui 0.16.0 → 0.99.0

package/dist/runtime/codexAppServerRuntime.js

@@ -70,8 +70,12 @@ export class CodexAppServerRuntime {
     async readGoal(conversationId) {
         const id = text(conversationId, "Codex thread id");
         const result = await this.transport.request("thread/goal/get", { threadId: id });
+        if (result.goal === null)
+            return null;
         const goal = objectMember(result, "goal");
-        return goal === null ? null : codexThreadGoal(goal, id);
+        if (goal === null)
+            throw new Error("Codex thread/goal/get returned no Goal state.");
+        return codexThreadGoal(goal, id);
     }
     async inspectConversation(conversationId) {
         const id = text(conversationId, "Codex thread id");
@@ -162,8 +166,7 @@ export class CodexAppServerRuntime {
                         text_elements: []
                     }]
             });
-            const turnId = optionalId(result.turnId)
-                ?? optionalId(objectMember(result, "turn")?.id);
+            const turnId = optionalId(objectMember(result, "turn")?.id);
             return turnId === undefined
                 ? { status: "unknown", reason: "turn/start returned no durable turn id" }
                 : { status: "accepted", turnId };
@@ -244,7 +247,7 @@ export class CodexAppServerRuntime {
         const result = await this.transport.request("thread/list", {
             ancestorThreadId: threadId
         });
-        const candidates = arrayMember(result, "threads")
+        const candidates = arrayMember(result, "data")
             .flatMap((entry) => optionalId(object(entry)?.id) === undefined
             ? []
             : [optionalId(object(entry)?.id)]);
@@ -276,7 +279,7 @@ export class CodexAppServerRuntime {
             return {
                 quality: "unavailable",
                 continuations: [],
-                detail: error instanceof Error ? error.message : String(error)
+                detail: serializeAgentErrorRaw(error)
             };
         }
         return { quality: "exact", continuations: Object.freeze(observed) };
@@ -284,10 +287,12 @@ export class CodexAppServerRuntime {
 }
 /** thread/closed unloads the client attachment; 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);
+    const conversationId = input.method === "thread/started"
+        ? optionalId(objectMember(input.params, "thread")?.id)
+        : optionalId(input.params.threadId);
+    const turnId = input.method === "turn/started" || input.method === "turn/completed"
+        ? optionalId(objectMember(input.params, "turn")?.id)
+        : optionalId(input.params.turnId);
     if (input.method === "thread/closed")
         return { kind: "attachment-closed", conversationId };
     if (input.method === "thread/goal/updated")
@@ -310,45 +315,53 @@ export function codexGoalNotification(input) {
         return undefined;
     const goal = objectMember(input.params, "goal");
     if (goal === null)
-        return undefined;
+        throw new Error("Codex Goal notification has no Goal state.");
     return codexThreadGoal(goal, conversationId);
 }
 function parseThreadSnapshot(result, expectedThreadId, loaded) {
-    const thread = objectMember(result, "thread") ?? result;
-    const id = optionalId(thread.id) ?? expectedThreadId;
+    const thread = objectMember(result, "thread");
+    if (thread === null)
+        throw new Error("Codex App Server returned no thread.");
+    const id = text(optionalId(thread.id), "Codex response thread id");
     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);
-    const turnSnapshots = turns.flatMap((turn) => {
-        const turnId = optionalId(turn.id);
-        if (turnId === undefined)
-            return [];
+    const status = threadStatus(thread.status);
+    if (status === "unknown")
+        throw new Error("Codex thread status is missing or unsupported.");
+    if (!Array.isArray(thread.turns))
+        throw new Error("Codex thread turns are missing or invalid.");
+    const turnSnapshots = thread.turns.map((value) => {
+        const turn = object(value);
+        if (turn === null)
+            throw new Error("Codex thread contains an invalid Turn.");
+        const turnId = text(optionalId(turn.id), "Codex response Turn id");
         const status = optionalTurnStatus(turn.status);
+        if (status === undefined)
+            throw new Error("Codex Turn status is missing or unsupported.");
         const output = codexTurnOutput(turn);
         const error = providerError(turn.error);
-        return [{
-                turnId,
-                ...(status === undefined ? {} : { status }),
-                ...(output === undefined ? {} : { output }),
-                ...(error === undefined ? {} : { error }),
-                ...(turn.error === undefined || turn.error === null ? {} : {
-                    rawError: serializeAgentErrorRaw(turn.error)
-                })
-            }];
+        return {
+            turnId,
+            status,
+            ...(output === undefined ? {} : { output }),
+            ...(error === undefined ? {} : { error }),
+            ...(turn.error === undefined || turn.error === null ? {} : {
+                rawError: serializeAgentErrorRaw(turn.error)
+            })
+        };
     });
+    const active = [...turnSnapshots].reverse().find((turn) => turn.status === "inProgress");
+    const latestStatus = turnSnapshots.at(-1)?.status;
     return {
         threadId: id,
         loaded,
-        status: threadStatus(thread.status),
-        ...(optionalId(active?.id) === undefined ? {} : { activeTurnId: optionalId(active?.id) }),
+        status,
+        ...(active === undefined ? {} : { activeTurnId: active.turnId }),
         ...(latestStatus === undefined ? {} : { latestTurnStatus: latestStatus }),
         turns: Object.freeze(turnSnapshots),
         ...(optionalId(thread.parentThreadId) === undefined
             ? {}
             : { parentThreadId: optionalId(thread.parentThreadId) }),
-        ancestorThreadIds: Object.freeze(arrayMember(thread, "ancestorThreadIds").flatMap((entry) => (optionalId(entry) === undefined ? [] : [optionalId(entry)]))),
         raw: result
     };
 }
@@ -356,36 +369,9 @@ function parseThreadSnapshot(result, expectedThreadId, loaded) {
 export function codexTurnOutput(turn) {
     for (const value of [...arrayMember(turn, "items")].reverse()) {
         const item = object(value);
-        if (item === null)
-            continue;
-        const type = item.type;
-        const message = object(item.message);
-        const agentMessage = type === "agentMessage"
-            || type === "agent_message"
-            || (type === "message" && (item.role === "assistant" || message?.role === "assistant"));
-        if (!agentMessage)
-            continue;
-        const text = messageOutput(item) ?? (message === null ? undefined : messageOutput(message));
-        if (text !== undefined)
-            return text;
-    }
-    return undefined;
-}
-function messageOutput(message) {
-    for (const value of [message.text, message.content]) {
-        if (typeof value === "string" && value.trim().length > 0)
-            return value;
-        if (!Array.isArray(value))
-            continue;
-        const parts = value.flatMap((part) => {
-            if (typeof part === "string" && part.trim().length > 0)
-                return [part];
-            const record = object(part);
-            const text = record?.text ?? record?.content;
-            return typeof text === "string" && text.trim().length > 0 ? [text] : [];
-        });
-        if (parts.length > 0)
-            return parts.join("\n");
+        if (item?.type === "agentMessage"
+            && typeof item.text === "string" && item.text.trim().length > 0)
+            return item.text;
     }
     return undefined;
 }
@@ -393,33 +379,12 @@ function messageOutput(message) {
 export function codexTurnInput(turn) {
     for (const value of arrayMember(turn, "items")) {
         const item = object(value);
-        if (item === null)
-            continue;
-        const type = item.type;
-        const message = object(item.message);
-        const userMessage = type === "userMessage"
-            || type === "user_message"
-            || (type === "message" && (item.role === "user" || message?.role === "user"));
-        if (!userMessage)
-            continue;
-        const text = messageText(item) ?? (message === null ? undefined : messageText(message));
-        if (text !== undefined)
-            return text;
-    }
-    return undefined;
-}
-function messageText(message) {
-    for (const value of [message.text, message.content]) {
-        if (typeof value === "string" && value.trim().length > 0)
-            return value.trim();
-        if (!Array.isArray(value))
+        if (item?.type !== "userMessage")
             continue;
-        const parts = value.flatMap((part) => {
-            if (typeof part === "string" && part.trim().length > 0)
-                return [part];
+        const parts = arrayMember(item, "content").flatMap((part) => {
             const record = object(part);
-            const text = record?.text ?? record?.content;
-            return typeof text === "string" && text.trim().length > 0 ? [text] : [];
+            return record?.type === "text" && typeof record.text === "string"
+                && record.text.trim().length > 0 ? [record.text] : [];
         });
         if (parts.length > 0)
             return parts.join("\n").trim();
@@ -438,7 +403,7 @@ function providerError(value) {
     return JSON.stringify(record);
 }
 function codexThreadGoal(goal, expectedThreadId) {
-    const conversationId = text(goal.threadId, "Codex Goal thread id");
+    const conversationId = text(optionalId(goal.threadId), "Codex Goal thread id");
     if (conversationId !== expectedThreadId) {
         throw new Error("Codex Goal belongs to a different thread.");
     }
@@ -554,7 +519,7 @@ export function codexAppServerErrorIsMissing(error) {
         || /\b(not found|missing|does not exist)\b.*\b(thread|conversation)\b/u.test(message);
 }
 function threadId(result) {
-    return text(optionalId(result.threadId) ?? optionalId(objectMember(result, "thread")?.id), "Codex thread id");
+    return text(optionalId(objectMember(result, "thread")?.id), "Codex response thread id");
 }
 function object(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -568,7 +533,8 @@ 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;
+    return typeof value === "string" && !value.includes("\0") && value.length > 0
+        && value.trim() === value ? value : undefined;
 }
 function text(value, label) {
     if (typeof value !== "string" || value.includes("\0") || value.trim().length === 0) {

package/dist/runtime/jsonLineChannel.js

@@ -1,3 +1,4 @@
+import { serializeAgentErrorRaw } from "./agentError.js";
 export const PROVIDER_MESSAGE_MAX_BYTES = 16 * 1024 * 1024;
 /**
  * Newline-delimited JSON over a child process's stdio. This is a plain shared
@@ -7,13 +8,15 @@ export const PROVIDER_MESSAGE_MAX_BYTES = 16 * 1024 * 1024;
 export class JsonLineChannel {
     child;
     mirror;
+    onFailure;
     #listeners = new Set();
     #closeListeners = new Set();
     #buffer = "";
     #closedError;
-    constructor(child, mirror) {
+    constructor(child, mirror, onFailure) {
         this.child = child;
         this.mirror = mirror;
+        this.onFailure = onFailure;
         child.stdout.setEncoding("utf8");
         child.stdout.on("data", (chunk) => this.#receive(chunk));
         child.once("error", (error) => this.#close(error));
@@ -57,10 +60,12 @@ export class JsonLineChannel {
         });
     }
     #receive(chunk) {
+        if (this.#closedError !== undefined)
+            return;
         this.mirror("stdout", chunk);
         this.#buffer += chunk;
         if (Buffer.byteLength(this.#buffer, "utf8") > PROVIDER_MESSAGE_MAX_BYTES) {
-            this.#close(new Error("Provider response line exceeds its message bound."));
+            this.#fail(new Error("Provider response line exceeds its message bound."));
             terminateProcessGroup(this.child, "SIGTERM");
             return;
         }
@@ -72,18 +77,41 @@ export class JsonLineChannel {
             this.#buffer = this.#buffer.slice(newline + 1);
             if (line.length === 0)
                 continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch (cause) {
+                this.#fail(new Error("Provider response is not valid JSON.", { cause }));
+                return;
+            }
+            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+                this.#fail(new Error("Provider response must be a JSON object."));
+                return;
+            }
+            // Unknown protocol objects belong to the protocol listener. A listener
+            // throwing is not an unrelated notification or a parse error.
             try {
-                const parsed = JSON.parse(line);
-                if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
-                    continue;
                 for (const listener of this.#listeners)
                     listener(parsed);
             }
-            catch {
-                continue;
+            catch (cause) {
+                this.#fail(new Error("Provider message listener failed.", { cause }));
+                return;
             }
         }
     }
+    #fail(error) {
+        // Failing this pipe neither proves a native terminal nor permits replay.
+        // Keep the original cause for pending callers and the Host's durable sink.
+        try {
+            this.mirror("stderr", `${serializeAgentErrorRaw(error)}\n`);
+            this.onFailure?.(error);
+        }
+        finally {
+            this.#close(error);
+        }
+    }
     #close(error) {
         if (this.#closedError !== undefined)
             return;

package/dist/runtime/providerContinuationReconciliationService.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { serializeAgentErrorRaw, standardAgentError } from "./agentError.js";
 import { providerContinuationKey } from "./providerContinuation.js";
 import { projectProviderContinuations } from "./runtimeContinuationProjection.js";
 import { reconcileKnownDetachedContinuations } from "./providerRuntimeReconciler.js";
@@ -39,17 +40,55 @@ export class ProviderContinuationReconciliationService {
                         now
                     });
                 }
-                catch {
+                catch (error) {
                     // One malformed identity group must not restart or block the
                     // Controller. Keep it writer-owned and retry through the same
                     // bounded, metadata-only schedule.
-                    this.#schedules.set(groupKey, failureSchedule(groupKey, previous, now));
-                    continue;
+                    result = {
+                        continuations: group, quality: "unavailable", changed: false,
+                        schedule: failureSchedule(groupKey, previous, now),
+                        failure: standardAgentError({
+                            source: "yui", phase: "turn-reconcile",
+                            message: error instanceof Error ? error.message : String(error),
+                            raw: serializeAgentErrorRaw(error)
+                        })
+                    };
                 }
                 if (result.schedule === null)
                     this.#schedules.delete(groupKey);
                 else
                     this.#schedules.set(groupKey, result.schedule);
+                if (result.failure !== undefined) {
+                    const failure = result.failure;
+                    // One original failure and one circuit-limit notice, not one wake per
+                    // poll. Existing observations deduplicate across Controller restarts.
+                    const digest = createHash("sha256").update(JSON.stringify([
+                        task.id, candidates.map(entry => entry.fence), failure.raw,
+                        result.schedule?.circuitOpenUntil === undefined ? "unavailable" : "circuit-open"
+                    ])).digest("hex");
+                    const eventId = `continuation-reconcile-error:${digest}`;
+                    if (!events.some(event => event.payload.eventId === eventId
+                        || event.type === "runtime.agent-error" && event.payload.sourceEventId === eventId)) {
+                        const observation = createRuntimeObservation({
+                            schemaVersion: 4, eventId, semanticKey: eventId,
+                            kind: "observer.health", authority: "controller",
+                            receivedAt: now.toISOString(), observedAt: now.toISOString(),
+                            fence: candidates[0].fence,
+                            payload: {
+                                sourceId: "continuation-metadata", observerStatus: "unavailable",
+                                observerDetail: failure.message,
+                                failure: { error: { ...failure, raw: serializeAgentErrorRaw({
+                                            failure, targets: group.map(entry => entry.identity),
+                                            schedule: result.schedule,
+                                            confirmed: "Metadata query did not prove quiescence; existing writer ownership is preserved.",
+                                            unknown: "Continuation execution, result and external effects."
+                                        }) } }
+                            }
+                        });
+                        if (this.sink.observeRuntimeObservation(observation, now) === "applied")
+                            changedTaskIds.add(task.id);
+                    }
+                }
                 for (let index = 0; index < group.length; index += 1) {
                     const before = group[index];
                     const after = result.continuations[index];

package/dist/runtime/providerRetry.js

@@ -152,6 +152,21 @@ export function providerRetryProjection(binding) {
         category: retry.error.category, preservesWork: true, nativeSessionId: retry.nativeSessionId,
         ...(retry.reason === undefined ? {} : { reason: retry.reason }),
         failureRef: retry.failureRef,
+        error: retry.error,
+        inputRef: retry.input.kind === "text" ? { kind: "text" } : retry.input,
+        failedAttemptId: retry.failedAttemptId,
+        failureAttemptId: retry.failureAttemptId,
+        ...(retry.failedNativeTurnId === undefined ? {} : { failedNativeTurnId: retry.failedNativeTurnId }),
+        ...(retry.currentAttemptId === undefined ? {} : { currentAttemptId: retry.currentAttemptId }),
+        currentTurn: binding?.run == null ? null : {
+            attemptId: binding.run.attemptId, status: binding.run.status,
+            ...(binding.run.nativeTurnId === undefined ? {} : { nativeTurnId: binding.run.nativeTurnId }),
+            ...(binding.run.failure === undefined ? {} : { failure: binding.run.failure })
+        },
+        history: (binding?.retryHistory ?? []).map(entry => ({
+            chainId: entry.chainId, status: entry.status, attempts: entry.attempts,
+            failureRef: entry.failureRef, failedAttemptId: entry.failedAttemptId
+        })),
         ...(retry.previousRunId === undefined ? {} : { previousRunId: retry.previousRunId }),
         ...(retry.successorRunId === undefined ? {} : { successorRunId: retry.successorRunId })
     };

package/dist/runtime/providerRuntimeReconciler.js

@@ -1,4 +1,5 @@
 import { continuationOwnsWriterUmbrella, observeProviderContinuation, providerContinuationKey } from "./providerContinuation.js";
+import { serializeAgentErrorRaw, standardAgentError } from "./agentError.js";
 const BASE_RECONCILE_MS = 2_000;
 const MAX_RECONCILE_MS = 5 * 60_000;
 const CIRCUIT_ERROR_LIMIT = 5;
@@ -47,8 +48,11 @@ export async function reconcileKnownDetachedContinuations(input) {
             })))
         }), QUERY_TIMEOUT_MS);
         result = validateQueryResult(raw, new Set(candidates.map((entry) => (providerContinuationKey(entry.identity)))));
+        if (result.quality === "unavailable") {
+            throw new Error(result.detail ?? "Provider continuation metadata is unavailable.");
+        }
     }
-    catch {
+    catch (error) {
         const errors = (input.previous?.consecutiveErrors ?? 0) + 1;
         const delay = backoff(input.previous?.attempts ?? 0);
         const circuitOpenUntil = errors >= CIRCUIT_ERROR_LIMIT
@@ -64,7 +68,13 @@ export async function reconcileKnownDetachedContinuations(input) {
                 ...(circuitOpenUntil === undefined ? {} : { circuitOpenUntil })
             },
             quality: "unavailable",
-            changed: false
+            changed: false,
+            failure: standardAgentError({
+                source: "driver", phase: "turn-reconcile",
+                message: error instanceof Error ? error.message : String(error),
+                raw: serializeAgentErrorRaw(error),
+                inputDisposition: "unknown", sessionDisposition: "unknown"
+            })
         };
     }
     const observations = new Map(result.continuations.map((entry) => [entry.key, entry]));