@sema-agent/client-core 0.86.0 → 0.88.0

package/dist/adapt/arms.js

@@ -10,11 +10,19 @@ import { registerSubagentAlias, registerSubagentContentAlias } from '../subagent
 import { readAsyncLaunchedAgentReceipt } from '../toolResult.js';
 import { isWorkflowAgentTaskId, recordWorkflowAgentTaskId } from '../workflow.js';
 import { isTerminalStatus } from '../runTerminal.js';
+import { readToolHistoryMismatchKey } from '../toolHistoryMismatch.js';
 import { resolveEnginePanelTaskId } from '../engineAgentPanelStore.js';
 import { fleetRowAgentType } from '../fleet/fleetRowAgentType.js';
 import { chrome, mainLane, transcript, messageIdentityOf } from './ids.js';
 import { wiringManifestViewOf } from '../adapter/downstream/wiringManifestView.js';
 import { CANCEL_MESSAGE, decisionOf, flattenWireOutput, REJECT_MESSAGE, sanitizeToolUseBlock, shortTaskLabel, TASK_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './wireShapes.js';
+function toolHistoryKeyCarry(m) {
+    if (m._sema_api_error_message !== true)
+        return {};
+    const raw = m._sema_tool_history_mismatch;
+    const key = readToolHistoryMismatchKey(typeof raw === 'object' && raw !== null ? raw : undefined);
+    return key === undefined ? {} : { _sema_tool_history_mismatch: key };
+}
 const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
     const message = m.message;
     const blocks = Array.isArray(message?.content)
@@ -120,6 +128,7 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
             session_id: ctx.sessionId,
             parent_tool_use_id: null,
             ...(m._sema_api_error_message === true ? { _sema_api_error_message: true } : {}),
+            ...toolHistoryKeyCarry(m),
         }, ctx.now());
         text.markEmittedText(textBlock.text);
     }

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -549,7 +549,8 @@ function wiringManifestSupersetBody(ev) {
     const autoConsolidation = projectAutoConsolidationSection(ev.autoConsolidation);
     const readDeny = projectReadDenySection(ev.readDeny);
     const hands = projectHandsSection(ev);
-    if (modelGate === undefined && autoMode === undefined && mcp === undefined && tools === undefined && hooks === undefined && lsp === undefined && writeProtection === undefined && autoConsolidation === undefined && readDeny === undefined && hands === undefined)
+    const fileHistory = projectFileHistorySection(ev);
+    if (modelGate === undefined && autoMode === undefined && mcp === undefined && tools === undefined && hooks === undefined && lsp === undefined && writeProtection === undefined && autoConsolidation === undefined && readDeny === undefined && hands === undefined && fileHistory === undefined)
         return undefined;
     return {
         ...(modelGate !== undefined ? { _sema_modelGate: modelGate } : {}),
@@ -562,8 +563,20 @@ function wiringManifestSupersetBody(ev) {
         ...(autoConsolidation !== undefined ? { _sema_autoConsolidation: autoConsolidation } : {}),
         ...(readDeny !== undefined ? { _sema_readDeny: readDeny } : {}),
         ...(hands !== undefined ? { _sema_hands: hands } : {}),
+        ...(fileHistory !== undefined ? { _sema_fileHistory: fileHistory } : {}),
     };
 }
+function projectFileHistorySection(holder) {
+    try {
+        if (!Object.hasOwn(holder, 'fileHistory'))
+            return undefined;
+        const raw = holder.fileHistory;
+        return typeof raw === 'string' && raw.length > 0 ? raw : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function projectWriteProtectionSection(raw) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
         return undefined;

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -499,6 +499,7 @@ function errorResult(ctx, parts) {
         ...selectedModelParts(parts.model),
         ...(parts.salvagedResult !== undefined ? { _sema_salvaged_result: parts.salvagedResult } : {}),
         ...(parts.outcomeUnknown === true ? { _sema_outcome: 'unknown' } : {}),
+        ...(parts.parkFailedReason !== undefined ? { _sema_park_failed_reason: washCredentials(parts.parkFailedReason) } : {}),
     });
 }
 export function doneToSdkResult(ev, ctx, observed) {
@@ -513,7 +514,9 @@ export function doneToSdkResult(ev, ctx, observed) {
     const durationMs = elapsedMs(ctx);
     const errorCode = runTerminalCode(terminal);
     const degraded = degradedOf(r);
-    const errorBase = { durationMs, stats, model: r.model, errorCode, degraded, observed, facts: effectiveFactParts(rec) };
+    const parkFailedRaw = ev._sema_park_failed_reason;
+    const parkFailedReason = typeof parkFailedRaw === 'string' && parkFailedRaw.length > 0 ? parkFailedRaw : undefined;
+    const errorBase = { durationMs, stats, model: r.model, errorCode, degraded, observed, facts: effectiveFactParts(rec), parkFailedReason };
     if (terminal?.kind === 'failed') {
         const failedCode = terminal.code;
         const failedMessage = terminal.message;

package/dist/adapter/downstream/wiringManifestView.d.ts

@@ -11,6 +11,7 @@ export type WiringManifestSections = {
     _sema_autoConsolidation?: WiringManifestAutoConsolidationView;
     _sema_readDeny?: WiringManifestReadDenyView;
     _sema_hands?: WiringManifestHandsView;
+    _sema_fileHistory?: string;
     eventId?: string;
 };
 export interface WiringManifestView {
@@ -24,6 +25,7 @@ export interface WiringManifestView {
     autoConsolidation?: WiringManifestAutoConsolidationView;
     readDeny?: WiringManifestReadDenyView;
     hands?: WiringManifestHandsView;
+    fileHistory?: string;
     eventId?: string;
 }
 export declare function wiringManifestViewOf(s: WiringManifestSections): WiringManifestView | undefined;

package/dist/adapter/downstream/wiringManifestView.js

@@ -15,6 +15,7 @@ export function wiringManifestViewOf(s) {
         ...(isObj(s._sema_autoConsolidation) ? { autoConsolidation: s._sema_autoConsolidation } : {}),
         ...(isObj(s._sema_readDeny) ? { readDeny: s._sema_readDeny } : {}),
         ...(isObj(s._sema_hands) && typeof s._sema_hands.mounted === 'boolean' ? { hands: s._sema_hands } : {}),
+        ...(typeof s._sema_fileHistory === 'string' && s._sema_fileHistory.length > 0 ? { fileHistory: s._sema_fileHistory } : {}),
     };
     if (Object.keys(view).length === 0)
         return undefined;

package/dist/adapter/runStream.js

@@ -5,9 +5,11 @@ import { readRunCostFacts, terminalToSdkResult, TOOL_INPUT_JOIN_MAX_CALLS } from
 import { coerceOutput, publishSubagentContentEvent } from '../subagentContentStore.js';
 import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
 import { corruptSessionContent } from '../corruptSessionCopy.js';
+import { classifyToolHistoryMismatch, noteToolHistoryTerminal, openToolHistoryGeneration, TOOL_HISTORY_REWIND_SENTENCE, toolHistoryMismatchRowKey, toolHistoryRepeatSentence, toolHistoryRewindOffered, } from '../toolHistoryMismatch.js';
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
 import { washCredentials } from '../displayUntrusted.js';
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
+import { resumeReopenContent, resumeReopenFromError, suspendedReopenOf } from '../hitl/suspendedReopen.js';
 import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../gateVocabulary.js';
 const mainLane = () => ({ lane: 'main' });
 function emitChromeFireAndForget(ctx, event) {
@@ -19,6 +21,27 @@ function emitChromeFireAndForget(ctx, event) {
     }
     catch { }
 }
+function suspendedReopenedNotice(ev) {
+    try {
+        const reopen = suspendedReopenOf(ev);
+        if (reopen.kind !== 'reopened')
+            return undefined;
+        const detail = resumeReopenFromError({ errorCode: reopen.code, retriable: true });
+        const rawTaskId = ev.taskId;
+        const eventId = eventSeq(ev);
+        return {
+            kind: 'suspended_reopened',
+            laneProof: mainLane(),
+            reopen,
+            ...(detail !== null ? { content: resumeReopenContent(detail) } : {}),
+            ...(typeof eventId === 'string' && eventId.length > 0 ? { eventId } : {}),
+            ...(typeof rawTaskId === 'string' && rawTaskId.length > 0 ? { taskId: rawTaskId } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 export function pendingGateIsProvablyDifferent(prev, next) {
     const a = prev?.checkpointId;
     const b = next?.checkpointId;
@@ -98,7 +121,7 @@ export function isModelOutputErrorRowText(text) {
     return text.trimStart().startsWith(`${MODEL_OUTPUT_ERROR_PREFIX}:`);
 }
 export const OUTCOME_UNKNOWN_ROW_PREFIX = 'Outcome unknown';
-function syntheticTerminalRow(ctx, text) {
+function syntheticTerminalRow(ctx, text, historyKey) {
     return stamp(ctx, {
         uuid: undefined,
         session_id: undefined,
@@ -106,8 +129,22 @@ function syntheticTerminalRow(ctx, text) {
         message: { role: 'assistant', model: '<synthetic>', content: [{ type: 'text', text: washCredentials(text) }] },
         parent_tool_use_id: null,
         _sema_api_error_message: true,
+        ...(historyKey !== undefined ? { _sema_tool_history_mismatch: historyKey } : {}),
     });
 }
+function engineRunIdOf(result) {
+    const v = result?.runId;
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+function engineSessionIdOf(result) {
+    const v = result?.sessionId;
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+function providerFailureStatusOf(result) {
+    const af = result?.apiFailure;
+    const status = typeof af === 'object' && af !== null ? af.status : undefined;
+    return typeof status === 'number' && Number.isFinite(status) ? status : undefined;
+}
 export function isOutcomeUnknownRowText(text) {
     return text.trimStart().startsWith(`${OUTCOME_UNKNOWN_ROW_PREFIX}:`);
 }
@@ -192,6 +229,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
     const seen = new Set();
     if (ctx.startedAtMs === undefined)
         ctx.startedAtMs = Date.now();
+    const historyGeneration = openToolHistoryGeneration();
     const nestedUsageByTask = new Map();
     let usageMissingObserved = false;
     const toolInputByCallId = new Map();
@@ -478,7 +516,37 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 const sessionUnreadable = ev.type === 'failed'
                     ? isCorruptSessionCode(ev.errorCode)
                     : doneTerminal?.kind === 'failed' && isCorruptSessionCode(doneTerminal.code);
-                yield syntheticTerminalRow(ctx, sessionUnreadable ? `${rowText}\n${corruptSessionContent()}` : rowText);
+                const historyMismatch = !busy.busy && !governance && !isModelOutputErrorText(errText)
+                    ? classifyToolHistoryMismatch({
+                        code: ev.type === 'failed' ? ev.errorCode : runTerminalCode(doneTerminal),
+                        status: ev.type === 'done' ? providerFailureStatusOf(ev.result) : undefined,
+                        message: errText,
+                    })
+                    : null;
+                const historyEchoedSid = ev.type === 'done' ? engineSessionIdOf(ev.result) : undefined;
+                const historyRepeat = noteToolHistoryTerminal({
+                    sessionId: historyEchoedSid ?? ctx.sessionId,
+                    sessionEchoed: historyEchoedSid !== undefined,
+                    generation: historyGeneration,
+                    runId: ev.type === 'done' ? engineRunIdOf(ev.result) : undefined,
+                    replay: ev.type === 'done' && ev.replay === true,
+                    mismatch: historyMismatch,
+                });
+                const rewindLine = historyMismatch !== null && ctx.lane !== 'print' && ctx.lane !== 'utility' && toolHistoryRewindOffered(ctx.offersRewind)
+                    ? `\n${TOOL_HISTORY_REWIND_SENTENCE}${historyRepeat !== undefined && historyRepeat >= 2 ? ` ${toolHistoryRepeatSentence(historyRepeat)}` : ''}`
+                    : '';
+                yield syntheticTerminalRow(ctx, `${sessionUnreadable ? `${rowText}\n${corruptSessionContent()}` : rowText}${rewindLine}`, historyMismatch === null ? undefined : toolHistoryMismatchRowKey(historyMismatch, historyRepeat));
+            }
+            else {
+                const echoedSid = ev.type === 'done' ? engineSessionIdOf(ev.result) : undefined;
+                noteToolHistoryTerminal({
+                    sessionId: echoedSid ?? ctx.sessionId,
+                    sessionEchoed: echoedSid !== undefined,
+                    generation: historyGeneration,
+                    runId: ev.type === 'done' ? engineRunIdOf(ev.result) : undefined,
+                    replay: ev.type === 'done' && ev.replay === true,
+                    mismatch: null,
+                });
             }
             if (ev.type === 'done' && isReviewPark(doneTerminal) && ctx.emitChrome) {
                 try {
@@ -514,6 +582,11 @@ async function* runStreamInner(events, ctx, handle = {}) {
             yield resultFrame;
             return;
         }
+        if (ev.type === 'suspended') {
+            const notice = suspendedReopenedNotice(ev);
+            if (notice !== undefined)
+                emitChromeFireAndForget(ctx, notice);
+        }
         const projection = eventToSdkMessage(ev, ctx);
         if (projection.kind === 'message') {
             yield projection.message;

package/dist/adapter/types.d.ts

@@ -18,6 +18,9 @@ export interface EmitContext {
     startedAtMs?: number;
     model?: string;
     lane?: RequestLane;
+    offersRewind?: boolean | {
+        readonly engineBaseUrl: string;
+    };
     emitChrome?(event: ChromeEvent): void | Promise<void>;
     onDroppedFrame?(info: DroppedFrameInfo): void;
 }

package/dist/decideReceipt.d.ts

@@ -1,5 +1,5 @@
 import { type GateOutcomeView } from './gateOutcome.js';
-import { type ResumeReopenDetail } from './resumeRefusalCopy.js';
+import { type ResumeReopenDetail } from './hitl/suspendedReopen.js';
 export interface DecideReceiptView {
     status?: string;
     taskId?: string;

package/dist/decideReceipt.js

@@ -1,5 +1,5 @@
 import { gateOutcomeOf } from './gateOutcome.js';
-import { resumeReopenFromError } from './resumeRefusalCopy.js';
+import { resumeReopenFromError } from './hitl/suspendedReopen.js';
 import { DECIDE_CLAIM_LOST, DECIDE_GATE_MOVED, DECIDE_NOT_PARKED, DECIDE_WORKFLOW_HOST_UNKNOWN, DECIDE_WORKFLOW_LANE_CODES, DECIDE_WORKFLOW_REMEMBER_UNSUPPORTED, isDecideParkMovedCode, } from './engineErrorCodes.js';
 import { effectiveWireErrorCode } from './wireErrorTriage.js';
 import { readErrorString } from './wireFailureShape.js';

package/dist/detachWire.d.ts

@@ -1,4 +1,5 @@
 import { type EnvLike } from './hostEnv.js';
+import { type WireAuthTokenSource } from './engineWireSdk.js';
 export declare const DETACH_HEADER = "x-detach-on-disconnect";
 export declare const HEADLESS_DETACH_ENV = "SEMA_HEADLESS_DETACH";
 export declare const DETACH_WIRE_MIN_ENGINE: readonly [number, number, number];
@@ -36,7 +37,11 @@ export interface DetachCancelArm {
     principal: string | undefined;
     getTaskId: () => string | null;
 }
-export declare function armDetachCancel(arm: DetachCancelArm): void;
+export declare function armDetachCancel(arm: Omit<DetachCancelArm, 'authToken'> & {
+    authToken: WireAuthTokenSource | {
+        mode: 'loopback-unauthed';
+    };
+}): void;
 export declare function isDetachArmed(): boolean;
 export declare function detachedTaskId(): string | null;
 export declare function detachCancelArm(): DetachCancelArm | null;

package/dist/detachWire.js

@@ -1,6 +1,7 @@
 import { hostEnv } from './hostEnv.js';
 import { envFlagOff } from './envFlag.js';
 import { versionSupportsLimits } from './limitsWire.js';
+import { resolveWireAuth } from './engineWireSdk.js';
 export const DETACH_HEADER = 'x-detach-on-disconnect';
 export const HEADLESS_DETACH_ENV = 'SEMA_HEADLESS_DETACH';
 export const DETACH_WIRE_MIN_ENGINE = [1, 196, 0];
@@ -80,6 +81,17 @@ let cancelArm = null;
 export function armDetachCancel(arm) {
     cancelArm = arm;
 }
+function armAuthNow(baseUrl, source) {
+    let token;
+    try {
+        const v = source();
+        token = typeof v === 'string' ? v : undefined;
+    }
+    catch {
+        token = undefined;
+    }
+    return resolveWireAuth(baseUrl, token);
+}
 export function isDetachArmed() {
     return cancelArm !== null;
 }
@@ -87,7 +99,16 @@ export function detachedTaskId() {
     return cancelArm?.getTaskId() ?? null;
 }
 export function detachCancelArm() {
-    return cancelArm;
+    const arm = cancelArm;
+    if (arm === null)
+        return null;
+    const source = arm.authToken;
+    if (typeof source === 'function') {
+        const view = Object.defineProperties(Object.create(Object.getPrototypeOf(arm)), Object.getOwnPropertyDescriptors(arm));
+        Object.defineProperty(view, 'authToken', { value: armAuthNow(arm.baseUrl, source), enumerable: true, writable: true, configurable: true });
+        return view;
+    }
+    return arm;
 }
 export function _resetDetachWireForTest() {
     cancelArm = null;

package/dist/displayUntrusted.d.ts

@@ -33,5 +33,9 @@ export interface DisplayUntrustedMarked {
     readonly text: string;
     readonly marks: readonly DisplayMarkSpan[];
 }
+export declare function credentialWashPasses(text: string, opts?: DisplayUntrustedOptions | null): {
+    passes: number;
+    capped: boolean;
+};
 export declare function displayUntrusted(text: string, opts?: DisplayUntrustedOptions): string;
 export declare function displayUntrustedMarks(text: string, opts?: DisplayUntrustedOptions): DisplayUntrustedMarked;