@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/agents/harness/execution-handle.js

@@ -1,49 +1,291 @@
 import { randomUUID } from "node:crypto";
-import { createEventChannel, createEventChannelOverflowError, isEventChannelOverflowError, } from "./event-channel.js";
-import { SubagentFailure } from "../types.js";
-export function createOverflowFailStream(channel) {
-    let drained = false;
-    let resolveDrained;
-    const drainedPromise = new Promise((resolve) => {
-        resolveDrained = resolve;
+import { AGENT_ACTIVITY_MAX_CHANGES, AGENT_EVENT_TEXT_MAX_CHARS, AGENT_UNKNOWN_PAYLOAD_MAX_CHARS, } from "./events.js";
+import { createEventChannel, EXEC_EVENT_BUFFER_HARD_CAP, } from "./event-channel.js";
+export function createTruncationMarker(envelope = {
+    seq: EXEC_EVENT_BUFFER_HARD_CAP,
+    at: new Date().toISOString(),
+    turn: 0,
+}) {
+    return {
+        type: "truncation",
+        limit: EXEC_EVENT_BUFFER_HARD_CAP,
+        admitted: EXEC_EVENT_BUFFER_HARD_CAP,
+        seq: envelope.seq,
+        at: envelope.at,
+        turn: envelope.turn,
+    };
+}
+export function overflowMarkerFromDropped(dropped) {
+    if (dropped.type === "truncation")
+        return dropped;
+    return createTruncationMarker({
+        seq: dropped.seq,
+        at: dropped.at,
+        turn: dropped.turn,
     });
-    const markDrained = () => {
-        if (drained)
-            return;
-        drained = true;
-        resolveDrained();
+}
+function truncateText(value) {
+    return {
+        value: value.slice(0, AGENT_EVENT_TEXT_MAX_CHARS),
+        truncated: value.length > AGENT_EVENT_TEXT_MAX_CHARS,
     };
+}
+function serializeUnknownPayload(value) {
+    let serialized;
+    try {
+        const encoded = JSON.stringify(value);
+        if (encoded === undefined) {
+            return {
+                payload: "null",
+                elided: { reason: "unserializable", retainedChars: 4 },
+            };
+        }
+        serialized = encoded;
+    }
+    catch {
+        serialized = "null";
+        return {
+            payload: serialized,
+            elided: { reason: "unserializable", retainedChars: serialized.length },
+        };
+    }
+    if (serialized.length <= AGENT_UNKNOWN_PAYLOAD_MAX_CHARS)
+        return { payload: serialized };
     return {
-        events: {
-            async *[Symbol.asyncIterator]() {
-                try {
-                    for await (const event of channel.iterable) {
-                        yield event;
-                    }
-                }
-                catch (error) {
-                    if (!isEventChannelOverflowError(error)) {
-                        throw error;
+        payload: serialized.slice(0, AGENT_UNKNOWN_PAYLOAD_MAX_CHARS),
+        elided: {
+            reason: "truncated",
+            originalChars: serialized.length,
+            retainedChars: AGENT_UNKNOWN_PAYLOAD_MAX_CHARS,
+        },
+    };
+}
+function normalizeBodyForPersistence(body) {
+    switch (body.type) {
+        case "message": {
+            const text = truncateText(body.text);
+            return { body: { ...body, text: text.value }, truncated: text.truncated };
+        }
+        case "unknown": {
+            const provider = truncateText(body.provider);
+            const nativeType = truncateText(body.nativeType);
+            const payload = truncateText(body.payload);
+            return {
+                body: {
+                    ...body,
+                    provider: provider.value,
+                    nativeType: nativeType.value,
+                    payload: payload.value,
+                    ...(payload.truncated && body.elided === undefined
+                        ? { elided: { reason: "truncated", originalChars: body.payload.length, retainedChars: payload.value.length } }
+                        : {}),
+                },
+                truncated: provider.truncated || nativeType.truncated || payload.truncated,
+            };
+        }
+        case "activity": {
+            const id = truncateText(body.id);
+            const tool = truncateText(body.tool);
+            let truncated = id.truncated || tool.truncated;
+            const text = (value) => {
+                const bounded = truncateText(value);
+                truncated ||= bounded.truncated;
+                return bounded.value;
+            };
+            const call = (() => {
+                switch (body.call.kind) {
+                    case "run":
+                        return {
+                            ...body.call,
+                            command: text(body.call.command),
+                            ...(body.call.description === undefined ? {} : { description: text(body.call.description) }),
+                        };
+                    case "read":
+                        return { ...body.call, path: text(body.call.path) };
+                    case "search":
+                        return { ...body.call, query: text(body.call.query) };
+                    case "fileChange": {
+                        const kept = body.call.changes.slice(0, AGENT_ACTIVITY_MAX_CHANGES);
+                        const dropped = body.call.changes.length - kept.length;
+                        truncated ||= dropped > 0;
+                        return {
+                            ...body.call,
+                            changes: kept.map((change) => ({ ...change, path: text(change.path) })),
+                            ...((body.call.omittedChanges ?? 0) + dropped > 0
+                                ? { omittedChanges: (body.call.omittedChanges ?? 0) + dropped }
+                                : {}),
+                        };
                     }
-                    yield {
-                        type: "fail",
-                        code: "PROJECTION_STATE_ERROR",
-                        message: error.message,
-                    };
-                }
-                finally {
-                    markDrained();
+                    case "other":
+                        return { ...body.call, display: text(body.call.display) };
                 }
-            },
-        },
-        whenDrained: () => drainedPromise,
+            })();
+            const result = body.result === undefined
+                ? undefined
+                : {
+                    ...body.result,
+                    ...(body.result.message === undefined ? {} : { message: text(body.result.message) }),
+                };
+            return {
+                body: {
+                    ...body,
+                    id: id.value,
+                    tool: tool.value,
+                    call,
+                    ...(result === undefined ? {} : { result }),
+                    ...(truncated ? { truncated: true } : {}),
+                },
+                truncated,
+            };
+        }
+        case "thought":
+        case "plan":
+        case "truncation":
+        case "turn":
+            return { body, truncated: false };
+        case "usage": {
+            const model = body.model === undefined ? undefined : truncateText(body.model);
+            return {
+                body: { ...body, ...(model ? { model: model.value } : {}) },
+                truncated: model?.truncated ?? false,
+            };
+        }
+        case "warning": {
+            const originalModel = body.warning.originalModel === undefined ? undefined : truncateText(body.warning.originalModel);
+            const fallbackModel = body.warning.fallbackModel === undefined ? undefined : truncateText(body.warning.fallbackModel);
+            const direction = body.warning.direction === undefined ? undefined : truncateText(body.warning.direction);
+            const requestId = body.warning.requestId === undefined || body.warning.requestId === null
+                ? undefined
+                : truncateText(body.warning.requestId);
+            const signerModel = body.warning.signerModel === undefined ? undefined : truncateText(body.warning.signerModel);
+            return {
+                body: {
+                    ...body,
+                    warning: {
+                        ...body.warning,
+                        ...(originalModel ? { originalModel: originalModel.value } : {}),
+                        ...(fallbackModel ? { fallbackModel: fallbackModel.value } : {}),
+                        ...(direction ? { direction: direction.value } : {}),
+                        ...(requestId ? { requestId: requestId.value } : {}),
+                        ...(signerModel ? { signerModel: signerModel.value } : {}),
+                    },
+                },
+                truncated: [originalModel, fallbackModel, direction, requestId, signerModel]
+                    .some((entry) => entry?.truncated === true),
+            };
+        }
+        case "diagnostic": {
+            const text = truncateText(body.text);
+            return { body: { ...body, text: text.value }, truncated: text.truncated };
+        }
+        case "done": {
+            const finalMessage = body.finalMessage === undefined ? undefined : truncateText(body.finalMessage);
+            return {
+                body: { ...body, ...(finalMessage ? { finalMessage: finalMessage.value } : {}) },
+                truncated: finalMessage?.truncated ?? false,
+            };
+        }
+        case "fail": {
+            const message = truncateText(body.message);
+            const diagnostics = body.diagnostics === undefined ? undefined : truncateText(body.diagnostics);
+            return {
+                body: {
+                    ...body,
+                    message: message.value,
+                    ...(diagnostics ? { diagnostics: diagnostics.value } : {}),
+                },
+                truncated: message.truncated || (diagnostics?.truncated ?? false),
+            };
+        }
+    }
+}
+export function prepareAgentEventForPersistence(event) {
+    const normalized = normalizeBodyForPersistence(event);
+    return {
+        ...normalized.body,
+        seq: event.seq,
+        at: event.at,
+        turn: event.turn,
+        ...(normalized.truncated ? { truncated: true } : {}),
     };
 }
 export function createProjectionDriver(input) {
+    if (input.initialTurn !== undefined
+        && (!Number.isSafeInteger(input.initialTurn) || input.initialTurn < 0)) {
+        throw new Error(`createProjectionDriver initialTurn must be a non-negative safe integer, got ${String(input.initialTurn)}`);
+    }
     const id = input.id ?? randomUUID();
     const abortController = new AbortController();
     let finishStarted = false;
-    let overflowed = false;
+    let nextSeq = 0;
+    let turn = input.initialTurn ?? 0;
+    let ordinaryAdmitted = 0;
+    let saturated = false;
+    let truncationPublished = false;
+    const nowMs = () => (input.now ?? Date.now)();
+    const nowIso = () => new Date(nowMs()).toISOString();
+    const admit = (body) => {
+        // Turn advance owns the builder ordinal for every submitted started body,
+        // including bodies that only produce the truncation marker or are dropped.
+        if (body.type === "turn" && body.phase === "started") {
+            if (turn >= Number.MAX_SAFE_INTEGER) {
+                throw new Error(`createProjectionDriver turn overflow: cannot advance past ${Number.MAX_SAFE_INTEGER}`);
+            }
+            turn += 1;
+        }
+        if (saturated) {
+            return undefined;
+        }
+        if (ordinaryAdmitted >= EXEC_EVENT_BUFFER_HARD_CAP) {
+            if (truncationPublished) {
+                saturated = true;
+                return undefined;
+            }
+            saturated = true;
+            truncationPublished = true;
+            const marker = createTruncationMarker({
+                seq: nextSeq,
+                at: nowIso(),
+                turn,
+            });
+            nextSeq += 1;
+            return marker;
+        }
+        const event = {
+            ...body,
+            seq: nextSeq,
+            at: nowIso(),
+            turn,
+        };
+        nextSeq += 1;
+        ordinaryAdmitted += 1;
+        return event;
+    };
+    const channel = createEventChannel({
+        createOverflowMarker: overflowMarkerFromDropped,
+    });
+    const publish = (event, meta) => {
+        channel.push(event, meta);
+    };
+    const emitBody = (body, meta) => {
+        if (meta?.coalesceKey) {
+            const prior = channel.peekCoalesced(meta.coalesceKey);
+            if (prior !== undefined) {
+                const updated = {
+                    ...body,
+                    seq: prior.seq,
+                    at: nowIso(),
+                    turn: prior.turn,
+                };
+                publish(updated, meta);
+                return;
+            }
+        }
+        const event = admit(body);
+        if (event === undefined)
+            return;
+        publish(event, event.type === "truncation" ? undefined : meta);
+    };
     let resolveCompletion;
     let rejectCompletion;
     const completion = new Promise((resolve, reject) => {
@@ -51,47 +293,33 @@ export function createProjectionDriver(input) {
         rejectCompletion = reject;
     });
     completion.catch(() => undefined);
-    const channel = createEventChannel({
-        onOverflow: () => {
-            overflowed = true;
-            if (!abortController.signal.aborted) {
-                abortController.abort();
-            }
-            void input.abort?.();
-        },
-    });
-    const eventStream = createOverflowFailStream(channel);
     const finish = (action) => {
         if (finishStarted)
             return;
         finishStarted = true;
         channel.close();
-        void eventStream.whenDrained().then(action, action);
+        void channel.whenDrained().then(action, action);
     };
-    const overflowFailure = () => new SubagentFailure("SUBAGENT_EXEC_ERROR", createEventChannelOverflowError().message, {
-        diagnostics: "PROJECTION_STATE_ERROR",
-    });
     const runPromise = (async () => {
         try {
             const outcome = await input.run({
-                emit(event, meta) {
-                    channel.push(event, meta);
+                emit(body, meta) {
+                    emitBody(body, meta);
+                },
+                ingress(provider, nativeType, payload, disposition, map) {
+                    input.onIngress?.();
+                    if (disposition === "unknown") {
+                        const bounded = serializeUnknownPayload(payload);
+                        emitBody({ type: "unknown", provider, nativeType, ...bounded });
+                        return;
+                    }
+                    map();
                 },
                 signal: abortController.signal,
             });
-            if (overflowed) {
-                finish(() => rejectCompletion(overflowFailure()));
-                return;
-            }
             finish(() => resolveCompletion(outcome));
         }
         catch (error) {
-            if (overflowed || isEventChannelOverflowError(error)) {
-                finish(() => rejectCompletion(error instanceof SubagentFailure && error.diagnostics === "PROJECTION_STATE_ERROR"
-                    ? error
-                    : overflowFailure()));
-                return;
-            }
             finish(() => rejectCompletion(error));
         }
     })();
@@ -102,9 +330,12 @@ export function createProjectionDriver(input) {
         });
     return {
         id,
-        events: eventStream.events,
+        events: channel.iterable,
         completion,
         steerMode: input.steerMode,
+        mintEvent(body) {
+            return admit(body);
+        },
         ...(enqueue ? { enqueue } : {}),
         ...(input.clearQueue ? { clearQueue: input.clearQueue } : {}),
         async abort() {