@sema-agent/client-core 0.97.1 → 0.99.0

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

@@ -2,6 +2,7 @@ import type { AgentEvent, CheckpointGate, TaskResult } from '@sema-agent/sdk';
 import { type WiringManifestView } from './wiringManifestView.js';
 import { type SDKMessage, type EmitContext, type ModelUsage } from '../types.js';
 import { type McpLivenessView } from '../../mcpLiveness.js';
+import { type ContextUsageSectionRow } from '../../ownKey.js';
 export declare const INTERNAL_SDK_ARM_TYPES: ReadonlySet<string>;
 export type EventProjectionNoneReason = 'usage_only' | 'terminal_delegated' | 'hitl_out_of_slice' | 'not_in_slice' | 'empty_payload';
 export type EventProjectionDropReason = 'malformed' | 'unknown_arm' | 'unsupported_arm';
@@ -66,11 +67,7 @@ export interface WiringManifestLspSeamView {
     mounted: boolean;
     lane?: string;
 }
-export interface ContextUsageSectionView {
-    id: string;
-    tokens: number;
-    kind?: string;
-}
+export type ContextUsageSectionView = ContextUsageSectionRow;
 export interface PromptManifestSectionView {
     id: string;
     chars: number;

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -5,10 +5,11 @@ import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../../gateOutcome.js'
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
 import { projectHandsSection } from '../../handsSeam.js';
 import { readMcpLiveness } from '../../mcpLiveness.js';
-import { markMcpSectionDroppedNamedRows, readFrameTrueMark } from '../../ownKey.js';
-import { SEGMENT_END_IDENTITY_KEYS, stripToolUseSideChannels } from '../types.js';
+import { contextUsageReadingOf, humanInputAttachmentsOf, markMcpSectionDroppedNamedRows, readFrameTrueMark } from '../../ownKey.js';
+import { SEGMENT_END_IDENTITY_KEYS, eventSeq, stripToolUseSideChannels } from '../types.js';
 import { frozenSet } from '../../frozenSet.js';
 import { isCoreWorkflowRunTerminal } from '../../terminalStatuses.js';
+import { envelopeUuidOf, mintEngineRowRef, readBoundRun, wireEventIdOf } from '../../engineRowRef.js';
 function armBody(body) {
     return body;
 }
@@ -23,8 +24,10 @@ export const INTERNAL_SDK_ARM_TYPES = frozenSet([
     'prompt_assembled',
     'workflow_complete',
     'tool_end_result',
+    'terminal_fact',
     'retry_status',
     'task_progress',
+    'task_started',
     'task_notification',
     'diagnostics',
     'steering_injected',
@@ -69,7 +72,22 @@ const dropped = (why, type) => ({ kind: 'dropped', why, type });
 function assertNeverArm(_ev) {
 }
 export function eventToSdkMessage(ev, ctx) {
+    return withEngineIdentity(projectEvent(ev, ctx), ev, ctx);
+}
+function withEngineIdentity(p, ev, ctx) {
+    if (p.kind !== 'message')
+        return p;
+    const eventId = wireEventIdOf(ev);
+    if (eventId === undefined)
+        return p;
+    const env = p.message;
+    const ref = mintEngineRowRef(eventId, ctx.boundRun === undefined ? undefined : readBoundRun(() => ctx.boundRun?.(ev)));
+    return projected(Object.assign({}, env, { uuid: envelopeUuidOf(eventId, env.type), _sema_engine_ref: ref }));
+}
+function projectEvent(ev, ctx) {
     switch (ev.type) {
+        case 'task_started':
+            return taskStartedProjection(ev, ctx);
         case 'text_end':
             return textEndProjection(ev, ctx);
         case 'reasoning_end':
@@ -178,7 +196,6 @@ export function eventToSdkMessage(ev, ctx) {
             const toolEndGatedCallId = ev.gatedCallId;
             const collateralAbort = ev._sema_collateral_abort;
             const denialKind = ccToolDenialKindForToolEnd(ev);
-            const denialUnclassified = denialKind === undefined && toolEndGate?.disposition.kind === 'denied';
             const toolEndNotExecuted = readFrameTrueMark(ev, 'notExecuted');
             return projected(stamp(ctx, armBody({
                 type: 'tool_end_result',
@@ -201,7 +218,6 @@ export function eventToSdkMessage(ev, ctx) {
                     : {}),
                 ...(collateralAbort === true ? { _sema_collateral_abort: true } : {}),
                 ...(denialKind !== undefined ? { _sema_denial_kind: denialKind } : {}),
-                ...(denialUnclassified ? { _sema_denial_unclassified: true } : {}),
                 ...(toolEndNotExecuted ? { notExecuted: true } : {}),
                 ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
                 ...(ev.parentToolCallId !== undefined
@@ -210,19 +226,18 @@ export function eventToSdkMessage(ev, ctx) {
             })));
         }
         case 'status': {
-            const st2 = ev;
             const num = (v) => typeof v === 'number' && Number.isFinite(v) ? v : undefined;
             const attempt = num(ev.attempt);
             const maxRetries = num(ev.maxRetries);
             const retryInMs = num(ev.retryInMs);
-            const retryAtMs = num(st2.retryAtMs);
-            const errorStatus = num(st2.errorStatus);
-            const elapsedMs = num(st2.elapsedMs);
-            const timeoutMs = num(st2.timeoutMs);
+            const retryAtMs = num(ev.retryAtMs);
+            const errorStatus = num(ev.errorStatus);
+            const elapsedMs = num(ev.elapsedMs);
+            const timeoutMs = num(ev.timeoutMs);
             const errClass = typeof ev.errClass === 'string' && ev.errClass.length > 0 ? ev.errClass : undefined;
             const nonEmptyStr = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
-            const providerCondition = nonEmptyStr(st2.providerCondition);
-            const providerConditionSource = nonEmptyStr(st2.providerConditionSource);
+            const providerCondition = nonEmptyStr(ev.providerCondition);
+            const providerConditionSource = nonEmptyStr(ev.providerConditionSource);
             return projected(stamp(ctx, armBody({
                 type: 'retry_status',
                 phase: ev.phase,
@@ -648,33 +663,54 @@ function contextUsageProjection(ev, ctx) {
     const { identity, bad } = identityOrMalformed(ev, 'context_usage');
     if (bad !== null)
         return bad;
-    const fin = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
-    const usedTokens = fin(ev.usedTokens);
-    const windowTokens = fin(ev.windowTokens);
-    const compactAtTokens = fin(ev.compactAtTokens);
-    let sections;
-    if (Array.isArray(ev.sections)) {
-        const rows = [];
-        for (const r of ev.sections) {
-            if (typeof r !== 'object' || r === null || Array.isArray(r))
-                continue;
-            const o = r;
-            const tokens = fin(o.tokens);
-            if (typeof o.id !== 'string' || o.id.length === 0 || tokens === undefined)
-                continue;
-            rows.push({ id: o.id, tokens, ...(typeof o.kind === 'string' && o.kind.length > 0 ? { kind: o.kind } : {}) });
-        }
-        if (rows.length > 0)
-            sections = rows;
-    }
-    if (usedTokens === undefined && windowTokens === undefined && compactAtTokens === undefined && sections === undefined)
+    const reading = contextUsageReadingOf(ev);
+    if (reading === undefined)
         return nothing('empty_payload');
     return projected(internalArmExit(stamp(ctx, armBody({
         type: 'context_usage',
-        ...(usedTokens !== undefined ? { usedTokens } : {}),
-        ...(windowTokens !== undefined ? { windowTokens } : {}),
-        ...(compactAtTokens !== undefined ? { compactAtTokens } : {}),
-        ...(sections !== undefined ? { sections } : {}),
+        ...reading,
+        ...identity,
+    }))));
+}
+function taskStartedProjection(frame, ctx) {
+    const ev = frame;
+    const { identity, bad } = identityOrMalformed(ev, 'task_started');
+    if (bad !== null)
+        return bad;
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+    const taskId = str(ev.taskId);
+    if (taskId === undefined)
+        return dropped('malformed', 'task_started');
+    const sessionId = str(ev.sessionId);
+    const model = str(ev.model);
+    const taskType = str(ev.taskType);
+    const seq = num(ev.seq);
+    const workflowRunId = str(ev.workflowRunId);
+    const workflowAgentLabel = str(ev.workflowAgentLabel);
+    const parentTaskId = str(ev.parentTaskId);
+    const parentSessionId = str(ev.parentSessionId);
+    const rootSessionId = str(ev.rootSessionId);
+    const name = str(ev.name);
+    const spawnName = str(ev.spawnName);
+    const agentType = str(ev.agentType);
+    const startedAt = num(ev.startedAt);
+    return projected(internalArmExit(stamp(ctx, armBody({
+        type: 'task_started',
+        taskId,
+        ...(sessionId !== undefined ? { sessionId } : {}),
+        ...(model !== undefined ? { model } : {}),
+        ...(taskType !== undefined ? { taskType } : {}),
+        ...(seq !== undefined ? { seq } : {}),
+        ...(workflowRunId !== undefined ? { workflowRunId } : {}),
+        ...(workflowAgentLabel !== undefined ? { workflowAgentLabel } : {}),
+        ...(parentTaskId !== undefined ? { parentTaskId } : {}),
+        ...(parentSessionId !== undefined ? { parentSessionId } : {}),
+        ...(rootSessionId !== undefined ? { rootSessionId } : {}),
+        ...(name !== undefined ? { name } : {}),
+        ...(spawnName !== undefined ? { spawnName } : {}),
+        ...(agentType !== undefined ? { agentType } : {}),
+        ...(startedAt !== undefined ? { startedAt } : {}),
         ...identity,
     }))));
 }
@@ -774,6 +810,7 @@ function engineNoticeProjection(ev, ctx) {
     const detail = typeof rawDetail === 'object' && rawDetail !== null && !Array.isArray(rawDetail)
         ? rawDetail
         : {};
+    const seq = eventSeq(ev);
     return projected(stamp(ctx, armBody({
         type: 'engine_notice',
         code,
@@ -782,7 +819,7 @@ function engineNoticeProjection(ev, ctx) {
         ...(sessionId !== undefined ? { sessionId } : {}),
         ...(ts !== undefined ? { ts } : {}),
         ...(typeof ev.eventId === 'string' && ev.eventId.length > 0 ? { eventId: ev.eventId } : {}),
-        ...(typeof ev.id === 'string' && ev.id.length > 0 ? { eventSeq: ev.id } : {}),
+        ...(seq !== undefined ? { eventSeq: seq } : {}),
     })));
 }
 function approvalFrameBody(ev) {
@@ -820,8 +857,12 @@ function humanInputProjection(ev, ctx) {
         ...(str(ev.entryId) !== undefined ? { entryId: str(ev.entryId) } : {}),
         ...(str(ev.eventId) !== undefined ? { eventId: str(ev.eventId) } : {}),
         ...(str(ev.parentToolCallId) !== undefined ? { parentToolCallId: str(ev.parentToolCallId) } : {}),
+        ...attachmentsKey(humanInputAttachmentsOf(ev)),
     })));
 }
+function attachmentsKey(rows) {
+    return rows !== undefined ? { attachments: rows } : {};
+}
 export function turnEndUsage(ev) {
     const rawValue = ev.usage;
     if (typeof rawValue !== 'object' || rawValue === null || Array.isArray(rawValue))

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -4,7 +4,8 @@ import { putOwnKey, readFrameStringKey } from '../../ownKey.js';
 import { REDACTION_MARKER_PREFIX, washCredentials } from '../../displayUntrusted.js';
 import { readEffectiveReasoning, readEffectiveMemoryScopes } from '../../effectiveFacts.js';
 import { isReviewPark, readRunTerminal, runTerminalCode, runTerminalGateToolName, } from '../../runTerminal.js';
-import { doneResultView } from '../../replayBody.js';
+import { doneResultView, isReplayedTerminal } from '../../replayBody.js';
+import { terminalRunIdOf, terminalUuidOf } from '../../engineRowRef.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, isCorruptSessionCode, idempotencyPayloadMismatchContent, isIdempotencyPayloadMismatchCode, isRewindFamilyCode, } from '../../engineErrorCodes.js';
 import { corruptSessionContent } from '../../corruptSessionCopy.js';
@@ -497,7 +498,7 @@ function cutoffParts(r, message, fallbackMessage, code) {
 }
 function errorResult(ctx, parts) {
     return stamp(ctx, {
-        uuid: undefined,
+        uuid: parts.uuid,
         session_id: undefined,
         type: 'result',
         subtype: parts.subtype,
@@ -525,6 +526,10 @@ function errorResult(ctx, parts) {
     });
 }
 export function doneToSdkResult(ev, ctx, observed) {
+    const msg = doneToSdkResultBody(ev, ctx, observed);
+    return isReplayedTerminal(ev) ? Object.assign({}, msg, { _sema_replay: true }) : msg;
+}
+function doneToSdkResultBody(ev, ctx, observed) {
     const view = doneResultView(ev.result);
     const rRaw = view.engine;
     const rec = typeof rRaw === 'object' && rRaw !== null ? rRaw : {};
@@ -539,7 +544,9 @@ export function doneToSdkResult(ev, ctx, observed) {
     const errorCode = runTerminalCode(terminal);
     const degraded = degradedOf(r);
     const parkFailedReason = readFrameStringKey(ev, '_sema_park_failed_reason');
-    const errorBase = { durationMs, stats, model: r.model, errorCode, degraded, observed, facts: effectiveFactParts(rec), parkFailedReason, abortCause: abortCauseWordOf(ev) };
+    const terminalRunId = terminalRunIdOf(ev);
+    const resultUuid = terminalRunId === undefined ? undefined : terminalUuidOf(terminalRunId, 'result');
+    const errorBase = { uuid: resultUuid, durationMs, stats, model: r.model, errorCode, degraded, observed, facts: effectiveFactParts(rec), parkFailedReason, abortCause: abortCauseWordOf(ev) };
     if (terminal?.kind === 'failed') {
         const failedCode = terminal.code;
         const failedMessage = terminal.message;
@@ -613,7 +620,7 @@ export function doneToSdkResult(ev, ctx, observed) {
         });
     }
     return stamp(ctx, {
-        uuid: undefined,
+        uuid: resultUuid,
         session_id: undefined,
         type: 'result',
         subtype: 'success',

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

@@ -12,10 +12,13 @@ export interface EngineUsageLike {
     readonly costMicroUsd?: number | undefined;
     readonly webSearchRequests?: number | undefined;
 }
-export type SemaModelUsage = ModelUsage & {
+export type SemaModelUsage = ModelUsage & SemaModelUsageAbsenceBits;
+export interface SemaModelUsageAbsenceBits {
     readonly _sema_cost_absent?: true;
     readonly _sema_web_search_requests_absent?: true;
-};
+    readonly _sema_context_window_absent?: true;
+    readonly _sema_max_output_tokens_absent?: true;
+}
 export declare function toCcModelUsage(raw: EngineUsageLike): SemaModelUsage;
 export declare function turnUsageToModelUsage(usage: TurnUsage): SemaModelUsage;
 export {};

package/dist/adapter/downstream/turnUsageToModelUsage.js

@@ -15,6 +15,8 @@ export function toCcModelUsage(raw) {
         maxOutputTokens: 0,
         ...(costPriced ? {} : { _sema_cost_absent: true }),
         ...(webSearchKnown ? {} : { _sema_web_search_requests_absent: true }),
+        _sema_context_window_absent: true,
+        _sema_max_output_tokens_absent: true,
     };
 }
 export function turnUsageToModelUsage(usage) {

package/dist/adapter/runStream.js

@@ -2,19 +2,36 @@ import { eventSeq, stamp, } from './types.js';
 import { eventToSdkMessage, turnEndUsage } from './downstream/eventToSdkMessage.js';
 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 { terminalRunIdOf, terminalUuidOf } from '../engineRowRef.js';
+import { publishSubagentContentEvent, subagentContentEventOf } from '../subagentContentStore.js';
 import { OUTPUT_INVALID, activeRunBusyCarrierOf, classifyActiveRunBusy, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
-import { doneResultView } from '../replayBody.js';
+import { doneResultView, isReplayedTerminal } from '../replayBody.js';
+import { readFrameStringKey } from '../ownKey.js';
 import { corruptSessionContent } from '../corruptSessionCopy.js';
 import { abortCauseNoteOf } from '../runCancelContext.js';
 import { classifyToolHistoryMismatch, noteToolHistoryTerminal, openToolHistoryGeneration, TOOL_HISTORY_REWIND_SENTENCE, toolHistoryMismatchRowKey, toolHistoryRepeatSentence, toolHistoryRewindOffered, } from '../toolHistoryMismatch.js';
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
+import { parkHeldCallIdOf } from '../engineRowRef.js';
 import { providerRejectionResend } from '../providerRejection.js';
-import { washCredentials } from '../displayUntrusted.js';
+import { displayUntrusted, washCredentials } from '../displayUntrusted.js';
 import { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD, runBlockedText } from '../promptBlockedCopy.js';
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
 import { resumeReopenContent, resumeReopenFromError, suspendedReopenOf } from '../hitl/suspendedReopen.js';
 import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../gateVocabulary.js';
+const ENGINE_TURN_USAGE_KEYS = Object.freeze(['inputTokens', 'totalInputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'costMicroUsd']);
+const _engineTurnUsageKeysPin = true;
+void _engineTurnUsageKeysPin;
+function closedEngineTurnUsage(raw) {
+    const out = {};
+    let unknownKeys = 0;
+    for (const k of Object.keys(raw)) {
+        if (ENGINE_TURN_USAGE_KEYS.includes(k))
+            out[k] = raw[k];
+        else
+            unknownKeys++;
+    }
+    return { usage: out, unknownKeys };
+}
 const mainLane = () => ({ lane: 'main' });
 function emitChromeFireAndForget(ctx, event) {
     try {
@@ -108,9 +125,25 @@ export function isModelOutputErrorRowText(text) {
     return text.trimStart().startsWith(`${MODEL_OUTPUT_ERROR_PREFIX}:`);
 }
 export const OUTCOME_UNKNOWN_ROW_PREFIX = 'Outcome unknown';
-function syntheticTerminalRow(ctx, text, historyKey, resend) {
+function apiErrorRowBitsOf(read) {
+    try {
+        const status = read.carrier.status;
+        const providerCondition = read.detail !== undefined && ownDataBit(read.detail, 'kind') === PROVIDER_REJECTED_DETAIL ? nonEmptyStr(ownDataBit(read.detail, 'providerCondition')) : undefined;
+        const errorCode = nonEmptyStr(read.carrier.code);
+        const bits = {
+            ...(typeof status === 'number' && Number.isInteger(status) && status >= 100 && status <= 999 ? { status } : {}),
+            ...(providerCondition !== undefined ? { providerCondition } : {}),
+            ...(errorCode !== undefined ? { errorCode } : {}),
+        };
+        return Object.keys(bits).length > 0 ? bits : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function syntheticTerminalRow(ctx, identity, replayed, text, historyKey, resend, apiError) {
     return stamp(ctx, {
-        uuid: undefined,
+        uuid: identity.runId === undefined ? undefined : terminalUuidOf(identity.runId, identity.label),
         session_id: undefined,
         type: 'assistant',
         message: { role: 'assistant', model: '<synthetic>', content: [{ type: 'text', text: washCredentials(text) }] },
@@ -118,12 +151,12 @@ function syntheticTerminalRow(ctx, text, historyKey, resend) {
         _sema_api_error_message: true,
         ...(historyKey !== undefined ? { _sema_tool_history_mismatch: historyKey } : {}),
         ...(resend !== undefined ? { _sema_provider_rejection_resend: { resend: resend.resend, text: resend.text, kind: resend.kind } } : {}),
+        ...(apiError?.status !== undefined ? { _sema_api_error_status: apiError.status } : {}),
+        ...(apiError?.providerCondition !== undefined ? { _sema_provider_condition: apiError.providerCondition } : {}),
+        ...(apiError?.errorCode !== undefined ? { _sema_api_error_code: apiError.errorCode } : {}),
+        ...(replayed ? { _sema_replay: true } : {}),
     });
 }
-function engineRunIdOf(result) {
-    const v = result?.runId;
-    return typeof v === 'string' && v.length > 0 ? v : undefined;
-}
 function engineResultOf(result) {
     const v = doneResultView(result);
     return v.replay ? (v.engine ?? result) : result;
@@ -142,6 +175,19 @@ export function isGovernanceTerminal(input) {
         return true;
     return input.errorCode === OUTPUT_INVALID;
 }
+function terminalFactOf(ev, doneTerminal) {
+    const engine = ev.type === 'done' ? engineResultOf(ev.result) : ev;
+    const taskId = readFrameStringKey(engine, 'taskId');
+    if (ev.type !== 'done' || doneTerminal?.kind !== 'paused')
+        return { type: 'terminal_fact', ...(taskId !== undefined ? { taskId } : {}) };
+    const checkpointId = doneTerminal.checkpointId;
+    const heldCallId = parkHeldCallIdOf(engine);
+    return {
+        type: 'terminal_fact',
+        ...(taskId !== undefined ? { taskId } : {}),
+        paused: { ...(checkpointId !== undefined ? { checkpointId } : {}), ...(heldCallId !== undefined ? { heldCallId } : {}) },
+    };
+}
 function terminalRowFacts(ev) {
     const doneTerminal = ev.type === 'done' ? readRunTerminal(ev.result) : null;
     const errTextRaw = ev.type === 'failed'
@@ -220,7 +266,7 @@ function ownTerminalSnapshot(result) {
     const ts = ownDataCopy(t, ['kind', 'code', 'message']);
     const detail = plainObjectOf(ownDataBit(t, 'detail'));
     if (detail !== undefined)
-        ts.detail = ownDataCopy(detail, ['kind', 'status', 'code']);
+        ts.detail = ownDataCopy(detail, ['kind', 'status', 'code', 'providerCondition']);
     snap.terminal = ts;
     return snap;
 }
@@ -301,12 +347,10 @@ function apiErrorTerminalOfRowFrame(ev, facts) {
 }
 const reportedDroppedTypes = new Set();
 const DROPPED_TYPE_MEMO_CAP = 64;
-const DROPPED_TYPE_DISPLAY_CAP = 60;
-function sanitizeFrameType(type) {
-    const flattened = type.replace(/[\u0000-\u001f\u007f-\u009f]/g, '\uFFFD');
-    return flattened.length > DROPPED_TYPE_DISPLAY_CAP
-        ? `${flattened.slice(0, DROPPED_TYPE_DISPLAY_CAP)}…`
-        : flattened;
+const DROPPED_TYPE_DISPLAY_MAX = 60;
+function droppedTypeForLog(type) {
+    const full = displayUntrusted(type);
+    return full.length > DROPPED_TYPE_DISPLAY_MAX ? `${displayUntrusted(type, { max: DROPPED_TYPE_DISPLAY_MAX })}…` : full;
 }
 const DROPPED_WHY_SENTENCE = Object.freeze({
     duplicate_seq: 'a frame with this event id was already consumed on this run stream, so it was dropped as a replay (durable idempotency, contract 02 §1.1). ' +
@@ -335,7 +379,7 @@ function reportDroppedFrame(why, type, ctx) {
         return;
     if (reportedDroppedTypes.size < DROPPED_TYPE_MEMO_CAP)
         reportedDroppedTypes.add(type);
-    console.error(`[client-core] dropped an engine frame (${why}): type="${sanitizeFrameType(type)}" — ${droppedWhySentence(why)}`);
+    console.error(`[client-core] dropped an engine frame (${why}): type="${droppedTypeForLog(type)}" — ${droppedWhySentence(why)}`);
 }
 export function _resetDroppedFrameReportForTest() {
     reportedDroppedTypes.clear();
@@ -499,27 +543,9 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 }
             }
         }
-        if ((ev.type === 'text_delta' ||
-            ev.type === 'reasoning_delta' ||
-            ev.type === 'text' ||
-            ev.type === 'reasoning' ||
-            ev.type === 'tool_start' ||
-            ev.type === 'tool_end') &&
-            typeof ev.parentToolCallId === 'string') {
-            const sub = ev;
-            publishSubagentContentEvent({
-                type: sub.type,
-                taskId: sub.taskId ?? sub.parentToolCallId,
-                parentToolCallId: sub.parentToolCallId,
-                delta: sub.delta,
-                text: sub.text,
-                eventId: sub.eventId,
-                toolCallId: sub.toolCallId,
-                toolName: sub.toolName,
-                args: sub.args,
-                output: coerceOutput(sub.output),
-                isError: sub.isError,
-            });
+        const sub = subagentContentEventOf(ev);
+        if (sub !== undefined) {
+            publishSubagentContentEvent(sub);
             if (!(ctx.lane === 'print' && (sub.type === 'tool_start' || sub.type === 'tool_end')))
                 continue;
         }
@@ -533,10 +559,10 @@ async function* runStreamInner(events, ctx, handle = {}) {
             const responseModelRaw = turnEndLoose.responseModel;
             const responseModelWord = typeof responseModelRaw === 'string' && responseModelRaw.length > 0 ? responseModelRaw : undefined;
             const rawUsage = ev.usage;
-            const engineUsage = typeof rawUsage === 'object' && rawUsage !== null && !Array.isArray(rawUsage)
-                ? rawUsage
-                : undefined;
-            const usage = engineUsage !== undefined ? turnUsageToModelUsage(engineUsage) : undefined;
+            const closedUsage = typeof rawUsage === 'object' && rawUsage !== null && !Array.isArray(rawUsage) ? closedEngineTurnUsage(rawUsage) : undefined;
+            const engineUsage = closedUsage?.usage;
+            const usageUnknownKeys = closedUsage !== undefined && closedUsage.unknownKeys > 0 ? { engineUsageUnknownKeys: closedUsage.unknownKeys } : {};
+            const usage = closedUsage !== undefined ? turnUsageToModelUsage(rawUsage) : undefined;
             const measured = turnEndUsage(ev);
             if (engineUsage === undefined || usage === undefined) {
                 usageMissingObserved = true;
@@ -564,6 +590,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             laneProof: mainLane(),
                             usage,
                             engineUsage,
+                            ...usageUnknownKeys,
                             ...(usageMissing ? { usageMissing: true } : {}),
                             ...(stopWord !== undefined ? { stopReason: stopWord } : {}),
                             ...(responseModelWord !== undefined ? { responseModel: responseModelWord } : {}),
@@ -587,6 +614,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             parentToolCallId: parent,
                             usage,
                             engineUsage,
+                            ...usageUnknownKeys,
                             ...(usageMissing ? { usageMissing: true } : {}),
                             ...(stopWord !== undefined ? { stopReason: stopWord } : {}),
                             ...(responseModelWord !== undefined ? { responseModel: responseModelWord } : {}),
@@ -625,6 +653,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
         if (ev.type === 'done' || ev.type === 'failed') {
             const rowFacts = terminalRowFacts(ev);
             const doneTerminal = rowFacts.doneTerminal;
+            const terminalRunId = terminalRunIdOf(ev);
+            const replayed = isReplayedTerminal(ev);
             const errText = rowFacts.errText;
             if (errText) {
                 const busy = rowFacts.busy;
@@ -655,8 +685,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     sessionId: historyEchoedSid ?? ctx.sessionId,
                     sessionEchoed: historyEchoedSid !== undefined,
                     generation: historyGeneration,
-                    runId: ev.type === 'done' ? engineRunIdOf(engineResultOf(ev.result)) : undefined,
-                    replay: ev.type === 'done' && ev.replay === true,
+                    runId: terminalRunId,
+                    replay: replayed,
                     mismatch: historyMismatch,
                 });
                 const rewindOffered = historyMismatch !== null && ctx.lane !== 'print' && ctx.lane !== 'utility' && toolHistoryRewindOffered(ctx.offersRewind);
@@ -665,7 +695,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     : '';
                 const resend = historyTerminal.detail !== undefined ? providerRejectionResend(historyTerminal.detail, historyTerminal.carrier) : undefined;
                 const resendLine = resend !== undefined ? `\n${resend.text}` : '';
-                yield syntheticTerminalRow(ctx, `${sessionUnreadable ? `${rowText}\n${corruptSessionContent()}` : rowText}${abortNote !== undefined ? `\n${abortNote}` : ''}${rewindLine}${resendLine}`, historyMismatch === null ? undefined : toolHistoryMismatchRowKey(historyMismatch, historyRepeat, rewindOffered), resend);
+                yield syntheticTerminalRow(ctx, { runId: terminalRunId, label: 'terminal-row' }, replayed, `${sessionUnreadable ? `${rowText}\n${corruptSessionContent()}` : rowText}${abortNote !== undefined ? `\n${abortNote}` : ''}${rewindLine}${resendLine}`, historyMismatch === null ? undefined : toolHistoryMismatchRowKey(historyMismatch, historyRepeat, rewindOffered), resend, arm === 'apiError' ? apiErrorRowBitsOf(historyTerminal) : undefined);
             }
             else {
                 const echoedSid = ev.type === 'done' ? engineSessionIdOf(engineResultOf(ev.result)) : undefined;
@@ -673,8 +703,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     sessionId: echoedSid ?? ctx.sessionId,
                     sessionEchoed: echoedSid !== undefined,
                     generation: historyGeneration,
-                    runId: ev.type === 'done' ? engineRunIdOf(engineResultOf(ev.result)) : undefined,
-                    replay: ev.type === 'done' && ev.replay === true,
+                    runId: terminalRunId,
+                    replay: replayed,
                     mismatch: null,
                 });
             }
@@ -707,8 +737,9 @@ async function* runStreamInner(events, ctx, handle = {}) {
             if (outcome === 'unknown') {
                 const errs = resultFrame.errors;
                 const sentence = Array.isArray(errs) && typeof errs[0] === 'string' ? errs[0] : 'the run ended without a terminal record this client can read';
-                yield syntheticTerminalRow(ctx, `${OUTCOME_UNKNOWN_ROW_PREFIX}: ${sentence}`);
+                yield syntheticTerminalRow(ctx, { runId: terminalRunId, label: 'outcome-unknown' }, replayed, `${OUTCOME_UNKNOWN_ROW_PREFIX}: ${sentence}`);
             }
+            yield terminalFactOf(ev, doneTerminal);
             yield resultFrame;
             return;
         }

package/dist/adapter/types.d.ts

@@ -1,11 +1,10 @@
-import type { AgentEvent } from '@sema-agent/sdk';
+import type { AgentEvent, StampedAgentEvent } from '@sema-agent/sdk';
 import type { ModelUsage, SDKMessage } from '@sema-agent/agent-types';
 import type { ChromeEvent } from '../seam.js';
 import type { RequestLane } from '../request/taskRequest.js';
+import type { EngineBoundRun } from '../engineRowRef.js';
 export type { ModelUsage, SDKMessage };
-export type StampedAgentEvent = AgentEvent & {
-    id?: string;
-};
+export type { StampedAgentEvent };
 export declare function eventSeq(ev: AgentEvent): string | undefined;
 export declare function uuid(): string;
 export interface DroppedFrameInfo {
@@ -23,6 +22,7 @@ export interface EmitContext {
     };
     emitChrome?(event: ChromeEvent): void | Promise<void>;
     onDroppedFrame?(info: DroppedFrameInfo): void;
+    boundRun?(frame: AgentEvent): EngineBoundRun | undefined;
 }
 export declare function stamp<T extends {
     uuid?: string | undefined;

package/dist/adapter/types.js

@@ -1,5 +1,6 @@
 export function eventSeq(ev) {
-    return ev.id;
+    const id = ev.id;
+    return typeof id === 'string' && id.length > 0 ? id : undefined;
 }
 export function uuid() {
     const g = typeof globalThis !== 'undefined' ? globalThis.crypto : undefined;

package/dist/agentSession/backgroundView.js

@@ -1,4 +1,5 @@
 import { abortableSleep } from '../abortableSleep.js';
+import { isAssistantLaneAbsent } from '../assistantInbox.js';
 import { errCodes } from '../controlRouter.js';
 import { engineWireDebugEnabled } from '../engineWireTarget.js';
 import { hostLog } from '../host.js';
@@ -145,7 +146,7 @@ export function createBackgroundView(client, opts) {
         }
         catch (err) {
             debugLog(`assistant.tasks degrade: ${String(err)}`);
-            const health = isNotImplemented(err)
+            const health = isAssistantLaneAbsent(err)
                 ? 'not-configured'
                 : isReadCredentialRefusal(err)
                     ? 'unauthorized'

package/dist/agentSession/engineAgentRegistryRead.d.ts

@@ -1,4 +1,4 @@
-import type { AgentClient, Capabilities } from '@sema-agent/sdk';
+import type { AgentClient } from '@sema-agent/sdk';
 import type { EngineAgentRegistryListing, EngineAgentRegistryRowView } from '../engineAgentAbsence.js';
 export interface EngineAgentRegistryClient {
     readonly sessions: Pick<AgentClient['sessions'], 'background'>;
@@ -13,6 +13,6 @@ export interface RegistryListingProvenance {
 }
 export declare function registryListingProvenanceOf(listing: EngineAgentRegistryListing | null | undefined): RegistryListingProvenance | undefined;
 export declare function isEngineAgentRegistryListingSuperseded(listing: EngineAgentRegistryListing | null | undefined): boolean;
-export declare function readEngineAgentRegistry(client: EngineAgentRegistryClient, sessionId: string, caps: Pick<Capabilities, 'background'> | null | undefined, opts?: {
+export declare function readEngineAgentRegistry(client: EngineAgentRegistryClient, sessionId: string, capsBaseUrl: string | undefined, opts?: {
     readonly signal?: AbortSignal;
 }): Promise<EngineAgentRegistryListing>;