@sema-agent/client-core 0.93.0 → 0.94.0

package/dist/skillToolListsCapability.js

@@ -1,16 +1,21 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
 export function projectSkillToolListsCapability(caps) {
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'skillToolLists'))
-        return { kind: 'not_reported' };
-    const v = caps.skillToolLists;
-    if (v === undefined)
-        return { kind: 'not_reported' };
-    if (typeof v !== 'boolean')
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        if (!Object.hasOwn(caps, 'skillToolLists'))
+            return { kind: 'not_reported' };
+        const v = caps.skillToolLists;
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        if (typeof v !== 'boolean')
+            return undefined;
+        return v ? { kind: 'present' } : { kind: 'absent' };
+    }
+    catch {
         return undefined;
-    return v ? { kind: 'present' } : { kind: 'absent' };
+    }
 }
 const reader = createEngineCapReader({
     name: 'skillToolLists',

package/dist/sqlEngineCapability.js

@@ -2,21 +2,26 @@ import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { capsGenerationOf, createEngineCapReader } from './engineCapReader.js';
 export function projectSqlEngineCapability(caps) {
-    if (caps === null || typeof caps !== 'object')
-        return undefined;
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+    try {
+        if (caps === null || typeof caps !== 'object')
+            return undefined;
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        const gen = capsGenerationOf(caps);
+        if (gen.generation === 'new') {
+            const store = gen.store;
+            if (!Object.hasOwn(store, 'sql'))
+                return { kind: 'none' };
+            const nested = store.sql;
+            if (nested === undefined)
+                return { kind: 'none' };
+            return projectSqlEngineView(nested);
+        }
+        return { kind: 'not_reported' };
+    }
+    catch {
         return undefined;
-    const gen = capsGenerationOf(caps);
-    if (gen.generation === 'new') {
-        const store = gen.store;
-        if (!Object.hasOwn(store, 'sql'))
-            return { kind: 'none' };
-        const nested = store.sql;
-        if (nested === undefined)
-            return { kind: 'none' };
-        return projectSqlEngineView(nested);
     }
-    return { kind: 'not_reported' };
 }
 function projectSqlEngineView(sql) {
     if (sql === null || typeof sql !== 'object')

package/dist/steerPriorityCapability.js

@@ -2,23 +2,28 @@ import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
 export function projectSteerPriorityCapability(caps) {
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'fleet'))
-        return { kind: 'not_reported' };
-    const fleet = caps.fleet;
-    if (fleet === undefined || fleet === false)
-        return { kind: 'not_reported' };
-    if (fleet === null || typeof fleet !== 'object' || Array.isArray(fleet))
-        return undefined;
-    if (!Object.hasOwn(fleet, 'steerPriority'))
-        return { kind: 'not_reported' };
-    const v = fleet.steerPriority;
-    if (v === undefined)
-        return { kind: 'not_reported' };
-    if (typeof v !== 'string' || v.length === 0)
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        if (!Object.hasOwn(caps, 'fleet'))
+            return { kind: 'not_reported' };
+        const fleet = caps.fleet;
+        if (fleet === undefined || fleet === false)
+            return { kind: 'not_reported' };
+        if (fleet === null || typeof fleet !== 'object' || Array.isArray(fleet))
+            return undefined;
+        if (!Object.hasOwn(fleet, 'steerPriority'))
+            return { kind: 'not_reported' };
+        const v = fleet.steerPriority;
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        if (typeof v !== 'string' || v.length === 0)
+            return undefined;
+        return { kind: 'present', word: v };
+    }
+    catch {
         return undefined;
-    return { kind: 'present', word: v };
+    }
 }
 const reader = createEngineCapReader({
     name: 'fleet.steerPriority',

package/dist/subagent/agentStateDetail.d.ts

@@ -0,0 +1 @@
+export declare function subagentStateDetail(carrier: unknown): string | undefined;

package/dist/subagent/agentStateDetail.js

@@ -0,0 +1,41 @@
+import { displayUntrusted } from '../displayUntrusted.js';
+function own(v, key) {
+    if (typeof v !== 'object' || v === null || Array.isArray(v))
+        return undefined;
+    try {
+        const d = Object.getOwnPropertyDescriptor(v, key);
+        return d !== undefined && 'value' in d ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const finite = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+const word = (v) => (typeof v === 'string' && v.trim() !== '' ? displayUntrusted(v, { max: 64 }) : undefined);
+function span(ms) {
+    const s = Math.floor(ms / 1000);
+    if (s < 60)
+        return `${String(s)} s`;
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${String(m)} min`;
+    return `${String(Math.floor(m / 60))} h`;
+}
+export function subagentStateDetail(carrier) {
+    const st = own(carrier, 'agentState');
+    const status = word(own(st, 'status'));
+    if (status === undefined)
+        return undefined;
+    const readAt = finite(own(st, 'readAt'));
+    const last = finite(own(st, 'lastActivityAt'));
+    const activity = readAt !== undefined && last !== undefined && last <= readAt ? `last activity ${span(readAt - last)} ago` : 'last activity unknown';
+    const approval = own(st, 'approval');
+    const approvalState = word(own(approval, 'state'));
+    let approvalPart = '';
+    if (approvalState !== undefined) {
+        const deadline = finite(own(approval, 'deadline'));
+        const when = deadline === undefined || readAt === undefined ? '' : deadline > readAt ? ` (deadline in ${span(deadline - readAt)})` : ' (deadline passed)';
+        approvalPart = ` · approval ${approvalState}${when}`;
+    }
+    return `Subagent state: ${status} · ${activity}${approvalPart}`;
+}

package/dist/subagent/engineCompactWire.d.ts

@@ -5,11 +5,26 @@ export type EngineCompactWireClient = {
     runs: Pick<AgentClient['runs'], 'compact'>;
 };
 export type EngineCompactWire = EngineWireInjection<EngineCompactWireClient>;
+export type EngineCompactOutcome = {
+    readonly kind: 'accepted';
+} | {
+    readonly kind: 'refused';
+    readonly status: number;
+    readonly errorCode?: string;
+} | {
+    readonly kind: 'failed';
+    readonly detail: string;
+    readonly status?: number;
+    readonly unconfirmed?: true;
+} | {
+    readonly kind: 'offline';
+};
 export declare function isEngineCompactPending(sessionKey?: string): boolean;
 export declare function resetManualCompactCapability(): void;
 export declare function __resetEngineCompactArmForTests(): void;
 export declare function requestEngineCompact(sessionKey?: string, opts?: {
     wire?: EngineCompactWire;
+    onSettled?: (outcome: EngineCompactOutcome) => void;
 }): 'fired' | 'armed' | 'offline' | 'unsupported';
 export declare function onEngineTaskBound(taskId: string, sessionKey?: string, opts?: {
     wire?: EngineCompactWire;

package/dist/subagent/engineCompactWire.js

@@ -1,5 +1,8 @@
 import { hostLog, hostTimersFor } from '../host.js';
-import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, settleInjected, } from '../engineWireFor.js';
+import { COMPACT_NOT_RUNNING, isUnavailableFaceCode } from '../engineErrorCodes.js';
+import { surfaceCompactNotRunning } from '../hitl/hitlHostSurface.js';
+import { wireFailureShapeOf, wireFailureTextsOf } from '../wireFailureShape.js';
+import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailFrom, settleInjected, } from '../engineWireFor.js';
 import { activeEngineRunIdFor, engineSessionParamFor } from '../engineSessionParam.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 function usableCompactClient(client) {
@@ -7,6 +10,7 @@ function usableCompactClient(client) {
 }
 const COMPACT_PROBE_SETTLE_MS = 5000;
 const pendingCompactKeys = new Set();
+const pendingCompactSinks = new Map();
 export function isEngineCompactPending(sessionKey = DEFAULT_SESSION_KEY) {
     return pendingCompactKeys.has(sessionKey);
 }
@@ -49,6 +53,7 @@ export function resetManualCompactCapability() {
 }
 export function __resetEngineCompactArmForTests() {
     pendingCompactKeys.clear();
+    pendingCompactSinks.clear();
 }
 function deferFire(ms, fn, why, sessionKey) {
     const timers = hostTimersFor(sessionKey);
@@ -80,26 +85,70 @@ function freezeCompactShot(taskId, sessionKey, wire) {
         ...(sid !== undefined ? { session: sid } : {}),
     };
 }
-async function postCompact(shot, retriesLeft = 1) {
+function emitCompactOutcome(sink, outcome) {
+    if (sink === undefined)
+        return;
+    void Promise.resolve().then(() => callSinkIsolated(sink, outcome));
+}
+function callSinkIsolated(sink, outcome) {
+    try {
+        sink(outcome);
+    }
+    catch (e) {
+        hostLog('debug', `engineCompactWire: onSettled sink threw (ignored): ${wireFailureTextsOf(e).log}`);
+    }
+}
+function fanOutCompactSinks(sinks) {
+    if (sinks === undefined || sinks.length === 0)
+        return undefined;
+    return (outcome) => {
+        for (const s of sinks)
+            callSinkIsolated(s, outcome);
+    };
+}
+function compactFailureOutcomeOf(e) {
+    const shape = wireFailureShapeOf(e);
+    const status = typeof shape.status === 'number' && Number.isFinite(shape.status) ? shape.status : undefined;
+    const code = shape.errorCode !== undefined && shape.errorCode !== '' ? shape.errorCode : undefined;
+    if (status !== undefined) {
+        if ((status >= 400 && status < 500) || isUnavailableFaceCode(code)) {
+            return { kind: 'refused', status, ...(code !== undefined ? { errorCode: code } : {}) };
+        }
+        return { kind: 'failed', status, detail: wireFailureTextsOf(e).reason };
+    }
+    const noAnswer = typeof e === 'object' && e !== null ? noAnswerDetailFrom(e) : null;
+    if (noAnswer !== null)
+        return { kind: 'failed', detail: noAnswer, unconfirmed: true };
+    return { kind: 'failed', detail: wireFailureTextsOf(e).reason };
+}
+async function postCompact(shot, sink, retriesLeft = 1) {
     const client = shot.client();
-    if (!client)
+    if (!client) {
+        emitCompactOutcome(sink, { kind: 'offline' });
         return;
+    }
     const taskId = shot.taskId;
     try {
         const fire = (signal) => client.runs.compact(taskId, { ...(shot.session !== undefined ? { session: shot.session } : {}), ...(signal ? { signal } : {}) });
         const ack = shot.injected ? await settleInjected(INJECTED_WIRE_SETTLE_MS, undefined, fire) : await fire(undefined);
         hostLog('debug', `engineCompactWire: POST compact ${taskId} → ok${ack?.status ? ` (${ack.status})` : ''}`);
+        emitCompactOutcome(sink, { kind: 'accepted' });
     }
     catch (e) {
-        const status = e?.status;
-        if (typeof status === 'number') {
-            hostLog('debug', `engineCompactWire: POST compact ${taskId} → ${status}`);
-            if (status === 404 && retriesLeft > 0) {
-                deferFire(2000, () => void postCompact(shot, retriesLeft - 1), '404 单次重试', shot.sessionKey);
-            }
-            return;
+        const outcome = compactFailureOutcomeOf(e);
+        if (outcome.kind === 'refused' || (outcome.kind === 'failed' && outcome.status !== undefined)) {
+            hostLog('debug', `engineCompactWire: POST compact ${taskId} → ${outcome.status}`);
+        }
+        else {
+            hostLog('debug', `engineCompactWire: compact fire failed (best-effort): ${wireFailureTextsOf(e).log}`);
         }
-        hostLog('debug', `engineCompactWire: compact fire failed (best-effort): ${String(e)}`);
+        if (outcome.kind === 'refused' && outcome.status === 404 && retriesLeft > 0) {
+            if (deferFire(2000, () => void postCompact(shot, sink, retriesLeft - 1), '404 单次重试', shot.sessionKey))
+                return;
+        }
+        if (outcome.kind === 'refused' && outcome.errorCode === COMPACT_NOT_RUNNING)
+            surfaceCompactNotRunning(shot.sessionKey);
+        emitCompactOutcome(sink, outcome);
     }
 }
 export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY, opts) {
@@ -113,13 +162,24 @@ export function requestEngineCompact(sessionKey = DEFAULT_SESSION_KEY, opts) {
         return 'unsupported';
     }
     const taskId = activeEngineRunIdFor(sessionKey);
+    const rawSink = opts?.onSettled;
+    const sink = typeof rawSink === 'function' ? rawSink : undefined;
     if (taskId) {
         const shot = freezeCompactShot(taskId, sessionKey, wire);
         if (shot !== null)
-            void postCompact(shot);
+            void postCompact(shot, sink);
+        else
+            emitCompactOutcome(sink, { kind: 'offline' });
         return 'fired';
     }
     pendingCompactKeys.add(sessionKey);
+    if (sink !== undefined) {
+        const sinks = pendingCompactSinks.get(sessionKey);
+        if (sinks === undefined)
+            pendingCompactSinks.set(sessionKey, [sink]);
+        else
+            sinks.push(sink);
+    }
     return 'armed';
 }
 const BOUND_FIRE_DELAY_MS = 1500;
@@ -132,7 +192,9 @@ export function onEngineTaskBound(taskId, sessionKey = DEFAULT_SESSION_KEY, opts
     const shot = freezeCompactShot(taskId, sessionKey, wire);
     if (shot === null)
         return;
-    if (deferFire(BOUND_FIRE_DELAY_MS, () => void postCompact(shot), 'bind 后发射', sessionKey)) {
+    const sink = fanOutCompactSinks(pendingCompactSinks.get(sessionKey));
+    if (deferFire(BOUND_FIRE_DELAY_MS, () => void postCompact(shot, sink), 'bind 后发射', sessionKey)) {
         pendingCompactKeys.delete(sessionKey);
+        pendingCompactSinks.delete(sessionKey);
     }
 }

package/dist/supportFloor.js

@@ -1,7 +1,7 @@
 export const SUPPORT_FLOOR = Object.freeze({
     server: '7.106.0',
     core: '7.35.2',
-    sdk: '12.0.1',
+    sdk: '18.1.0',
 });
 export function supportFloorOf(component) {
     if (component === 'server' || component === 'core' || component === 'sdk')

package/dist/taskRequestWords.d.ts

@@ -1,9 +1,8 @@
 import type { TaskRequest } from '@sema-agent/sdk';
 export type TaskRequestReasoningEffort = NonNullable<TaskRequest['reasoningEffort']>;
 export declare const REASONING_EFFORT_WORDS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-type SdkTaskRequestPermissionMode = NonNullable<TaskRequest['permissionMode']>;
-export type TaskRequestPermissionMode = SdkTaskRequestPermissionMode | 'dontAsk';
-export declare const PERMISSION_MODE_WORDS: readonly ["default", "plan", "acceptEdits", "bypassPermissions", "auto", "dontAsk"];
+export type TaskRequestPermissionMode = NonNullable<TaskRequest['permissionMode']>;
+export declare const PERMISSION_MODE_WORDS: readonly ["default", "acceptEdits", "plan", "auto", "bypassPermissions", "dontAsk"];
 export interface RetiredAttachmentsKey {
     readonly key: string;
     readonly why: string;
@@ -11,4 +10,3 @@ export interface RetiredAttachmentsKey {
     readonly remedy: string;
 }
 export declare function retiredAttachmentsKeyOf(nameOrToken: string, form?: 'token' | 'key'): RetiredAttachmentsKey | undefined;
-export {};

package/dist/taskRequestWords.js

@@ -1,6 +1,7 @@
+import { CORE_PERMISSION_MODES } from './generated/engineFactTables.js';
 export const REASONING_EFFORT_WORDS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
-export const PERMISSION_MODE_WORDS = ['default', 'plan', 'acceptEdits', 'bypassPermissions', 'auto', 'dontAsk'];
-const _taskRequestWordPins = [true, true, true, true];
+export const PERMISSION_MODE_WORDS = CORE_PERMISSION_MODES;
+const _taskRequestWordPins = [true, true, true, true, true, true];
 void _taskRequestWordPins;
 export function retiredAttachmentsKeyOf(nameOrToken, form = 'token') {
     const lower = nameOrToken.trim().toLowerCase();

package/dist/types/engineState.d.ts

@@ -1,5 +1,5 @@
 import type { EngineHealth } from '@sema-agent/sdk';
-export interface HealthResponse extends Pick<EngineHealth, 'status' | 'model' | 'sessionBackend' | 'sessions' | 'instanceId' | 'dataRoot' | 'configHash' | 'pid' | 'port' | 'restartRequired' | 'version'> {
+export interface HealthResponse extends Pick<EngineHealth, 'status' | 'model' | 'sessionBackend' | 'sessions' | 'instanceId' | 'dataRoot' | 'configHash' | 'pid' | 'port' | 'restartRequired' | 'version' | 'restart'> {
 }
 export interface EnginePortFile {
     port: number;

package/dist/userAttachmentEnvelope.d.ts

@@ -1,6 +1,13 @@
 import { type DescriptorView } from './humanTurnRead.js';
 export type UserAttachmentSource = 'at-mention' | 'compact-restore';
-export type UserAttachmentNotIncludedReason = 'too-large' | 'unreadable' | 'read-denied';
+export type UserAttachmentNotIncludedReason = 'too-large' | 'unreadable' | 'read-denied' | 'approval-required' | 'server-not-connected' | 'resource-not-listed' | 'read-failed';
+export type UserAttachmentMcpResourcePart = {
+    readonly kind: 'text';
+    readonly text: string;
+} | {
+    readonly kind: 'binary';
+    readonly mimeType: string | null;
+};
 export interface UserAttachmentNotebookCell {
     readonly cellType?: string;
     readonly source?: string;
@@ -54,6 +61,20 @@ export type UserAttachmentDescriptor = {
     readonly path: string;
     readonly sizeBytes: number | null;
     readonly reason: UserAttachmentNotIncludedReason;
+} | {
+    readonly kind: 'not-included';
+    readonly target: 'mcp-resource';
+    readonly server: string;
+    readonly uri: string;
+    readonly name: string;
+    readonly reason: UserAttachmentNotIncludedReason;
+} | {
+    readonly kind: 'mcp-resource';
+    readonly server: string;
+    readonly uri: string;
+    readonly name: string;
+    readonly parts: readonly UserAttachmentMcpResourcePart[];
+    readonly truncated: boolean;
 };
 export declare function showAttachmentName(s: string): string;
 export declare function mintEnvelopeOf(d: DescriptorView, imageDelivery: 'attached' | 'not-attached'): string;

package/dist/userAttachmentEnvelope.js

@@ -162,16 +162,93 @@ const NOT_INCLUDED_REASON = Object.freeze({
     'too-large': "it is larger than the client's size limit for attaching files",
     unreadable: 'the client could not read it',
     'read-denied': "the user's permission rules do not allow reading it",
+    'approval-required': "this deployment's rules require approval before it is read, so the client did not attach it without asking",
+    'server-not-connected': 'the MCP server it comes from is not connected',
+    'resource-not-listed': 'the MCP server does not list that resource',
+    'read-failed': 'reading it from the MCP server failed',
 });
 function targetWhat(target) {
     return target === 'directory' ? 'a directory' : target === 'file' ? 'a file' : 'a file or directory';
 }
+function mcpWhere(server, uri) {
+    return `Server: ${showAttachmentName(server)}. URI: ${showAttachmentName(uri)}`;
+}
+function mintMcpResource(d) {
+    const l1 = firstLine('at-mention', 'an MCP resource', d.name);
+    const texts = d.parts.flatMap((p) => (p.kind === 'text' ? [p.text] : []));
+    const binaries = d.parts.flatMap((p) => (p.kind === 'binary' ? [p.mimeType] : []));
+    const typed = [...new Set(binaries.filter((t) => t !== null))];
+    const binaryNote = binaries.length > 0
+        ? `${plural(binaries.length, 'binary part', 'binary parts')}${typed.length > 0 ? ` (${typed.map(showAttachmentName).join(', ')})` : ''} ${binaries.length === 1 ? 'is' : 'are'} not included.`
+        : null;
+    const truncNote = d.truncated ? 'The client shortened the text; the rest is not included.' : null;
+    if (texts.length === 0) {
+        return [`${l1}\n${mcpWhere(d.server, d.uri)} (no text parts). The client read it from that server; it has no text to include.`, binaryNote, truncNote].filter((s) => s !== null).join(' ');
+    }
+    let anyEscaped = false;
+    const body = texts
+        .join('\n')
+        .split('\n')
+        .map((line, i) => {
+        const shown = showBodyLine(line);
+        if (shown.escaped)
+            anyEscaped = true;
+        return `${i + 1}\t${shown.text}`;
+    });
+    const head = [
+        l1,
+        `${mcpWhere(d.server, d.uri)} (${plural(texts.length, 'text part', 'text parts')}). The client read it from that server and copied the text between the two fence lines below. ${dataNote('at-mention', "the resource's contents")}`,
+    ];
+    if (binaryNote !== null)
+        head.push(binaryNote);
+    if (truncNote !== null)
+        head.push(truncNote);
+    if (anyEscaped)
+        head.push(ESCAPE_NOTE);
+    return fenced(head, body);
+}
 function mintNotIncluded(d) {
+    if (d.target === 'mcp-resource') {
+        return `${firstLine('at-mention', 'an MCP resource', d.name)}\n${mcpWhere(d.server, d.uri)}. It is not included in this message: ${NOT_INCLUDED_REASON[d.reason]}.`;
+    }
     const size = sizePart(d.sizeBytes);
     return (`${firstLine('at-mention', targetWhat(d.target), d.name)}\n` +
         `Full path: ${showAttachmentName(d.path)}${size !== null ? ` (${size})` : ''}. It is not included in this message: ${NOT_INCLUDED_REASON[d.reason]}.`);
 }
-export function mintEnvelopeOf(d, imageDelivery) {
+const TAG_OPEN = '<attachment';
+const TAG_CLOSE = '</attachment>';
+function attributeValue(s) {
+    let out = '';
+    for (const c of s) {
+        switch (c) {
+            case '&':
+                out += '&amp;';
+                break;
+            case '"':
+                out += '&quot;';
+                break;
+            case '<':
+                out += '&lt;';
+                break;
+            case '>':
+                out += '&gt;';
+                break;
+            default:
+                out += c;
+        }
+    }
+    return out;
+}
+function pathOf(d) {
+    if (d.kind === 'mcp-resource' || (d.kind === 'not-included' && d.target === 'mcp-resource'))
+        return undefined;
+    return d.path;
+}
+function tagAttributes(d) {
+    const path = pathOf(d);
+    return path === undefined ? '' : ` path="${attributeValue(showAttachmentName(path))}"`;
+}
+function envelopeInner(d, imageDelivery) {
     switch (d.kind) {
         case 'text':
             return mintText(d);
@@ -185,10 +262,18 @@ export function mintEnvelopeOf(d, imageDelivery) {
             return mintDirectory(d);
         case 'not-included':
             return mintNotIncluded(d);
+        case 'mcp-resource':
+            return mintMcpResource(d);
     }
 }
-export function mintReferenceOf(d) {
+export function mintEnvelopeOf(d, imageDelivery) {
+    return `${TAG_OPEN}${tagAttributes(d)}>\n${envelopeInner(d, imageDelivery)}\n${TAG_CLOSE}`;
+}
+function referenceSentence(d) {
     const name = showAttachmentName(d.name);
+    if (d.kind === 'mcp-resource' || (d.kind === 'not-included' && d.target === 'mcp-resource')) {
+        return `The user mentioned the MCP resource ${name} (${showAttachmentName(d.uri)} on the server ${showAttachmentName(d.server)}) in this message; its contents are not included here.`;
+    }
     const path = showAttachmentName(d.path);
     const what = d.kind === 'directory' ? 'directory' : d.kind === 'not-included' ? targetWhat(d.target).replace(/^an? /, '') : 'file';
     if (d.kind !== 'directory' && d.kind !== 'not-included' && d.source === 'compact-restore') {
@@ -196,6 +281,9 @@ export function mintReferenceOf(d) {
     }
     return `The user mentioned the ${what} ${name} (${path}) in this message; its contents are not included here.`;
 }
+export function mintReferenceOf(d) {
+    return `${TAG_OPEN}${tagAttributes(d)} />\n${referenceSentence(d)}`;
+}
 export function mintUserAttachmentEnvelope(descriptor) {
     const d = readDescriptor(descriptor, 'required');
     if (d === undefined)

package/dist/userInvokedSkillsCapability.js

@@ -1,16 +1,21 @@
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
 export function projectUserInvokedSkillsCapability(caps) {
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'userInvokedSkills'))
-        return { kind: 'not_reported' };
-    const v = caps.userInvokedSkills;
-    if (v === undefined)
-        return { kind: 'not_reported' };
-    if (typeof v !== 'boolean')
+    try {
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        if (!Object.hasOwn(caps, 'userInvokedSkills'))
+            return { kind: 'not_reported' };
+        const v = caps.userInvokedSkills;
+        if (v === undefined)
+            return { kind: 'not_reported' };
+        if (typeof v !== 'boolean')
+            return undefined;
+        return v ? { kind: 'present' } : { kind: 'absent' };
+    }
+    catch {
         return undefined;
-    return v ? { kind: 'present' } : { kind: 'absent' };
+    }
 }
 const reader = createEngineCapReader({
     name: 'userInvokedSkills',

package/dist/webSearchBackendCapability.js

@@ -3,23 +3,28 @@ import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
 export const WEB_SEARCH_BACKEND_NONE = 'none';
 export function projectWebSearchBackendCapability(caps) {
-    if (caps === null || typeof caps !== 'object')
-        return undefined;
-    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
-        return undefined;
-    if (!Object.hasOwn(caps, 'webSearch'))
-        return { kind: 'not_reported' };
-    const ws = caps.webSearch;
-    if (ws === undefined)
-        return { kind: 'not_reported' };
-    if (ws === null || typeof ws !== 'object' || Array.isArray(ws))
-        return undefined;
-    const backend = ws.backend;
-    if (typeof backend !== 'string' || backend === '')
+    try {
+        if (caps === null || typeof caps !== 'object')
+            return undefined;
+        if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+            return undefined;
+        if (!Object.hasOwn(caps, 'webSearch'))
+            return { kind: 'not_reported' };
+        const ws = caps.webSearch;
+        if (ws === undefined)
+            return { kind: 'not_reported' };
+        if (ws === null || typeof ws !== 'object' || Array.isArray(ws))
+            return undefined;
+        const backend = ws.backend;
+        if (typeof backend !== 'string' || backend === '')
+            return undefined;
+        if (backend === WEB_SEARCH_BACKEND_NONE)
+            return { kind: 'none' };
+        return { kind: 'present', view: { backend } };
+    }
+    catch {
         return undefined;
-    if (backend === WEB_SEARCH_BACKEND_NONE)
-        return { kind: 'none' };
-    return { kind: 'present', view: { backend } };
+    }
 }
 const reader = createEngineCapReader({
     name: 'webSearch.backend',

package/dist/wireErrorTriage.d.ts

@@ -28,6 +28,17 @@ export declare function drainingRetryDelayMs(err: unknown, attempt: number, opts
     ladder?: readonly number[];
     retryAfterCapMs?: number;
 }): number;
+export declare function isInStreamDrainingEnd(frame: unknown): boolean;
+export declare const STREAM_DRAINING_RECONNECT_MAX = 3;
+export type StreamDrainingGiveUp = 'not_draining_end' | 'attempts_exhausted';
+export type StreamDrainingDecision = {
+    readonly reconnectAfterMs: number;
+} | {
+    readonly giveUp: StreamDrainingGiveUp;
+};
+export declare function streamDrainingDecision(frame: unknown, attempt: number, opts?: {
+    ladder?: readonly number[];
+}): StreamDrainingDecision;
 export interface ScenarioDenyDetail {
     allowlist: string[];
 }