@sema-agent/client-core 0.84.1 → 0.85.1

package/dist/adapt/arms.js

@@ -141,7 +141,7 @@ const userArm = function* (m, { ctx, idOf }) {
 };
 const systemArm = function* (m, { ctx, idOf }) {
     yield transcript(m, ctx.now());
-    const attachedFiles = m._sema_attached_files ?? m.attachedFiles;
+    const attachedFiles = m._sema_attached_files;
     if (Array.isArray(attachedFiles)) {
         let i = 0;
         for (const f of attachedFiles) {

package/dist/adapt.d.ts

@@ -1,5 +1,5 @@
 import type { AdapterContext, AdapterOutput, WireToCcAdapter } from './seam.js';
-export { CANCEL_MESSAGE, estimateCjkTokens, flattenWireOutput, FLUSH_INTERVAL_MS, IDLE_FLUSH_MS, REJECT_MESSAGE, sanitizeToolUseBlock, shortTaskLabel, SUBAGENT_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './adapt/wireShapes.js';
+export { CANCEL_MESSAGE, estimateCjkTokens, flattenWireOutput, FLUSH_INTERVAL_MS, IDLE_FLUSH_MS, REJECT_MESSAGE, sanitizeToolUseBlock, SUBAGENT_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './adapt/wireShapes.js';
 export interface AdapterLedgerState {
     version: 1;
     renderedNotifications: string[];

package/dist/adapt.js

@@ -1,5 +1,5 @@
 import { isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, listNotifiedRuns, listWorkflowCompletionCardsEnqueued, markEngineWorkflowNotified, noteWorkflowCompletionCardEnqueued, parseTranscriptNotificationSeeds, } from './notifications.js';
-export { CANCEL_MESSAGE, estimateCjkTokens, flattenWireOutput, FLUSH_INTERVAL_MS, IDLE_FLUSH_MS, REJECT_MESSAGE, sanitizeToolUseBlock, shortTaskLabel, SUBAGENT_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './adapt/wireShapes.js';
+export { CANCEL_MESSAGE, estimateCjkTokens, flattenWireOutput, FLUSH_INTERVAL_MS, IDLE_FLUSH_MS, REJECT_MESSAGE, sanitizeToolUseBlock, SUBAGENT_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './adapt/wireShapes.js';
 import { IDLE_FLUSH_MS } from './adapt/wireShapes.js';
 import { chrome, mainLane, makeIdOf } from './adapt/ids.js';
 import { createTextStream } from './adapt/textStream.js';

package/dist/adapter/activeRunSelfHeal.d.ts

@@ -35,6 +35,7 @@ export type ReopenCardVerdict = {
     pendingRowGone?: true;
     _sema_decisionInFlight?: true;
     dismissedByUser?: true;
+    _sema_noPresentationSurface?: true;
 } | {
     reopened: true;
     firstSight: boolean;
@@ -86,6 +87,7 @@ export type SelfHealOutcome = {
     decisionInFlight?: true;
     pendingRowGone?: true;
     dismissedByUser?: true;
+    noPresentationSurface?: true;
 } | {
     kind: 'not-parked';
     taskId: string;
@@ -108,6 +110,7 @@ export type SelfHealOutcome = {
     decidePath: string | null;
     decisionInFlight?: true;
     pendingRowGone?: true;
+    noPresentationSurface?: true;
 } | {
     kind: 'ask-decided-without-card';
     taskId: string;

package/dist/adapter/activeRunSelfHeal.js

@@ -79,11 +79,105 @@ export function readCancelRequested(body) {
     const v = body.cancelRequested;
     return typeof v === 'boolean' ? v : undefined;
 }
+const REOPEN_VERDICT_KEYS = [
+    'reopened',
+    'firstSight',
+    'presented',
+    'decidedWithoutCard',
+    'pendingRowGone',
+    '_sema_decisionInFlight',
+    'dismissedByUser',
+    '_sema_noPresentationSurface',
+];
+function snapshotReopenVerdict(raw) {
+    if (raw === null || raw === undefined)
+        return { reopened: false };
+    if (typeof raw !== 'object' && typeof raw !== 'function')
+        return raw;
+    const src = raw;
+    let nullProto = false;
+    try {
+        nullProto = Object.getPrototypeOf(raw) === null;
+    }
+    catch {
+        nullProto = false;
+    }
+    const snap = nullProto ? Object.create(null) : {};
+    const put = (k, v) => {
+        Object.defineProperty(snap, k, { value: v, enumerable: true, writable: true, configurable: true });
+    };
+    let own = [];
+    try {
+        own = Reflect.ownKeys(raw);
+    }
+    catch {
+        own = [];
+    }
+    const copied = new Set();
+    for (const k of own) {
+        let enumerable = false;
+        try {
+            enumerable = Object.prototype.propertyIsEnumerable.call(raw, k);
+        }
+        catch {
+            enumerable = false;
+        }
+        if (!enumerable)
+            continue;
+        let v;
+        let readable = true;
+        try {
+            v = src[k];
+        }
+        catch {
+            readable = false;
+        }
+        if (!readable)
+            continue;
+        put(k, v);
+        copied.add(k);
+    }
+    for (const k of REOPEN_VERDICT_KEYS) {
+        if (copied.has(k))
+            continue;
+        let v;
+        let readable = true;
+        try {
+            v = src[k];
+        }
+        catch {
+            readable = false;
+        }
+        if (readable && v !== undefined)
+            put(k, v);
+    }
+    return snap;
+}
 function reopenRefusedForDecisionInFlight(verdict) {
-    return verdict !== null && verdict.reopened === false && verdict._sema_decisionInFlight === true;
+    try {
+        return verdict !== null && verdict.reopened === false && verdict._sema_decisionInFlight === true;
+    }
+    catch {
+        return false;
+    }
 }
 function reopenRefusedForUserDismissal(verdict) {
-    return verdict !== null && verdict.reopened === false && verdict.dismissedByUser === true;
+    try {
+        return verdict !== null && verdict.reopened === false && verdict.dismissedByUser === true;
+    }
+    catch {
+        return false;
+    }
+}
+function reopenRefusedForNoPresentationSurface(verdict) {
+    try {
+        return (verdict !== null &&
+            verdict.reopened === false &&
+            verdict._sema_noPresentationSurface === true);
+    }
+    catch {
+        return false;
+    }
 }
 function planReviewReopenTriggerFor(origin) {
     if (origin === 'user')
@@ -93,7 +187,31 @@ function planReviewReopenTriggerFor(origin) {
     return undefined;
 }
 function reopenDelivered(verdict) {
-    return verdict.reopened === true && verdict.presented !== false;
+    let reopened;
+    let presented;
+    try {
+        reopened = verdict.reopened;
+    }
+    catch {
+        return false;
+    }
+    if (reopened !== true)
+        return false;
+    try {
+        presented = verdict.presented;
+    }
+    catch {
+        presented = undefined;
+    }
+    return presented !== false;
+}
+function reopenedOfOutcome(outcome) {
+    try {
+        return outcome.reopened ?? null;
+    }
+    catch {
+        return null;
+    }
 }
 export function atMostOnceFailureClass(e) {
     const status = e?.status;
@@ -299,7 +417,7 @@ async function planVerdict(taskId, deps) {
     try {
         const trigger = planReviewReopenTriggerFor(deps?.submissionOrigin);
         const verdict = trigger === undefined ? deps?.reopenPlanReview?.(taskId) : deps?.reopenPlanReview?.(taskId, { trigger });
-        return (await verdict) ?? { reopened: false };
+        return snapshotReopenVerdict(await verdict);
     }
     catch {
         return { reopened: false };
@@ -307,7 +425,7 @@ async function planVerdict(taskId, deps) {
 }
 async function askVerdict(taskId, deps) {
     try {
-        return (await deps?.reopenAskPark?.(taskId)) ?? { reopened: false };
+        return snapshotReopenVerdict(await deps?.reopenAskPark?.(taskId));
     }
     catch {
         return { reopened: false };
@@ -324,6 +442,7 @@ async function planReviewArm(taskId, signal, deps) {
         ...(reopenRefusedForDecisionInFlight(verdict) ? { decisionInFlight: true } : {}),
         ...(verdict.pendingRowGone === true ? { pendingRowGone: true } : {}),
         ...(reopenRefusedForUserDismissal(verdict) ? { dismissedByUser: true } : {}),
+        ...(reopenRefusedForNoPresentationSurface(verdict) ? { noPresentationSurface: true } : {}),
     };
 }
 async function askParkArm(taskId, signal, runs, deps) {
@@ -364,6 +483,7 @@ async function askParkArm(taskId, signal, runs, deps) {
         decidePath: signal.pendingGate?.decidePath ?? null,
         ...(inFlight ? { decisionInFlight: true } : {}),
         ...(verdict.pendingRowGone === true ? { pendingRowGone: true } : {}),
+        ...(reopenRefusedForNoPresentationSurface(verdict) ? { noPresentationSurface: true } : {}),
     };
 }
 async function probeRunStatusOnce(taskId, durable, durableGet, deps) {
@@ -655,6 +775,7 @@ export function activeRunSelfHealRow(outcome, signal, copy, origin, follow) {
 }
 const INJECTED_LEAD = 'A follow-up message sema sent on its own (not one you typed)';
 const USER_CLOSED_CARD_NOT_PUT_BACK = 'sema does not put a card you closed back on screen by itself';
+const NO_CARD_VIEW_ATTACHED = 'this session has no view attached that can show decision cards';
 function injectedSubmissionRow(outcome, following = false) {
     const lead = INJECTED_LEAD;
     const id = 'taskId' in outcome && outcome.taskId ? ` (id ${outcome.taskId})` : '';
@@ -677,17 +798,19 @@ function injectedSubmissionRow(outcome, following = false) {
     }
     if (outcome.kind === 'running-steered' && outcome.delivery === 'queued') {
         const queuedOn = `${lead} is queued on an earlier reply${id} that is paused waiting for a decision`;
-        if (outcome.reopened !== null && reopenDelivered(outcome.reopened)) {
+        const reopened = reopenedOfOutcome(outcome);
+        if (reopened !== null && reopenDelivered(reopened)) {
             return `${queuedOn}; sema has shown that decision card, and the message is picked up once you answer it.`;
         }
-        if (reopenRefusedForDecisionInFlight(outcome.reopened)) {
+        if (reopenRefusedForDecisionInFlight(reopened)) {
             return `${queuedOn}; your answer to it is still on its way, and the message is picked up once that answer is applied.`;
         }
-        if (reopenRefusedForUserDismissal(outcome.reopened)) {
+        if (reopenRefusedForUserDismissal(reopened)) {
             return (`${queuedOn}; you closed that card yourself, so sema did not put it back on screen — send a message to bring it ` +
                 `back, and the message is picked up once that decision is made.`);
         }
-        return `${queuedOn} sema could not show here; the message is picked up only once that decision is made.`;
+        const noView = reopenRefusedForNoPresentationSurface(reopened) ? ` (${NO_CARD_VIEW_ATTACHED})` : '';
+        return `${queuedOn} sema could not show here${noView}; the message is picked up only once that decision is made.`;
     }
     if (outcome.kind === 'running-steered' && outcome.delivery === 'parked_for_wake') {
         return (`${lead} has not reached the model: the earlier reply${id} had already finished, so the message was set aside on it ` +
@@ -710,9 +833,13 @@ function injectedSubmissionRow(outcome, following = false) {
                     `sema is following that reply and will show whatever it asks for next; nothing for you to do now.`
                 : `${lead} was passed to the reply already in progress${id} instead of starting a new one — ` +
                     `watch that reply for what it does with it.`;
-        case 'not-delivered':
+        case 'not-delivered': {
+            const noView = (outcome.kind === 'ask-reopen-failed' || outcome.kind === 'plan-review-reopen-failed') && outcome.noPresentationSurface === true
+                ? ` (${NO_CARD_VIEW_ATTACHED})`
+                : '';
             return (`${lead} was not delivered: this session was still busy with an earlier reply${id}, and there was no open card ` +
-                `you could answer to free it. sema did not retry, so the model has not seen it.`);
+                `you could answer to free it${noView}. sema did not retry, so the model has not seen it.`);
+        }
     }
 }
 function decisionInFlightRow(parkedOn) {
@@ -780,8 +907,9 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
             const viaEngine = engineDecide && outcome.decidePath
                 ? ` You can also decide it on the engine directly: POST ${outcome.decidePath}.`
                 : '';
+            const noView = outcome.noPresentationSurface === true ? `: ${NO_CARD_VIEW_ATTACHED}` : '';
             return (`The previous turn is parked waiting for your decision (run ${outcome.taskId}) and sema could ` +
-                `not reopen that card here. It did NOT cancel the run — that would have decided it for you. ` +
+                `not reopen that card here${noView}. It did NOT cancel the run — that would have decided it for you. ` +
                 (keepSessionWayOut !== null
                     ? `Your message was NOT sent. To keep this conversation, ${keepSessionWayOut}: the card comes back when the session resumes, if it is still waiting. Or ${wayOut} if you no longer want it.${viaEngine}`
                     : `Your message was NOT sent; ${wayOut} if you no longer want it.${viaEngine}`));
@@ -797,8 +925,9 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
             const viaEngine = engineDecide && outcome.decidePath
                 ? ` You can also decide it on the engine directly: POST ${outcome.decidePath}.`
                 : '';
+            const noView = outcome.noPresentationSurface === true ? `: ${NO_CARD_VIEW_ATTACHED}` : '';
             return (`The previous turn is parked waiting for a plan review (run ${outcome.taskId}) and sema could not ` +
-                `reopen that approval card. It did NOT cancel the run — that would have discarded the plan for ` +
+                `reopen that approval card${noView}. It did NOT cancel the run — that would have discarded the plan for ` +
                 (keepSessionWayOut !== null
                     ? `you. Your message was NOT sent. To keep this conversation, ${keepSessionWayOut}: the card comes back when the session resumes, if it is still waiting. Or ${wayOut} if you no longer want that plan.${viaEngine}`
                     : `you. Your message was NOT sent; ${wayOut} if you no longer want that plan.${viaEngine}`));
@@ -816,15 +945,18 @@ function activeRunSelfHealBaseRow(outcome, signal, wayOut, following = false, ke
             }
             if (outcome.delivery === 'queued') {
                 const parked = outcome.status ? `parked (status ${outcome.status})` : 'parked';
-                const next = outcome.reopened !== null && reopenDelivered(outcome.reopened)
+                const reopened = reopenedOfOutcome(outcome);
+                const next = reopened !== null && reopenDelivered(reopened)
                     ? `sema has surfaced that decision card — answering it is what lets that run resume and pick your message up.`
-                    : reopenRefusedForDecisionInFlight(outcome.reopened)
+                    : reopenRefusedForDecisionInFlight(reopened)
                         ? `Your answer to that decision is still on its way to the engine, so sema did not show the card again; ` +
                             `that run moves on once the engine applies it.`
-                        : reopenRefusedForUserDismissal(outcome.reopened)
+                        : reopenRefusedForUserDismissal(reopened)
                             ? `You closed that decision card yourself, so sema did not put it back on screen; nothing will resume that ` +
                                 `run until that decision is made — send a message to bring the card back.`
-                            : `sema could not surface that decision card here, so nothing will resume that run until that decision is made; ` +
+                            : `sema could not surface that decision card here` +
+                                (reopenRefusedForNoPresentationSurface(reopened) ? ` (${NO_CARD_VIEW_ATTACHED})` : '') +
+                                `, so nothing will resume that run until that decision is made; ` +
                                 `${wayOut} if you no longer want it.`;
                 return (`${handle} is not actually working right now: the engine reports it ${parked} on a decision it needs ` +
                     `from you, so it queued your message on that park instead of running it. ${next} ${textOnly} ` +

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -5,7 +5,11 @@ import { REDACTION_MARKER_PREFIX, washCredentials } from '../../displayUntrusted
 import { readEffectiveReasoning, readEffectiveMemoryScopes } from '../../effectiveFacts.js';
 import { isReviewPark, readRunTerminal, runTerminalCode, runTerminalGateToolName, } from '../../runTerminal.js';
 import { toCcModelUsage } from './turnUsageToModelUsage.js';
-import { LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, OUTPUT_INVALID, isRewindFamilyCode, } from '../../engineErrorCodes.js';
+import { LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, OUTPUT_INVALID, isCorruptSessionCode, isRewindFamilyCode, } from '../../engineErrorCodes.js';
+import { corruptSessionContent } from '../../corruptSessionCopy.js';
+function withSessionUnreadableNote(text, code) {
+    return isCorruptSessionCode(code) ? `${text}\n${corruptSessionContent()}` : text;
+}
 function finiteOr0(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : 0;
 }
@@ -527,9 +531,9 @@ export function doneToSdkResult(ev, ctx, observed) {
             ...errorBase,
             subtype: failedSubtype,
             errors: [
-                isRewindFamilyCode(failedCode) && failedMessage
+                withSessionUnreadableNote(isRewindFamilyCode(failedCode) && failedMessage
                     ? `${failedMessage} (${failedCode})`
-                    : (failedMessage ?? 'run failed'),
+                    : (failedMessage ?? 'run failed'), failedCode),
             ],
         });
     }
@@ -619,9 +623,9 @@ export function failedToSdkResult(ev, ctx, observed) {
         durationMs: elapsedMs(ctx),
         errorCode: ev.errorCode,
         errors: [
-            isRewindFamilyCode(ev.errorCode) && ev.errorMessage
+            withSessionUnreadableNote(isRewindFamilyCode(ev.errorCode) && ev.errorMessage
                 ? `${ev.errorMessage} (${ev.errorCode})`
-                : (ev.errorMessage ?? ev.errorCode ?? 'run failed'),
+                : (ev.errorMessage ?? ev.errorCode ?? 'run failed'), ev.errorCode),
         ],
     });
 }

package/dist/adapter/runStream.js

@@ -3,7 +3,8 @@ import { eventToSdkMessage, turnEndUsage } from './downstream/eventToSdkMessage.
 import { turnUsageToModelUsage } from './downstream/turnUsageToModelUsage.js';
 import { readRunCostFacts, terminalToSdkResult, TOOL_INPUT_JOIN_MAX_CALLS } from './downstream/terminalToSdkResult.js';
 import { coerceOutput, publishSubagentContentEvent } from '../subagentContentStore.js';
-import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isLimitsExceededCode } from '../engineErrorCodes.js';
+import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
+import { corruptSessionContent } from '../corruptSessionCopy.js';
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
 import { washCredentials } from '../displayUntrusted.js';
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
@@ -474,7 +475,10 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             ?
                                 `${MODEL_OUTPUT_ERROR_PREFIX}: ${errText}${maxTokHint}`
                             : `API Error: ${errText}${maxTokHint}`;
-                yield syntheticTerminalRow(ctx, rowText);
+                const sessionUnreadable = ev.type === 'failed'
+                    ? isCorruptSessionCode(ev.errorCode)
+                    : doneTerminal?.kind === 'failed' && isCorruptSessionCode(doneTerminal.code);
+                yield syntheticTerminalRow(ctx, sessionUnreadable ? `${rowText}\n${corruptSessionContent()}` : rowText);
             }
             if (ev.type === 'done' && isReviewPark(doneTerminal) && ctx.emitChrome) {
                 try {

package/dist/agentSession/engineSessionBackgroundStop.d.ts

@@ -0,0 +1,50 @@
+import type { AgentClient, SessionBackgroundStopOutcome } from '@sema-agent/sdk';
+import type { EngineWireInjection } from '../engineWireSdk.js';
+export type EngineSessionBackgroundStopClient = {
+    sessions: Pick<AgentClient['sessions'], 'backgroundStop'>;
+};
+export type EngineSessionBackgroundStopWire = EngineWireInjection<EngineSessionBackgroundStopClient>;
+export interface EngineSessionBackgroundStopOptions {
+    wire?: EngineSessionBackgroundStopWire;
+    signal?: AbortSignal;
+    sessionKey?: string;
+}
+export interface EngineSessionBackgroundReceipt {
+    readonly id: string;
+    readonly outcome: SessionBackgroundStopOutcome | (string & {});
+}
+export type EngineSessionBackgroundStopUnavailableWhy = 'bad_input' | 'no_wire' | 'capability_unknown' | 'no_exit_face';
+export type EngineSessionBackgroundStopRefusedWhy = 'credentials_required' | 'not_permitted' | 'ownership_required' | 'session_not_found' | 'route_absent' | 'bad_request' | 'rate_limited' | 'other';
+export type EngineSessionBackgroundStopResult = {
+    kind: 'stopped';
+    receipts?: readonly EngineSessionBackgroundReceipt[];
+    unreadableReceipts?: number;
+} | {
+    kind: 'unavailable';
+    why: EngineSessionBackgroundStopUnavailableWhy;
+    detail: string;
+} | {
+    kind: 'refused';
+    why: EngineSessionBackgroundStopRefusedWhy;
+    detail: string;
+    status?: number;
+    errorCode?: string;
+    retryAfterMs?: number;
+} | {
+    kind: 'error';
+    detail: string;
+    status?: number;
+    errorCode?: string;
+    unconfirmed?: true;
+};
+export declare function stopEngineSessionBackground(sessionId: string, body: {
+    readonly includeRetained: boolean;
+}, opts?: EngineSessionBackgroundStopOptions): Promise<EngineSessionBackgroundStopResult>;
+export type EngineSessionBackgroundReceiptState = 'stopped' | 'still_running' | 'may_be_running';
+export declare const ENGINE_SESSION_BACKGROUND_RECEIPT_STATES: readonly EngineSessionBackgroundReceiptState[];
+export interface EngineSessionBackgroundReceiptReading {
+    readonly state: EngineSessionBackgroundReceiptState;
+    readonly text: string;
+    readonly unrecognizedOutcome?: string;
+}
+export declare function engineSessionBackgroundReceiptReadingOf(outcome: string): EngineSessionBackgroundReceiptReading;