@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/displayUntrusted.js

@@ -43,6 +43,9 @@ export function looksLikeKnownSecret(s) {
     for (let layer = 0; layer < 4; layer++) {
         if (scanForSecretLiteral(cur))
             return true;
+        const wide = percentBoundaryDecode(cur);
+        if (wide !== null && scanForSecretLiteral(wide.decoded))
+            return true;
         const next = percentDecodeForMatching(cur).decoded;
         if (next === cur)
             break;
@@ -301,7 +304,7 @@ function pathCandidates(src, base, path, opaqueSegments, edits, soft) {
         if (opaqueSegments) {
             let a = 0;
             let b = head.length;
-            while (a < b && !isKeyWordChar(head.charCodeAt(a)))
+            while (a < b && !isKeyWordChar(head.charCodeAt(a)) && !(head.charCodeAt(a) === 0x25 && hasNonAsciiPercentEscape(head.slice(a, a + 3))))
                 a++;
             while (b > a && !isKeyWordChar(head.charCodeAt(b - 1)))
                 b--;
@@ -1321,10 +1324,97 @@ function percentDecodeForMatching(text) {
     return { decoded: chars.join(''), offsets };
 }
 const PERCENT_ESCAPE_ASCII = /%[0-7][0-9A-Fa-f]/;
+function hasNonAsciiPercentEscape(text) {
+    return /%[89A-Fa-f][0-9A-Fa-f]/.test(text);
+}
+function isWellFormedUtf8(bytes) {
+    for (let i = 0; i < bytes.length;) {
+        const lead = bytes[i] ?? 0;
+        if (lead < 0x80) {
+            i += 1;
+            continue;
+        }
+        const need = utf8TailLength(lead);
+        if (need === 0)
+            return false;
+        for (let k = 1; k <= need; k++) {
+            const c = bytes[i + k];
+            const lo = k === 1 ? (lead === 0xe0 ? 0xa0 : lead === 0xf0 ? 0x90 : 0x80) : 0x80;
+            const hi = k === 1 ? (lead === 0xed ? 0x9f : lead === 0xf4 ? 0x8f : 0xbf) : 0xbf;
+            if (c === undefined || c < lo || c > hi)
+                return false;
+        }
+        i += need + 1;
+    }
+    return true;
+}
+function utf8TailLength(lead) {
+    if (lead >= 0xc2 && lead <= 0xdf)
+        return 1;
+    if (lead >= 0xe0 && lead <= 0xef)
+        return 2;
+    if (lead >= 0xf0 && lead <= 0xf4)
+        return 3;
+    return 0;
+}
+function percentBoundaryDecode(text) {
+    if (!hasNonAsciiPercentEscape(text))
+        return null;
+    const chars = [];
+    const from = [];
+    const to = [];
+    const escapeAt = (k) => text.charCodeAt(k) === 0x25 && isHexDigit(text.charAt(k + 1)) && isHexDigit(text.charAt(k + 2));
+    let i = 0;
+    while (i < text.length) {
+        if (!escapeAt(i)) {
+            chars.push(text.charAt(i));
+            from.push(i);
+            to.push(i + 1);
+            i += 1;
+            continue;
+        }
+        const bytes = [];
+        let j = i;
+        while (escapeAt(j)) {
+            bytes.push(Number.parseInt(text.slice(j + 1, j + 3), 16));
+            j += 3;
+        }
+        if (isWellFormedUtf8(bytes)) {
+            for (let k = 0; k < bytes.length;) {
+                const lead = bytes[k] ?? 0;
+                const len = lead < 0x80 ? 1 : utf8TailLength(lead) + 1;
+                let cp = len === 1 ? lead : lead & (0xff >> (len + 1));
+                for (let t = 1; t < len; t++)
+                    cp = (cp << 6) | ((bytes[k + t] ?? 0) & 0x3f);
+                const ch = String.fromCodePoint(cp);
+                for (let u = 0; u < ch.length; u++) {
+                    chars.push(ch.charAt(u));
+                    from.push(i + k * 3);
+                    to.push(i + (k + len) * 3);
+                }
+                k += len;
+            }
+        }
+        else {
+            for (let k = 0; k < bytes.length; k++) {
+                const b = bytes[k] ?? 0;
+                chars.push(b < 0x80 ? String.fromCharCode(b) : ' ');
+                from.push(i + k * 3);
+                to.push(i + k * 3 + 3);
+            }
+        }
+        i = j;
+    }
+    return { decoded: chars.join(''), from, to };
+}
+export function percentBoundaryReadingOf(text) {
+    const wide = percentBoundaryDecode(text);
+    return wide === null ? text : wide.decoded;
+}
 const MAX_PERCENT_VIEW_LAYERS = 3;
 function percentLayers(text) {
     const out = [];
-    if (!PERCENT_ESCAPE_ASCII.test(text))
+    if (!PERCENT_ESCAPE_ASCII.test(text) && !hasNonAsciiPercentEscape(text))
         return out;
     let cur = text;
     let ps = null;
@@ -1347,6 +1437,22 @@ function percentLayers(text) {
         ps = nps;
         pe = npe;
     }
+    const bases = [[text, null, null], ...out.map((l) => [l.text, l.ps, l.pe])];
+    for (const [base, bps, bpe] of bases) {
+        const wide = percentBoundaryDecode(base);
+        if (wide === null)
+            continue;
+        const n = wide.decoded.length;
+        const nps = new Int32Array(n);
+        const npe = new Int32Array(n);
+        for (let k = 0; k < n; k++) {
+            const a = wide.from[k] ?? 0;
+            const b = wide.to[k] ?? base.length;
+            nps[k] = bps === null ? a : (bps[a] ?? 0);
+            npe[k] = bpe === null ? b : (bpe[b - 1] ?? 0);
+        }
+        out.push({ text: wide.decoded, ps: nps, pe: npe });
+    }
     return out;
 }
 function firstLabelCutInPath(path, outer = false) {
@@ -3312,7 +3418,7 @@ function proseLiteralEdits(text) {
         let end = i;
         while (end < text.length && isKeyWordChar(text.charCodeAt(end)))
             end++;
-        const escHead = i > 0 && text.charCodeAt(i - 1) === 0x25 && PERCENT_ESCAPE_ASCII.test(text.slice(i - 1, i + 2)) && i + 2 < end ? 2 : 0;
+        const escHead = i > 0 && text.charCodeAt(i - 1) === 0x25 && (PERCENT_ESCAPE_ASCII.test(text.slice(i - 1, i + 2)) || hasNonAsciiPercentEscape(text.slice(i - 1, i + 2))) && i + 2 < end ? 2 : 0;
         const word = text.slice(i, end);
         if (word.startsWith('eyJ')) {
             let segEnd = end;
@@ -3809,11 +3915,12 @@ function screenSurfaces(text, o) {
 function percentSurfaces(raw, text, base, o) {
     const surfaces = [];
     const contents = [];
+    const locals = [];
     for (const layer of percentLayers(text))
-        layerSurfaces(raw, layer, base, o, surfaces, contents);
-    return { surfaces, contents };
+        layerSurfaces(raw, layer, base, o, surfaces, contents, true, base === null ? locals : undefined);
+    return { surfaces, contents, locals };
 }
-function layerSurfaces(raw, layer, base, o, surfaces, contents, decoded = true) {
+function layerSurfaces(raw, layer, base, o, surfaces, contents, decoded = true, locals) {
     const n = layer.text.length;
     const ps = new Int32Array(n);
     const pe = new Int32Array(n);
@@ -3835,6 +3942,52 @@ function layerSurfaces(raw, layer, base, o, surfaces, contents, decoded = true)
         surfaces.push(base === null ? { ...joined, rawDot: null, decoded } : { ...joined, decoded });
     for (const [a, b] of VD.contents)
         contents.push({ sub: layer.text.slice(a, b), rawAt: (k) => ps[a + k] ?? 0, rawEndAt: (k) => pe[a + k] ?? 0 });
+    if (locals !== undefined && decoded && base === null && hasLineBreakAny(layer.text)) {
+        locals.push({ text: layer.text, view: VD, ps, pe });
+        if (layer.text.includes('+')) {
+            const spaced = layer.text.split('+').join(' ');
+            locals.push({ text: spaced, view: buildScanView(spaced, o), ps, pe });
+        }
+    }
+}
+function hasLineBreakAny(text) {
+    for (let i = 0; i < text.length; i++) {
+        const c = text.charCodeAt(i);
+        if ((c === 0x0a || c === 0x0d || c === 0x5c) && lineBreakLengthAt(text, i) > 0)
+            return true;
+    }
+    return false;
+}
+function decodedLayerLocalCandidates(L, o, out) {
+    const layerSep = { ...separatedSurface(L.text, L.view), rawDot: null, decoded: true };
+    const layerJoined = joinedSurface(L.text, L.view);
+    const surfaces = layerJoined === null ? [layerSep] : [layerSep, { ...layerJoined, rawDot: null, decoded: true }];
+    const blocks = { raw: L.text, view: L.view, out: [], lines: [null, null], marks: null };
+    const found = [];
+    for (const S of surfaces) {
+        const cands = [];
+        const regions = [];
+        if (o.urls) {
+            const unitPos = (k) => S.dropped(k) || L.view.rawUnit[S.rawStart(k)] === 1;
+            urlCandidates(S.text, [], regions, unitPos, (k) => unitPos(k) || S.painted(k), o.queryByShape ?? false, o.wholeAddress === true, false);
+        }
+        runLabelPasses(S, regions, cands, blocks);
+        for (const c of cands) {
+            const r = toRaw(S, c);
+            if (r !== null)
+                found.push(r);
+        }
+    }
+    for (const r of blocks.out)
+        found.push(r);
+    for (const r of found) {
+        const start = L.ps[r.start];
+        const end = L.pe[r.end - 1];
+        if (start === undefined || end === undefined || end <= start)
+            continue;
+        const tokenEnd = r.tokenEnd > r.start ? (L.pe[Math.min(r.tokenEnd, L.text.length) - 1] ?? end) : end;
+        out.push({ ...r, start, end, tokenEnd });
+    }
 }
 function parserViewLayer(text) {
     if (!/[\t\n\r]/.test(text))
@@ -4107,6 +4260,13 @@ function toRaw(S, c) {
     const te = c.te > b ? S.rawEnd(c.te - 1) : S.rawEnd(b - 1);
     return { start: S.rawStart(a), end: S.rawEnd(b - 1), kind: c.kind, cls: c.cls, tokenEnd: te };
 }
+function runLabelPasses(S, regions, cands, blocks) {
+    labelCandidates(S, 'scheme', regions, cands, blocks);
+    labelCandidates(S, 'token', regions, cands, blocks);
+    labelCandidates(S, 'label', regions, cands, blocks);
+    labelCandidates(S, 'scheme', regions, cands, blocks, true);
+    labelCandidates(S, 'label', regions, cands, blocks, true);
+}
 function collectCandidates(text, o, nested) {
     const V = buildScanView(text, o);
     const separated = separatedSurface(text, V);
@@ -4134,19 +4294,23 @@ function collectCandidates(text, o, nested) {
     for (const S of surfaces) {
         const cands = [];
         const regions = [];
+        const unitPos = (k) => S.dropped(k) || V.rawUnit[S.rawStart(k)] === 1;
         if (o.urls) {
-            const unitPos = (k) => S.dropped(k) || V.rawUnit[S.rawStart(k)] === 1;
             urlCandidates(S.text, cands, regions, unitPos, (k) => unitPos(k) || S.painted(k), o.queryByShape ?? false, o.wholeAddress === true, o.wholeAddress === true && S.decoded !== true);
             userinfoCandidates(S, cands, o.words);
         }
+        else if (o.words && o.wholeAddress === true) {
+            const scratch = [];
+            const hostOnly = [];
+            urlCandidates(S.text, scratch, hostOnly, unitPos, (k) => unitPos(k) || S.painted(k), false, true, S.decoded !== true);
+            for (const r of hostOnly)
+                if (r[2] === 'host')
+                    regions.push(r);
+        }
         if (o.words) {
             editsToCandidates(pemEdits(S, (blk) => { if (S === regionSurface)
                 pemBlocksSeen.push(pemBlockToRaw(S, blk)); }), 'pem', cands);
-            labelCandidates(S, 'scheme', regions, cands, blocks);
-            labelCandidates(S, 'token', regions, cands, blocks);
-            labelCandidates(S, 'label', regions, cands, blocks);
-            labelCandidates(S, 'scheme', regions, cands, blocks, true);
-            labelCandidates(S, 'label', regions, cands, blocks, true);
+            runLabelPasses(S, regions, cands, blocks);
             editsToCandidates(authParamEdits(S.text), 'param', cands);
             editsToCandidates(proseLiteralEdits(S.text), 'prose', cands);
         }
@@ -4156,6 +4320,9 @@ function collectCandidates(text, o, nested) {
                 raw.push(S.rawDot !== null ? { ...r, dotted: true } : r);
         }
     }
+    if (o.words)
+        for (const L of decoded.locals)
+            decodedLayerLocalCandidates(L, o, raw);
     if (!nested) {
         for (const [a, b] of V.contents) {
             const sub = text.slice(a, b);
@@ -4778,7 +4945,42 @@ function isHighEntropyQueryValue(value) {
 }
 function isOpaqueSecretValue(value) {
     const core = valueCoreForJudging(value);
-    return core.length > 0 && (looksLikeKnownSecret(core) || isHighEntropyQueryValue(core));
+    if (core.length === 0)
+        return false;
+    if (looksLikeKnownSecret(core) || isHighEntropyQueryValue(core))
+        return true;
+    if (hasNonAsciiPercentEscape(core)) {
+        for (const chunk of percentByteChunks(core))
+            if (chunk.length > 0 && isHighEntropyQueryValue(chunk))
+                return true;
+    }
+    return false;
+}
+function percentByteChunks(text) {
+    const escapeAt = (k) => text.charCodeAt(k) === 0x25 && isHexDigit(text.charAt(k + 1)) && isHexDigit(text.charAt(k + 2));
+    const chunks = [];
+    let start = 0;
+    let i = 0;
+    while (i < text.length) {
+        if (!escapeAt(i)) {
+            i += 1;
+            continue;
+        }
+        let j = i;
+        let wide = false;
+        while (escapeAt(j)) {
+            if (text.charCodeAt(j + 1) >= 0x38)
+                wide = true;
+            j += 3;
+        }
+        if (wide) {
+            chunks.push(text.slice(start, i));
+            start = j;
+        }
+        i = j;
+    }
+    chunks.push(text.slice(start));
+    return chunks;
 }
 const VALUE_PIECE_SEPARATORS = new Set(['/', '\\', '?', '#', '&', '=', ';', ':', '@', ',', '+']);
 function hasOpaquePiece(text) {

package/dist/engineAgentPanelStore.d.ts

@@ -2,6 +2,10 @@ import { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, MAX_HELD_WIRE_T
 import type { EngineAgentPanelCycleIdentity } from './cycleOrder.js';
 export { isNewEngineAgentPanelCycle, isStaleEngineAgentPanelEnd, MAX_HELD_WIRE_TICK_BEATS };
 export type { EngineAgentPanelCycleIdentity, EnginePanelTaskIdentity };
+type PanelFinalityFlags = {
+    totalTokens?: true;
+    toolUses?: true;
+};
 export type EngineAgentPanelEvent = {
     kind: 'tick';
     taskId: string;
@@ -16,6 +20,8 @@ export type EngineAgentPanelEvent = {
     cardBound?: true;
     wireTaskId?: string;
     taskIdOrigin?: 'fleet-row' | 'wire';
+    cycleSeq?: number;
+    final?: PanelFinalityFlags;
 } | {
     kind: 'fleet-row';
     taskId: string;
@@ -33,10 +39,7 @@ export type EngineAgentPanelEvent = {
     parentToolCallId?: string;
     wireTaskId?: string;
     taskIdOrigin?: 'wire';
-    final?: {
-        totalTokens?: true;
-        toolUses?: true;
-    };
+    final?: PanelFinalityFlags;
 } | {
     kind: 'end';
     taskId: string;

package/dist/engineCapReader.js

@@ -11,7 +11,7 @@ function freezeReading(reading, seen = new Set()) {
     seen.add(reading);
     Object.freeze(reading);
     for (const d of Object.values(Object.getOwnPropertyDescriptors(reading))) {
-        if ('value' in d)
+        if (Object.hasOwn(d, 'value'))
             freezeReading(d.value, seen);
     }
     return reading;

package/dist/engineConfigDrift.js

@@ -3,7 +3,7 @@ function countOf(v) {
 }
 function ownValue(o, key) {
     const d = Object.getOwnPropertyDescriptor(o, key);
-    return d !== undefined && 'value' in d ? d.value : undefined;
+    return d !== undefined && Object.hasOwn(d, 'value') ? d.value : undefined;
 }
 export function readEngineConfigApplyState(health) {
     try {

package/dist/engineErrorCodes.d.ts

@@ -1,4 +1,6 @@
+import { SDK_STATUS_DERIVED_COARSE_CODES } from './generated/sdkFactTables.js';
 import type { RunDeathVerdictCode } from '@sema-agent/sdk';
+import type { SDKResultError } from '@sema-agent/agent-types';
 export declare const LIMITS_MAX_TOKENS_EXCEEDED = "limits.max_tokens_exceeded";
 export declare const LIMITS_MAX_COST_EXCEEDED = "limits.max_cost_exceeded";
 export declare const LIMITS_MAX_TURNS_EXCEEDED = "limits.max_turns_exceeded";
@@ -8,16 +10,16 @@ export declare const USAGE_WINDOW_EXHAUSTED = "usage.window_exhausted";
 export declare const ENV_LIFETIME_EXPIRED = "env.lifetime_expired";
 export declare const FLEET_LEASE_UNAVAILABLE = "fleet.lease_unavailable";
 export declare const CONFIG_LIMIT_INVALID = "config.limit_invalid";
-export declare const CONFIG_STRATEGY_FIND_LIMIT_INVALID = "config.strategy_find_limit_invalid";
-export declare const CONFIG_STRATEGY_MAX_SIZE_INVALID = "config.strategy_max_size_invalid";
 export declare const CONFIG_LIMIT_UNKNOWN_KEY = "config.limit_unknown_key";
 export declare const CONFIG_DELEGATION_ENTRY_CAPS = "config.delegation_entry_caps";
 export declare const CONFIG_MEMORY_PROJECT_KEY_SPELLING = "config.memory_project_key_spelling";
 export declare const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = "config.memory_write_scope_mismatch";
 export declare const CONFIG_LEGACY_TOOL_NAME = "config.legacy_tool_name";
 export declare const CONFIG_IMAGE_INVALID = "config.image_invalid";
-export declare function imageInvalidFailureNoteOf(code: string | undefined): string | undefined;
 export declare const CONFIG_AGENT_UNKNOWN_TOOL = "config.agent.unknown_tool";
+export declare const CONFIG_TOOL_FACE_CONTROL = "config.tool_face_control";
+export declare const CONFIG_MCP_SERVER_NAME_COLLISION = "config.mcp_server_name_collision";
+export declare const PROMPT_ASSEMBLED_ROLE_REFUSED = "prompt.assembled_role_refused";
 export declare const CONFIG_OUTPUT_STYLE_INVALID = "config.output_style_invalid";
 export declare const RULES_INERT_ENTRY = "rules.inert_entry";
 export declare const RULES_INVALID_SHAPE = "rules.invalid_shape";
@@ -29,12 +31,17 @@ export declare function isDelegationCapCode(code: string | undefined): boolean;
 export type DelegationCapDisposition = 'wait-for-slot' | 'reuse-existing-or-await-reap';
 export declare function delegationCapDispositionOf(code: string | undefined): DelegationCapDisposition | undefined;
 export declare const MCP_SERVER_REVOKED = "mcp.server_revoked";
+export declare const MCP_TOOL_DECLARATION_CHANGED = "mcp.tool_declaration_changed";
+export declare const MCP_TOOL_LISTING_UNREACHED = "mcp.tool_listing_unreached";
 export declare function isConfigRefusalCode(code: string | undefined): boolean;
 export declare const TOOL_END_INTERRUPTED_NEVER_STARTED = "interrupted_never_started";
 export declare const TOOL_END_INTERRUPTED_OUTCOME_UNKNOWN = "interrupted_outcome_unknown";
 export declare function isInterruptedToolEndCode(code: string | undefined): boolean;
 export declare const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = "capability.self_orchestration_required";
 export declare const CAPABILITY_IMAGE_INDEX_REQUIRED = "capability.image_index_required";
+export declare const CAPABILITY_K8S_LANE_REQUIRED = "capability.k8s_lane_required";
+export declare const NOT_FOUND_IMAGE = "not_found.image";
+export declare const REQUEST_PRECONDITION_UNMET = "request.precondition_unmet";
 export declare const GATE_PARKED_ERROR_CODE = "gate.parked";
 export declare const ACTIVE_RUN_BUSY_ERROR_CODE = "conflict.session_active_run";
 export declare const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = "conflict.idempotency_payload_mismatch";
@@ -59,8 +66,13 @@ export declare const STOP_NOT_LANDED = "stop.not_landed";
 export declare const STOP_NOT_LOCAL = "stop.not_local";
 export declare const STOP_PARKED = "stop.parked";
 export declare const OUTPUT_INVALID = "output.invalid";
+export type ResultLimitWord = 'wall_clock' | 'tokens' | 'turns' | 'budget_usd' | 'structured_output_retries';
+export declare const RESULT_LIMIT_WORDS: readonly ResultLimitWord[];
+export declare function resultLimitRowOfCode(code: string | undefined): {
+    readonly word: ResultLimitWord;
+    readonly subtype: SDKResultError['subtype'];
+} | undefined;
 export declare const RESUME_POLICY_FOLD_CODE = "resume_blocked_by_policy";
-export declare const STATUS_DERIVED_COARSE_CODES: readonly ["request.rejected", "auth.unauthorized", "auth.forbidden", "not_found.resource", "request.payload_too_large", "request.unprocessable", "limit.rate_exceeded", "capability.unavailable", "internal.error"];
 export declare function isStatusDerivedCoarseCode(code: string | null | undefined): boolean;
 export declare const RESUME_AT_ERROR_CODE_PREFIX = "resume_at.";
 export declare const REWIND_ERROR_CODE_PREFIXES: readonly ["resume_at.", "rewind_snapshot."];
@@ -77,7 +89,7 @@ export declare const CHECKPOINT_REFUSED_PARK_CODES: readonly string[];
 export declare function isRefusedParkCode(code: string | null | undefined): code is typeof CHECKPOINT_UNSUPPORTED_VERSION | typeof CHECKPOINT_WALLTIME_AXIS_RETIRED | typeof CHECKPOINT_CONFIG_REFUSED;
 export declare function refusalSaysStillPending(err: object): boolean;
 export declare function refusalRetriableReading(err: object): boolean | undefined;
-export type StatusDerivedCoarseCode = (typeof STATUS_DERIVED_COARSE_CODES)[number];
+export type StatusDerivedCoarseCode = (typeof SDK_STATUS_DERIVED_COARSE_CODES)[number];
 export declare const RESUME_PLACEMENT_MISMATCH = "resume.placement_mismatch";
 export declare const RESUME_CONTEXT_UNAVAILABLE = "conflict.resume_context_unavailable";
 export declare const RESUME_RETRY_LATER_CODES: readonly string[];
@@ -98,6 +110,8 @@ export declare const CONFLICT_NOT_RESUMABLE = "conflict.not_resumable";
 export declare const GATE_NOT_TOOL_APPROVAL = "gate_not_tool_approval";
 export declare const DECIDE_PARK_MOVED_CODES: readonly string[];
 export declare function isDecideParkMovedCode(code: string | null | undefined): boolean;
+export declare const DECIDE_ROW_UNREVIVABLE = "decide.row_unrevivable";
+export declare function isDecideRowUnrevivableCode(code: string | null | undefined): boolean;
 export declare const APPROVAL_STALE = "approval_stale";
 export declare const APPROVAL_BINDING_MISMATCH = "approval_binding_mismatch";
 export declare const CHECKPOINT_INVALID_OUTCOME = "checkpoint.invalid_outcome";
@@ -110,8 +124,11 @@ export declare const DECIDE_ALREADY_RESOLVED_CODES: readonly string[];
 export declare function isDecideAlreadyResolvedCode(code: string | null | undefined): boolean;
 export declare const ASK_GONE = "gone.ask";
 export declare const ASK_GONE_PARKED = "gone.ask_parked";
+export declare const ASK_NOT_FOUND = "not_found.ask";
+export declare const ASK_IDEMPOTENCY_CONFLICT = "conflict.ask_idempotency";
+export declare const ASK_PARKING_RETRY = "parking.ask_retry";
+export declare const ASK_DECISION_LANE_DISABLED = "feature.approval_ask_disabled";
 export declare const ASK_GONE_DENIED_WORD: "routing_failure_fail_closed";
-export declare const RUN_DEATH_VERDICT_CODES: readonly ["run.stalled", "run.orphaned", "approval.expired"];
 export type { RunDeathVerdictCode };
 export declare const RUN_STALLED: "run.stalled";
 export declare const RUN_ORPHANED: "run.orphaned";

package/dist/engineErrorCodes.js

@@ -1,6 +1,6 @@
 import { frozenSet } from './frozenSet.js';
 import { ownDataField } from './ownKey.js';
-import { SDK_DENY_REASON_ROUTING_FAILURE, SDK_RUN_DEATH_VERDICT_CODES, SDK_STATUS_DERIVED_COARSE_CODES } from './generated/sdkFactTables.js';
+import { SDK_DENY_REASON_ROUTING_FAILURE, SDK_STATUS_DERIVED_COARSE_CODES } from './generated/sdkFactTables.js';
 export const LIMITS_MAX_TOKENS_EXCEEDED = 'limits.max_tokens_exceeded';
 export const LIMITS_MAX_COST_EXCEEDED = 'limits.max_cost_exceeded';
 export const LIMITS_MAX_TURNS_EXCEEDED = 'limits.max_turns_exceeded';
@@ -13,20 +13,16 @@ export const USAGE_WINDOW_EXHAUSTED = 'usage.window_exhausted';
 export const ENV_LIFETIME_EXPIRED = 'env.lifetime_expired';
 export const FLEET_LEASE_UNAVAILABLE = 'fleet.lease_unavailable';
 export const CONFIG_LIMIT_INVALID = 'config.limit_invalid';
-export const CONFIG_STRATEGY_FIND_LIMIT_INVALID = 'config.strategy_find_limit_invalid';
-export const CONFIG_STRATEGY_MAX_SIZE_INVALID = 'config.strategy_max_size_invalid';
 export const CONFIG_LIMIT_UNKNOWN_KEY = 'config.limit_unknown_key';
 export const CONFIG_DELEGATION_ENTRY_CAPS = 'config.delegation_entry_caps';
 export const CONFIG_MEMORY_PROJECT_KEY_SPELLING = 'config.memory_project_key_spelling';
 export const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = 'config.memory_write_scope_mismatch';
 export const CONFIG_LEGACY_TOOL_NAME = 'config.legacy_tool_name';
 export const CONFIG_IMAGE_INVALID = 'config.image_invalid';
-const IMAGE_INVALID_FAILURE_NOTE = 'This run did not start: an image sent with the message was refused before the model was called — the engine’s own error text says which image and what is wrong with it. ' +
-    'Nothing was sent to the model; remove or replace that image, then send the message again.';
-export function imageInvalidFailureNoteOf(code) {
-    return code === CONFIG_IMAGE_INVALID ? IMAGE_INVALID_FAILURE_NOTE : undefined;
-}
 export const CONFIG_AGENT_UNKNOWN_TOOL = 'config.agent.unknown_tool';
+export const CONFIG_TOOL_FACE_CONTROL = 'config.tool_face_control';
+export const CONFIG_MCP_SERVER_NAME_COLLISION = 'config.mcp_server_name_collision';
+export const PROMPT_ASSEMBLED_ROLE_REFUSED = 'prompt.assembled_role_refused';
 export const CONFIG_OUTPUT_STYLE_INVALID = 'config.output_style_invalid';
 export const RULES_INERT_ENTRY = 'rules.inert_entry';
 export const RULES_INVALID_SHAPE = 'rules.invalid_shape';
@@ -51,6 +47,8 @@ export function delegationCapDispositionOf(code) {
     return undefined;
 }
 export const MCP_SERVER_REVOKED = 'mcp.server_revoked';
+export const MCP_TOOL_DECLARATION_CHANGED = 'mcp.tool_declaration_changed';
+export const MCP_TOOL_LISTING_UNREACHED = 'mcp.tool_listing_unreached';
 export function isConfigRefusalCode(code) {
     return typeof code === 'string' && code.startsWith('config.');
 }
@@ -65,6 +63,9 @@ export function isInterruptedToolEndCode(code) {
 }
 export const CAPABILITY_SELF_ORCHESTRATION_REQUIRED = 'capability.self_orchestration_required';
 export const CAPABILITY_IMAGE_INDEX_REQUIRED = 'capability.image_index_required';
+export const CAPABILITY_K8S_LANE_REQUIRED = 'capability.k8s_lane_required';
+export const NOT_FOUND_IMAGE = 'not_found.image';
+export const REQUEST_PRECONDITION_UNMET = 'request.precondition_unmet';
 export const GATE_PARKED_ERROR_CODE = 'gate.parked';
 export const ACTIVE_RUN_BUSY_ERROR_CODE = 'conflict.session_active_run';
 export const CONFLICT_IDEMPOTENCY_PAYLOAD_MISMATCH = 'conflict.idempotency_payload_mismatch';
@@ -112,10 +113,27 @@ export const STOP_NOT_LANDED = 'stop.not_landed';
 export const STOP_NOT_LOCAL = 'stop.not_local';
 export const STOP_PARKED = 'stop.parked';
 export const OUTPUT_INVALID = 'output.invalid';
+const RESULT_LIMIT_TABLE = Object.freeze([
+    Object.freeze({ code: LIMITS_MAX_TURNS_EXCEEDED, word: 'turns', subtype: 'error_max_turns' }),
+    Object.freeze({ code: LIMITS_MAX_COST_EXCEEDED, word: 'budget_usd', subtype: 'error_max_budget_usd' }),
+    Object.freeze({ code: OUTPUT_INVALID, word: 'structured_output_retries', subtype: 'error_max_structured_output_retries' }),
+    Object.freeze({ code: LIMITS_MAX_WALLTIME_EXCEEDED, word: 'wall_clock', subtype: 'error_during_execution' }),
+    Object.freeze({ code: LIMITS_MAX_TOKENS_EXCEEDED, word: 'tokens', subtype: 'error_during_execution' }),
+]);
+export const RESULT_LIMIT_WORDS = Object.freeze(RESULT_LIMIT_TABLE.map((r) => r.word));
+const _limitWordPins = [true, true];
+void _limitWordPins;
+export function resultLimitRowOfCode(code) {
+    if (typeof code !== 'string' || code.length === 0)
+        return undefined;
+    for (const row of RESULT_LIMIT_TABLE)
+        if (row.code === code)
+            return row;
+    return undefined;
+}
 export const RESUME_POLICY_FOLD_CODE = 'resume_blocked_by_policy';
-export const STATUS_DERIVED_COARSE_CODES = SDK_STATUS_DERIVED_COARSE_CODES;
 export function isStatusDerivedCoarseCode(code) {
-    return typeof code === 'string' && STATUS_DERIVED_COARSE_CODES.includes(code);
+    return typeof code === 'string' && SDK_STATUS_DERIVED_COARSE_CODES.includes(code);
 }
 export const RESUME_AT_ERROR_CODE_PREFIX = 'resume_at.';
 export const REWIND_ERROR_CODE_PREFIXES = Object.freeze([RESUME_AT_ERROR_CODE_PREFIX, 'rewind_snapshot.']);
@@ -189,6 +207,10 @@ export const DECIDE_PARK_MOVED_CODES = Object.freeze([
 export function isDecideParkMovedCode(code) {
     return typeof code === 'string' && DECIDE_PARK_MOVED_CODES.includes(code);
 }
+export const DECIDE_ROW_UNREVIVABLE = 'decide.row_unrevivable';
+export function isDecideRowUnrevivableCode(code) {
+    return typeof code === 'string' && code === DECIDE_ROW_UNREVIVABLE;
+}
 export const APPROVAL_STALE = 'approval_stale';
 export const APPROVAL_BINDING_MISMATCH = 'approval_binding_mismatch';
 export const CHECKPOINT_INVALID_OUTCOME = 'checkpoint.invalid_outcome';
@@ -208,8 +230,11 @@ export function isDecideAlreadyResolvedCode(code) {
 }
 export const ASK_GONE = 'gone.ask';
 export const ASK_GONE_PARKED = 'gone.ask_parked';
+export const ASK_NOT_FOUND = 'not_found.ask';
+export const ASK_IDEMPOTENCY_CONFLICT = 'conflict.ask_idempotency';
+export const ASK_PARKING_RETRY = 'parking.ask_retry';
+export const ASK_DECISION_LANE_DISABLED = 'feature.approval_ask_disabled';
 export const ASK_GONE_DENIED_WORD = SDK_DENY_REASON_ROUTING_FAILURE;
-export const RUN_DEATH_VERDICT_CODES = SDK_RUN_DEATH_VERDICT_CODES;
 const _runDeathVerdictCodePin = true;
 void _runDeathVerdictCodePin;
 export const RUN_STALLED = 'run.stalled';

package/dist/engineGenerationConvergence.d.ts

@@ -0,0 +1,39 @@
+export interface ApprovalWindowAnchor {
+    readonly receivedAtMs?: number;
+    readonly expiresInMs?: number;
+}
+export declare const ENGINE_GENERATION_WINDOW_MARGIN_MS = 5000;
+export declare const ENGINE_STOPPED_CALL_PHASES: readonly ["engine-stopped-awaiting-approval", "engine-stopped-before-result"];
+export type EngineStoppedCallPhase = (typeof ENGINE_STOPPED_CALL_PHASES)[number];
+export interface EndedGenerationCard {
+    readonly callKey: string;
+    readonly toolCallId?: string;
+    readonly parkRow: boolean;
+    readonly windowLeftMs?: number;
+    readonly closedByEngine?: boolean;
+}
+export interface EndedGenerationOpenedCall {
+    readonly toolCallId: string;
+    readonly generation: number;
+}
+export interface EndedGenerationPhaseHold {
+    readonly toolCallId: string;
+    readonly generation: number;
+}
+export interface EndedGenerationFacts {
+    readonly cards: readonly EndedGenerationCard[];
+    readonly opened: readonly EndedGenerationOpenedCall[];
+    readonly phases?: readonly EndedGenerationPhaseHold[];
+    readonly endedGeneration: number;
+}
+export interface EndedGenerationPhaseChange {
+    readonly toolCallId: string;
+    readonly phase: EngineStoppedCallPhase;
+    readonly viaCallKey?: string;
+}
+export interface EngineGenerationConvergence {
+    readonly retract: readonly string[];
+    readonly phases: readonly EndedGenerationPhaseChange[];
+}
+export declare function approvalWindowLeftMs(keys: Readonly<ApprovalWindowAnchor> | null | undefined, nowMs: number): number | undefined;
+export declare function convergeEndedEngineGeneration(facts: EndedGenerationFacts): EngineGenerationConvergence;