@sema-agent/core 5.16.0 → 5.17.0

package/dist/core/canonical-json.js

@@ -39,20 +39,10 @@ function encode(value, depth = 0) {
                         out += encode(el, depth + 1);
                     return `${out}]`;
                 }
-                const obj = value;
-                const keys = Object.keys(obj).sort();
-                let out = `o${keys.length}:{`;
-                for (const k of keys) {
-                    let encoded;
-                    try {
-                        encoded = encode(obj[k], depth + 1);
-                    }
-                    catch {
-                        encoded = "<unreadable-property>";
-                    }
-                    out += `${Buffer.byteLength(k, "utf8")}:${k}=${encoded}`;
-                }
-                return `${out}}`;
+                const branded = encodeBranded(value, depth);
+                if (branded !== undefined)
+                    return branded;
+                return encodeOwnKeys(value, depth);
             }
             catch {
                 return "<unserializable>";
@@ -62,6 +52,178 @@ function encode(value, depth = 0) {
             return "U";
     }
 }
+function encodeOwnKeys(source, depth, skipIndicesBelow = 0) {
+    const obj = source;
+    const all = Object.keys(obj);
+    const keys = (skipIndicesBelow > 0 ? all.filter((k) => !isIndexBelow(k, skipIndicesBelow)) : all).sort();
+    let out = `o${keys.length}:{`;
+    for (const k of keys) {
+        let encoded;
+        try {
+            encoded = encode(obj[k], depth + 1);
+        }
+        catch {
+            encoded = "<unreadable-property>";
+        }
+        out += `${Buffer.byteLength(k, "utf8")}:${k}=${encoded}`;
+    }
+    return `${out}}`;
+}
+function isIndexBelow(key, limit) {
+    const n = Number(key);
+    return Number.isInteger(n) && n >= 0 && n < limit && String(n) === key;
+}
+function brandOf(value) {
+    try {
+        const s = Object.prototype.toString.call(value);
+        return s.startsWith("[object ") && s.endsWith("]") ? s.slice(8, -1) : "Object";
+    }
+    catch {
+        return "Object";
+    }
+}
+function encodeBranded(value, depth) {
+    const brand = brandOf(value);
+    if (brand === "Object")
+        return undefined;
+    if (ArrayBuffer.isView(value)) {
+        try {
+            const { buffer, byteOffset, byteLength, elements, family } = viewRange(value);
+            const bytesToken = digestBytes(new Uint8Array(buffer, byteOffset, byteLength));
+            return `V:${family}:${brand}:${byteLength}:${bytesToken}${encodeOwnKeys(value, depth, elements)}`;
+        }
+        catch {
+        }
+    }
+    const own = encodeOwnKeys(value, depth);
+    try {
+        switch (brand) {
+            case "Date": {
+                const t = Date.prototype.getTime.call(value);
+                return `D:${Number.isNaN(t) ? "Invalid" : encodeNumber(t)}${own}`;
+            }
+            case "Map": {
+                const size = Number(mapSizeGetter.call(value));
+                let out = `m${size}:{`;
+                let seen = 0;
+                for (const [k, v] of mapEntries.call(value)) {
+                    if (seen++ >= size)
+                        break;
+                    out += `${encode(k, depth + 1)}=${encode(v, depth + 1)}`;
+                }
+                return `${out}}${own}`;
+            }
+            case "Set": {
+                const size = Number(setSizeGetter.call(value));
+                let out = `t${size}:[`;
+                let seen = 0;
+                for (const v of setValues.call(value)) {
+                    if (seen++ >= size)
+                        break;
+                    out += encode(v, depth + 1);
+                }
+                return `${out}]${own}`;
+            }
+            case "RegExp": {
+                const source = String(regexpSourceGetter.call(value));
+                const flags = String(regexpFlagsGetter.call(value));
+                return `r${Buffer.byteLength(source, "utf8")}:${source}/${flags}${own}`;
+            }
+            case "Error": {
+                const name = String(value.name);
+                const message = String(value.message);
+                return `E${Buffer.byteLength(name, "utf8")}:${name}:${Buffer.byteLength(message, "utf8")}:${message}${own}`;
+            }
+            case "URL": {
+                const href = String(urlHrefGetter.call(value));
+                return `L${Buffer.byteLength(href, "utf8")}:${href}${own}`;
+            }
+            case "Boolean":
+            case "Number":
+            case "String":
+            case "BigInt":
+            case "Symbol": {
+                const unboxed = boxedValueOf[brand].call(value);
+                return `B:${encode(unboxed, depth + 1)}${own}`;
+            }
+            case "ArrayBuffer":
+            case "SharedArrayBuffer": {
+                const byteLength = Number((brand === "ArrayBuffer" ? arrayBufferByteLengthGetter : sharedArrayBufferByteLengthGetter).call(value));
+                return `A:${brand}:${byteLength}:${digestBytes(new Uint8Array(value))}${own}`;
+            }
+            default:
+                break;
+        }
+    }
+    catch {
+    }
+    return `x${Buffer.byteLength(brand, "utf8")}:${brand}${own}`;
+}
+function primordialGetter(proto, key) {
+    const get = Object.getOwnPropertyDescriptor(proto, key)?.get;
+    if (!get) {
+        return () => {
+            throw new Error(`no primordial getter for ${key}`);
+        };
+    }
+    return get;
+}
+const mapEntries = Map.prototype.entries;
+const setValues = Set.prototype.values;
+const mapSizeGetter = primordialGetter(Map.prototype, "size");
+const setSizeGetter = primordialGetter(Set.prototype, "size");
+const regexpSourceGetter = primordialGetter(RegExp.prototype, "source");
+const regexpFlagsGetter = primordialGetter(RegExp.prototype, "flags");
+const urlHrefGetter = primordialGetter(URL.prototype, "href");
+const arrayBufferByteLengthGetter = primordialGetter(ArrayBuffer.prototype, "byteLength");
+const sharedArrayBufferByteLengthGetter = typeof SharedArrayBuffer !== "undefined"
+    ? primordialGetter(SharedArrayBuffer.prototype, "byteLength")
+    : primordialGetter({}, "byteLength");
+const boxedValueOf = {
+    Boolean: Boolean.prototype.valueOf,
+    Number: Number.prototype.valueOf,
+    String: String.prototype.valueOf,
+    BigInt: BigInt.prototype.valueOf,
+    Symbol: Symbol.prototype.valueOf,
+};
+const typedArrayProto = Object.getPrototypeOf(Uint8Array.prototype);
+const typedArrayLengthGetter = primordialGetter(typedArrayProto, "length");
+const viewGetters = {
+    typed: {
+        buffer: primordialGetter(typedArrayProto, "buffer"),
+        byteOffset: primordialGetter(typedArrayProto, "byteOffset"),
+        byteLength: primordialGetter(typedArrayProto, "byteLength"),
+    },
+    dataView: {
+        buffer: primordialGetter(DataView.prototype, "buffer"),
+        byteOffset: primordialGetter(DataView.prototype, "byteOffset"),
+        byteLength: primordialGetter(DataView.prototype, "byteLength"),
+    },
+};
+function viewRange(view) {
+    for (const family of ["typed", "dataView"]) {
+        const g = viewGetters[family];
+        try {
+            const range = {
+                buffer: g.buffer.call(view),
+                byteOffset: Number(g.byteOffset.call(view)),
+                byteLength: Number(g.byteLength.call(view)),
+                elements: 0,
+                family,
+            };
+            if (family === "typed")
+                range.elements = Number(typedArrayLengthGetter.call(view));
+            return range;
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error("not a readable ArrayBuffer view");
+}
+function digestBytes(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
 function encodeNumber(n) {
     if (Number.isNaN(n))
         return "NaN";

package/dist/core/checkpoint-store.d.ts

@@ -283,9 +283,22 @@ export declare class CheckpointError extends Error {
     } | undefined);
 }
 export type StoreDurability = "durable" | "process-local";
+export type StoreFidelity = "structured-clone" | "json";
+export declare function resolveDeclaredFidelity(store: {
+    readonly fidelity?: StoreFidelity;
+} | undefined, storeName: string): StoreFidelity;
+export declare function encodeAtFidelity(fidelity: StoreFidelity, value: unknown): {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    cause: unknown;
+};
+export declare function samePlainValue(a: unknown, b: unknown): boolean;
 export interface CheckpointStore {
     readonly retention?: import("./retention.js").RetentionDeclaration;
     readonly durability?: StoreDurability;
+    readonly fidelity?: StoreFidelity;
     put(token: CheckpointToken, cp: Checkpoint): Promise<void>;
     get(token: CheckpointToken): Promise<Checkpoint | null>;
     resolve(token: CheckpointToken, scope: string, outcome: ResumeOutcome, expect?: ResolveExpectation): Promise<boolean>;
@@ -315,6 +328,7 @@ export type CheckpointFaultMode = "resolve-after-commit" | "resolve-before-commi
 export declare class InMemoryCheckpointStore implements CheckpointStore {
     readonly retention: "none";
     readonly durability: "process-local";
+    readonly fidelity: "structured-clone";
     private cps;
     private fault;
     put(token: CheckpointToken, cp: Checkpoint): Promise<void>;

package/dist/core/checkpoint-store.js

@@ -218,6 +218,78 @@ export class CheckpointError extends Error {
         this.name = "CheckpointError";
     }
 }
+export function resolveDeclaredFidelity(store, storeName) {
+    const declared = store?.fidelity;
+    if (declared === undefined)
+        return "json";
+    if (declared === "structured-clone" || declared === "json")
+        return declared;
+    const e = new Error(`${storeName}.fidelity declares ${JSON.stringify(declared)} — not a recognized StoreFidelity ` +
+        `("structured-clone" | "json"). Fix the declaration; an unparseable fidelity cannot be folded to either arm.`);
+    e.code = "config.store_fidelity_invalid";
+    throw e;
+}
+export function encodeAtFidelity(fidelity, value) {
+    if (fidelity === "structured-clone")
+        return { ok: true, value };
+    try {
+        const encoded = JSON.stringify(value);
+        return { ok: true, value: encoded === undefined ? undefined : JSON.parse(encoded) };
+    }
+    catch (err) {
+        return { ok: false, cause: err };
+    }
+}
+const MAX_SAME_VALUE_DEPTH = 256;
+export function samePlainValue(a, b) {
+    return sameValueAt(a, b, 0, new Map(), new Map());
+}
+function sameValueAt(a, b, depth, aToB, bToA) {
+    if (Object.is(a, b))
+        return true;
+    if (depth >= MAX_SAME_VALUE_DEPTH)
+        return false;
+    if (a === null || b === null || typeof a !== "object" || typeof b !== "object")
+        return false;
+    try {
+        const pairedWithA = aToB.get(a);
+        const pairedWithB = bToA.get(b);
+        if (pairedWithA !== undefined || pairedWithB !== undefined)
+            return pairedWithA === b && pairedWithB === a;
+        aToB.set(a, b);
+        bToA.set(b, a);
+        const proto = Object.getPrototypeOf(a);
+        if (proto !== Object.getPrototypeOf(b))
+            return false;
+        if (proto !== Object.prototype && proto !== Array.prototype)
+            return false;
+        if (Object.isExtensible(a) !== Object.isExtensible(b))
+            return false;
+        const ka = Reflect.ownKeys(a);
+        const kb = Reflect.ownKeys(b);
+        if (ka.length !== kb.length)
+            return false;
+        for (let i = 0; i < ka.length; i++) {
+            const k = ka[i];
+            if (k !== kb[i])
+                return false;
+            const da = Object.getOwnPropertyDescriptor(a, k);
+            const db = Object.getOwnPropertyDescriptor(b, k);
+            if (da === undefined || db === undefined)
+                return false;
+            if (!("value" in da) || !("value" in db))
+                return false;
+            if (da.enumerable !== db.enumerable || da.writable !== db.writable || da.configurable !== db.configurable)
+                return false;
+            if (!sameValueAt(da.value, db.value, depth + 1, aToB, bToA))
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 export function resolveCheckpointStore(spec, deps) {
     if (spec.checkpointStore === null)
         return undefined;
@@ -385,6 +457,7 @@ export function checkpointOccMatches(cp, expect) {
 export class InMemoryCheckpointStore {
     retention = "none";
     durability = "process-local";
+    fidelity = "structured-clone";
     cps = new Map();
     fault = null;
     async put(token, cp) {

package/dist/core/hooks.d.ts

@@ -123,6 +123,9 @@ export type ContentAskOutcome = {
     code: string;
     presentedInput?: unknown;
 };
+export interface ParkAttemptFailed {
+    parkFailed: string;
+}
 export interface ToolGateInput {
     onNotifyError?: (failure: import("./safe-notify.js").SafeNotifyFailure) => void;
     event: {
@@ -134,7 +137,7 @@ export interface ToolGateInput {
     hookEnv?: HookEnvCapabilities;
     adjudicate?: (req: ToolCallRequest) => Promise<PermissionResult>;
     resolveAsk: (decision: PermissionResult, req: ToolCallRequest) => Promise<ResolvedAsk>;
-    suspendAsk?: (req: ToolCallRequest, postHookArgs: unknown, safety?: import("./checkpoint-store.js").SafetyAxis, liveFaceUnavailable?: boolean) => Promise<ToolGateResult["suspend"] | undefined>;
+    suspendAsk?: (req: ToolCallRequest, postHookArgs: unknown, safety?: import("./checkpoint-store.js").SafetyAxis, liveFaceUnavailable?: boolean) => Promise<ToolGateResult["suspend"] | ParkAttemptFailed | undefined>;
     resolveContentAsk?: (req: ToolCallRequest) => Promise<ContentAskOutcome>;
     egress?: boolean;
     irreversibility?: "never" | "maybe" | "always";

package/dist/core/hooks.js

@@ -78,6 +78,14 @@ export function createHookEnvCapabilities(env) {
 export function formatHookFeedback(text) {
     return `<system-reminder>\n${text}\n</system-reminder>`;
 }
+const PARK_FAILURE_CAUSE_MAX = 600;
+function withParkFailureCause(reason, parkFailed) {
+    if (parkFailed === undefined)
+        return reason;
+    return (`${reason} — note: a durable approval park was attempted for this call FIRST and could not be minted ` +
+        `(${inlineUntrusted(parkFailed, PARK_FAILURE_CAUSE_MAX)}), so the refusal above is what the fallback had ` +
+        `left to say, not the reason the call stopped.`);
+}
 function preToolUseCrashReason(subject, err) {
     const raw = err instanceof Error ? err.message.trim() || err.name : String(err);
     const cause = inlineUntrusted(raw, 200);
@@ -126,6 +134,7 @@ export async function runToolGate(input) {
     let currentInput = event.input;
     const preToolContext = [];
     let hookAsk;
+    let parkFailed;
     const notifier = createSafeNotifier(input.onNotifyError !== undefined ? { onError: input.onNotifyError } : undefined);
     if (preToolUse) {
         let r;
@@ -241,7 +250,10 @@ export async function runToolGate(input) {
         if (suspendAsk && decision.action === "ask") {
             const suspended = await suspendAsk(req, currentInput, safety);
             if (suspended) {
-                return { suspend: suspended, preToolContext };
+                if ("parkFailed" in suspended)
+                    parkFailed = suspended.parkFailed;
+                else
+                    return { suspend: suspended, preToolContext };
             }
         }
         if (decision.action === "ask" && req.toolName === ASK_USER_QUESTION_TOOL_NAME) {
@@ -254,10 +266,13 @@ export async function runToolGate(input) {
                     currentInput = outcome.presentedInput;
                     req.args = outcome.presentedInput;
                 }
-                if (suspendAsk && outcome.parkDeclined) {
+                if (suspendAsk && outcome.parkDeclined && parkFailed === undefined) {
                     const suspended = await suspendAsk(req, currentInput, safety, true);
                     if (suspended) {
-                        return { suspend: suspended, preToolContext };
+                        if ("parkFailed" in suspended)
+                            parkFailed = suspended.parkFailed;
+                        else
+                            return { suspend: suspended, preToolContext };
                     }
                 }
                 decision = {
@@ -278,10 +293,13 @@ export async function runToolGate(input) {
         if (decision.action === "ask") {
             const resolved = await resolveAsk(decision, req);
             decision = resolved;
-            if (resolved.action === "deny" && resolved.approverUnavailable === true && suspendAsk) {
+            if (resolved.action === "deny" && resolved.approverUnavailable === true && suspendAsk && parkFailed === undefined) {
                 const suspended = await suspendAsk(req, currentInput, safety, true);
                 if (suspended) {
-                    return { suspend: suspended, preToolContext };
+                    if ("parkFailed" in suspended)
+                        parkFailed = suspended.parkFailed;
+                    else
+                        return { suspend: suspended, preToolContext };
                 }
             }
             if (decision.action === "allow" && decision.updatedInput !== undefined) {
@@ -369,7 +387,7 @@ export async function runToolGate(input) {
         }
     }
     if (decision.action === "deny") {
-        const denyReason = decisionText(decision) ?? `tool "${toolName}" denied by policy`;
+        const denyReason = withParkFailureCause(decisionText(decision) ?? `tool "${toolName}" denied by policy`, parkFailed);
         if (decision.updatedInput !== undefined) {
             currentInput = decision.updatedInput;
         }

package/dist/core/mailbox-store.d.ts

@@ -3,6 +3,7 @@ export interface MailboxMessage {
     from?: string;
     content: string;
     sentAt: number;
+    hopChain?: string[];
 }
 export interface MailboxLease {
     messages: MailboxMessage[];
@@ -12,6 +13,7 @@ export interface MailboxAppendMessage {
     from?: string;
     content: string;
     sentAt: number;
+    hopChain?: string[];
 }
 export interface MailboxStore {
     append(scope: string, handle: string, msg: MailboxAppendMessage): Promise<number>;

package/dist/core/mailbox-store.js

@@ -30,7 +30,7 @@ export class InMemoryMailboxStore {
             throw new Error("MailboxStore.append: refusing a message without a scope");
         const b = this.box(scope, handle);
         const seq = b.nextSeq++;
-        b.messages.push({ seq, ...(msg.from !== undefined ? { from: msg.from } : {}), content: msg.content, sentAt: msg.sentAt });
+        b.messages.push({ seq, ...(msg.from !== undefined ? { from: msg.from } : {}), content: msg.content, sentAt: msg.sentAt, ...(msg.hopChain !== undefined ? { hopChain: [...msg.hopChain] } : {}) });
         return seq;
     }
     async claimLease(scope, handle, owner, ttlMs, now = Date.now()) {
@@ -41,7 +41,7 @@ export class InMemoryMailboxStore {
             return null;
         const maxSeq = b.messages[b.messages.length - 1].seq;
         b.lease = { owner, expiresAt: now + ttlMs, maxSeq };
-        return { messages: b.messages.map((m) => ({ ...m })), maxSeq };
+        return { messages: b.messages.map((m) => ({ ...m, ...(m.hopChain !== undefined ? { hopChain: [...m.hopChain] } : {}) })), maxSeq };
     }
     async ack(scope, handle, owner, upToSeq) {
         const b = this.boxes.get(this.key(scope, handle));

package/dist/core/mcp.d.ts

@@ -60,6 +60,7 @@ export interface McpServerStatus {
 export declare const MCP_PREFIX: "mcp__";
 export declare function resolveMcpDeclaredResultSize(meta: Record<string, unknown> | undefined): number | undefined;
 export declare function gateMcpOutput(content: Array<TextContent | ImageContent>, limitTokens?: number): Array<TextContent | ImageContent>;
+export declare function structuredContentErrorLine(structuredContent: unknown, collectedText: string): string | undefined;
 export declare function truncateMcpErrorText(s: string): string;
 export declare const MCP_TOOL_TIMEOUT_DEFAULT_MS = 100000000;
 export declare function mcpToolTimeoutMs(): number;

package/dist/core/mcp.js

@@ -69,6 +69,18 @@ export function gateMcpOutput(content, limitTokens = mcpMaxOutputTokens()) {
 }
 const MCP_ERROR_HEAD_CHARS = 8_000;
 const MCP_ERROR_TAIL_CHARS = 2_000;
+const STRUCTURED_CONTENT_DEDUP_MIN_CHARS = 32;
+export function structuredContentErrorLine(structuredContent, collectedText) {
+    if (structuredContent === undefined)
+        return undefined;
+    const json = JSON.stringify(structuredContent);
+    if (json === undefined)
+        return undefined;
+    const distinctive = json.length >= STRUCTURED_CONTENT_DEDUP_MIN_CHARS && (json.startsWith("{") || json.startsWith("["));
+    if (distinctive && truncateMcpErrorText(collectedText.trim()).includes(json))
+        return undefined;
+    return `[structuredContent] ${truncateMcpErrorText(json)}`;
+}
 export function truncateMcpErrorText(s) {
     const max = MCP_ERROR_HEAD_CHARS + MCP_ERROR_TAIL_CHARS;
     if (s.length <= max)
@@ -1198,9 +1210,9 @@ function intakeListedTools(listed, spec, client, health, imageResizer) {
                         else
                             parts.push(`[${block.type} block omitted from error result]`);
                     }
-                    const errSc = res.structuredContent;
-                    if (errSc !== undefined)
-                        parts.push(`[structuredContent] ${truncateMcpErrorText(JSON.stringify(errSc))}`);
+                    const errScLine = structuredContentErrorLine(res.structuredContent, parts.join("\n"));
+                    if (errScLine !== undefined)
+                        parts.push(errScLine);
                     const body = truncateMcpErrorText(parts.join("\n").trim());
                     const msg = body
                         ? `MCP tool ${inlineUntrusted(remoteName)} reported an error. The server's error content follows as external/untrusted data:\n${delimitUntrusted(`${spec.name} tool error`, body)}`

package/dist/core/runner/prepare-task.d.ts

@@ -127,6 +127,7 @@ export interface Prepared {
     activeTools: Set<string>;
     deferredToolNames?: ReadonlySet<string>;
     toolMaterializeStatic: boolean;
+    deferDirectCall: boolean;
     staticFaceFor?: (name: string) => boolean;
     memoryEngineSession?: {
         engine: MemoryEngine;
@@ -339,6 +340,9 @@ export interface RunInternals {
     ownOrgAdmissionRef?: {
         current: import("../memory-admission.js").OwnOrgAdmissionVerdict | undefined;
     };
+    peerSelfRef?: import("../../agents/peer-admission.js").PeerSelfRef;
+    peerInboundChainRef?: import("../../agents/peer-admission.js").PeerInboundChainRef;
+    parentPeerRef?: import("../../agents/peer-admission.js").PeerSelfRef;
     workflowDepth?: number;
     insideFork?: boolean;
     isDelegatedChild?: boolean;