@sema-agent/client-core 0.100.0 → 0.101.0

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -5,7 +5,7 @@ import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../../gateOutcome.js'
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
 import { projectHandsSection } from '../../handsSeam.js';
 import { readMcpLiveness } from '../../mcpLiveness.js';
-import { contextUsageReadingOf, humanInputAttachmentsOf, markMcpSectionDroppedNamedRows, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameTrueMark } from '../../ownKey.js';
+import { contextUsageReadingOf, humanInputAttachmentsOf, guardedRead, markMcpSectionDroppedNamedRows, ownSnapshotTyped, promptManifestIdentityOfFrame, promptManifestSectionViewOf, readFrameTrueMark, readOwnDataNonEmptyString } from '../../ownKey.js';
 import { SEGMENT_END_IDENTITY_KEYS, eventSeq, stripToolUseSideChannels } from '../types.js';
 import { frozenSet } from '../../frozenSet.js';
 import { isCoreWorkflowRunTerminal } from '../../terminalStatuses.js';
@@ -76,12 +76,27 @@ function isCompactionStartedFrame(ev) {
 function assertNeverArm(_ev) {
 }
 export function eventToSdkMessage(ev, ctx) {
-    return withEngineIdentity(projectEvent(ev, ctx), ev, ctx);
-}
-function withEngineIdentity(p, ev, ctx) {
+    const entry = sampleNotificationEntry(ev);
+    if (entry.dropped !== undefined)
+        return entry.dropped;
+    return withEngineIdentity(projectEvent(entry.frame, ctx), ev, ctx, entry.frame);
+}
+function sampleNotificationEntry(ev) {
+    const word = guardedRead(() => readOwnDataNonEmptyString(ev, 'type'));
+    if (word !== 'task_notification' && word !== 'workflow_complete')
+        return { frame: ev };
+    const sampled = ownSnapshotTyped(ev);
+    if (sampled === undefined)
+        return { dropped: dropped('malformed', word) };
+    return { frame: sampled };
+}
+function noticeSnapshotOf(ev) {
+    return ownSnapshotTyped(ev);
+}
+function withEngineIdentity(p, ev, ctx, identityFrame = ev) {
     if (p.kind !== 'message')
         return p;
-    const eventId = wireEventIdOf(ev);
+    const eventId = wireEventIdOf(identityFrame);
     if (eventId === undefined)
         return p;
     const env = p.message;
@@ -128,17 +143,20 @@ function projectEvent(ev, ctx) {
             })));
         }
         case 'workflow_complete': {
-            if (typeof ev.runId !== 'string' || ev.runId.length === 0) {
+            const wf = noticeSnapshotOf(ev);
+            if (wf === undefined)
+                return dropped('malformed', 'workflow_complete');
+            if (typeof wf.runId !== 'string' || wf.runId.length === 0) {
                 return dropped('malformed', 'workflow_complete');
             }
-            if (!isCoreWorkflowRunTerminal(ev.status)) {
+            if (!isCoreWorkflowRunTerminal(wf.status)) {
                 return dropped('malformed', 'workflow_complete');
             }
             return projected(stamp(ctx, armBody({
                 type: 'workflow_complete',
-                runId: ev.runId,
-                status: ev.status,
-                summary: typeof ev.summary === 'string' ? ev.summary : '',
+                runId: wf.runId,
+                status: wf.status,
+                summary: typeof wf.summary === 'string' ? wf.summary : '',
             })));
         }
         case 'text':
@@ -313,8 +331,11 @@ function projectEvent(ev, ctx) {
             return projected(stamp(ctx, armBody({ type: 'wiring_manifest', ...body, ...identity })));
         }
         case 'task_notification': {
-            const nested = ev.notification;
-            const n = (nested ?? ev);
+            const notice = noticeSnapshotOf(ev);
+            if (notice === undefined)
+                return dropped('malformed', 'task_notification');
+            const nested = notice.notification;
+            const n = (nested ?? notice);
             if (typeof n.task_id !== 'string')
                 return dropped('malformed', 'task_notification');
             return projected(stamp(ctx, armBody({

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

@@ -1,8 +1,11 @@
 import type { AgentEvent, TaskStats } from '@sema-agent/sdk';
 import { type CcToolDenialKind, type GateDeniedByWord } from '../../gateVocabulary.js';
 import { type SDKMessage, type EmitContext } from '../types.js';
-import type { TerminalReason } from '@sema-agent/agent-types';
+import type { SDKPermissionDenial, SDKResultError, SDKResultSuccess, TerminalReason } from '@sema-agent/agent-types';
+import { type RunTerminalCodedDetail, type RunTerminalRead } from '../../runTerminal.js';
 import { type SemaModelUsage } from './turnUsageToModelUsage.js';
+import { type ResultLimitWord } from '../../engineErrorCodes.js';
+import { type ResultWayOutFacts } from '../../providerRejection.js';
 export interface SemaFlatUsage {
     readonly inputTokens: number;
     readonly outputTokens: number;
@@ -23,6 +26,9 @@ export interface TerminalStreamObserved {
     readonly streamSawRunOpen?: boolean;
     readonly deniedToolNameByCallId?: ReadonlyMap<string, string | undefined>;
     readonly deniedCallsOverflowed?: boolean;
+    readonly wayOutFacts?: ResultWayOutFacts | undefined;
+    readonly codedDetail?: RunTerminalCodedDetail | undefined;
+    readonly lastRow?: PrintResultLastRow | null;
 }
 export declare const TOOL_INPUT_JOIN_MAX_CALLS = 4096;
 export interface SemaPermissionDenial {
@@ -36,6 +42,22 @@ export interface SemaPermissionDenial {
     readonly _sema_denied_by_source?: 'tool_end';
     readonly toolDenialKind?: CcToolDenialKind;
 }
+export interface CcPermissionDenial {
+    readonly tool_name: string;
+    readonly tool_use_id: string;
+    readonly tool_input: SDKPermissionDenial['tool_input'];
+    readonly _sema_tool_arg?: string;
+    readonly _sema_tool_input_redacted?: true;
+    readonly deniedBy?: GateDeniedByWord;
+    readonly _sema_denied_by_source?: 'tool_end';
+    readonly toolDenialKind?: CcToolDenialKind;
+}
+export interface PermissionDenialParts {
+    readonly permission_denials: readonly CcPermissionDenial[];
+    readonly _sema_permission_denials?: readonly SemaPermissionDenial[];
+    readonly _sema_permission_denials_absent?: true;
+    readonly _sema_zero_output_denied?: true;
+}
 export interface SemaCostBreakdown {
     readonly llmRootMicroUsd?: number;
     readonly nestedSubagentMicroUsd?: number;
@@ -68,6 +90,10 @@ export interface RunCostFacts {
 export declare function readRunCostFacts(stats: TaskStats | undefined, observed?: {
     readonly usageMissingObserved?: boolean;
 }): RunCostFacts | undefined;
+export interface ObservedTerminalParts extends PermissionDenialParts {
+    readonly _sema_usage_lower_bound?: true;
+}
+export declare function terminalPartsOfObserved(observed: TerminalStreamObserved | undefined): ObservedTerminalParts;
 export interface SemaSubagentUsageRow {
     readonly turns: number;
     readonly inputTokens: number;
@@ -98,6 +124,39 @@ export interface SemaTerminalModelUsage extends SemaModelUsage {
     readonly _sema_cache_write_tokens_long?: number;
 }
 export declare function terminalReasonForResult(msg: SDKMessage): TerminalReason | undefined;
+export type { ResultLimitWord };
+export declare function resultLimitOf(frame: object | null | undefined): ResultLimitWord | undefined;
+export interface PrintResultLastRowBlock {
+    readonly type?: string;
+    readonly text?: string;
+}
+export interface PrintResultLastRowMessage {
+    readonly content?: string | readonly PrintResultLastRowBlock[];
+    readonly stop_reason?: string | null;
+}
+export interface PrintResultLastRow {
+    readonly type?: string;
+    readonly _sema_api_error_message?: boolean;
+    readonly message?: PrintResultLastRowMessage;
+    readonly salvagedText?: string;
+}
+export interface PrintResultArmInput {
+    readonly terminal: RunTerminalRead | null;
+    readonly lastRow?: PrintResultLastRow | null;
+}
+export interface PrintResultSuccessArm {
+    readonly subtype: SDKResultSuccess['subtype'];
+    readonly is_error: boolean;
+    readonly stop_reason: SDKResultSuccess['stop_reason'];
+}
+export interface PrintResultErrorArm {
+    readonly subtype: SDKResultError['subtype'];
+    readonly is_error: true;
+    readonly stop_reason: SDKResultError['stop_reason'];
+    readonly limit?: ResultLimitWord;
+}
+export type PrintResultArm = PrintResultSuccessArm | PrintResultErrorArm;
+export declare function printResultArmOf(input: PrintResultArmInput | null | undefined): PrintResultArm;
 export declare function doneToSdkResult(ev: Extract<AgentEvent, {
     type: 'done';
 }>, ctx: EmitContext, observed?: TerminalStreamObserved): SDKMessage;

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -1,16 +1,17 @@
 import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../../gateVocabulary.js';
 import { stamp } from '../types.js';
-import { putOwnKey, readFrameStringKey } from '../../ownKey.js';
+import { guardedRead, putOwnKey, readFrameStringKey, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue } 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 { isReviewPark, readRunTerminal, runTerminalCode, runTerminalCodedDetail, runTerminalGateToolName, } from '../../runTerminal.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 { LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, isCorruptSessionCode, isLimitsExceededCode, RESULT_LIMIT_WORDS, resultLimitRowOfCode, idempotencyPayloadMismatchContent, isIdempotencyPayloadMismatchCode, isRewindFamilyCode, } from '../../engineErrorCodes.js';
 import { corruptSessionContent } from '../../corruptSessionCopy.js';
 import { runBlockedText } from '../../promptBlockedCopy.js';
 import { abortCauseNoteOf, readAbortCause } from '../../runCancelContext.js';
+import { wayOutOfApiErrorFacts } from '../../providerRejection.js';
 function withTerminalNote(text, code, frame) {
     const withCorrupt = isCorruptSessionCode(code)
         ? `${text}\n${corruptSessionContent()}`
@@ -296,6 +297,26 @@ function costFactParts(stats, observed) {
         ...(facts.nested !== undefined ? { _sema_nested_usage: facts.nested } : {}),
     };
 }
+export function terminalPartsOfObserved(observed) {
+    let denials;
+    try {
+        denials = permissionDenialParts(undefined, observed);
+    }
+    catch {
+        denials = permissionDenialParts(undefined, undefined);
+    }
+    let lowerBound = false;
+    try {
+        lowerBound = usageLowerBoundOf(undefined, observed);
+    }
+    catch {
+        lowerBound = false;
+    }
+    return Object.freeze({
+        ...denials,
+        ...(lowerBound ? { _sema_usage_lower_bound: true } : {}),
+    });
+}
 export const SEMA_SUBAGENT_USAGE_PARTIAL_KEY = '_sema_subagent_usage_partial';
 export function subagentUsageIsPartial(row, opts) {
     if (opts?.tablePartial === true)
@@ -427,23 +448,10 @@ function degradedOf(r) {
     const d = r.degraded;
     return d !== undefined && d !== null && typeof d === 'object' ? d : undefined;
 }
-const COST_EXCEEDED_CODES = new Set([LIMITS_MAX_COST_EXCEEDED]);
-const TURNS_EXCEEDED_CODES = new Set([LIMITS_MAX_TURNS_EXCEEDED]);
 const CUTOFF_EXCEEDED_CODES = new Set([
     LIMITS_MAX_TOKENS_EXCEEDED,
     LIMITS_MAX_WALLTIME_EXCEEDED,
 ]);
-function subtypeForErrorCode(code) {
-    if (code === undefined || code.length === 0)
-        return 'error_during_execution';
-    if (COST_EXCEEDED_CODES.has(code))
-        return 'error_max_budget_usd';
-    if (TURNS_EXCEEDED_CODES.has(code))
-        return 'error_max_turns';
-    if (code === OUTPUT_INVALID)
-        return 'error_max_structured_output_retries';
-    return 'error_during_execution';
-}
 function terminalReasonOf(subtype, isError) {
     switch (subtype) {
         case 'success':
@@ -476,6 +484,103 @@ export function terminalReasonForResult(msg) {
         return undefined;
     }
 }
+export function resultLimitOf(frame) {
+    const raw = guardedRead(() => readOwnDataNonEmptyString(frame, '_sema_limit'));
+    return raw !== undefined && RESULT_LIMIT_WORDS.includes(raw) ? raw : undefined;
+}
+const PRINT_ARM_KIND_TABLE = Object.freeze({ completed: true, failed: true, blocked: true, paused: true, unknown: true });
+function printArmNonBlank(v) {
+    return typeof v === 'string' && v.trim().length > 0;
+}
+function printArmObjectLike(v) {
+    return typeof v === 'object' && v !== null;
+}
+function printArmRowText(row) {
+    const message = readOwnDataValue(row, 'message');
+    if (!printArmObjectLike(message) || Array.isArray(message))
+        return undefined;
+    const content = readOwnDataValue(message, 'content');
+    if (typeof content === 'string')
+        return printArmNonBlank(content) ? content : undefined;
+    if (!Array.isArray(content) || content.length === 0)
+        return undefined;
+    const last = readOwnDataValue(content, String(content.length - 1));
+    if (!printArmObjectLike(last) || Array.isArray(last))
+        return undefined;
+    const text = readOwnDataValue(last, 'text');
+    return readOwnDataValue(last, 'type') === 'text' && printArmNonBlank(text) ? text : undefined;
+}
+function printArmLastRowOriginOf(row) {
+    try {
+        if (!printArmObjectLike(row) || Array.isArray(row))
+            return { origin: 'other' };
+        const isAssistant = readOwnDataValue(row, 'type') === 'assistant';
+        if (isAssistant && readOwnDataValue(row, '_sema_api_error_message') === true) {
+            const text = printArmRowText(row);
+            return text !== undefined ? { origin: 'api_error', text } : { origin: 'api_error' };
+        }
+        const salvaged = readOwnDataValue(row, 'salvagedText');
+        if (printArmNonBlank(salvaged))
+            return { origin: 'model_text', text: salvaged };
+        if (!isAssistant)
+            return { origin: 'other' };
+        const text = printArmRowText(row);
+        return text !== undefined ? { origin: 'model_text', text } : { origin: 'other' };
+    }
+    catch {
+        return { origin: 'other' };
+    }
+}
+function printArmStopReasonOf(row) {
+    try {
+        if (!printArmObjectLike(row) || Array.isArray(row))
+            return null;
+        const message = readOwnDataValue(row, 'message');
+        if (!printArmObjectLike(message) || Array.isArray(message))
+            return null;
+        return readOwnDataNonEmptyString(message, 'stop_reason') ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+const PRINT_ARM_UNKNOWN_OUTCOME = Object.freeze({ subtype: 'error_during_execution', is_error: true, stop_reason: null });
+export function printResultArmOf(input) {
+    return printArmReadingOf(input).arm;
+}
+function printArmReadingOf(input) {
+    try {
+        if (!printArmObjectLike(input) || Array.isArray(input))
+            return PRINT_ARM_UNKNOWN_READING;
+        if (!Object.hasOwn(input, 'terminal'))
+            return PRINT_ARM_UNKNOWN_READING;
+        const terminal = readOwnDataValue(input, 'terminal');
+        if (terminal !== null && (!printArmObjectLike(terminal) || Array.isArray(terminal)))
+            return PRINT_ARM_UNKNOWN_READING;
+        const kind = terminal === null ? null : readOwnDataValue(terminal, 'kind');
+        if (terminal !== null && (typeof kind !== 'string' || !Object.hasOwn(PRINT_ARM_KIND_TABLE, kind)))
+            return PRINT_ARM_UNKNOWN_READING;
+        const lastRow = readOwnDataValue(input, 'lastRow');
+        const stop_reason = printArmStopReasonOf(lastRow);
+        if (kind === 'completed')
+            return { arm: Object.freeze({ subtype: 'success', is_error: false, stop_reason }) };
+        if (kind === 'failed') {
+            const code = readOwnDataValue(terminal, 'code');
+            const limit = typeof code === 'string' ? resultLimitRowOfCode(code) : undefined;
+            if (limit !== undefined)
+                return { arm: Object.freeze({ subtype: limit.subtype, is_error: true, stop_reason, limit: limit.word }) };
+        }
+        const row = printArmLastRowOriginOf(lastRow);
+        if (row.origin === 'api_error' || row.origin === 'model_text') {
+            return { arm: Object.freeze({ subtype: 'success', is_error: true, stop_reason }), ...(row.text !== undefined ? { text: row.text, errorRow: row.origin === 'api_error' } : {}) };
+        }
+        return { arm: Object.freeze({ subtype: 'error_during_execution', is_error: true, stop_reason }) };
+    }
+    catch {
+        return PRINT_ARM_UNKNOWN_READING;
+    }
+}
+const PRINT_ARM_UNKNOWN_READING = Object.freeze({ arm: PRINT_ARM_UNKNOWN_OUTCOME });
 function selectedModelParts(model) {
     return typeof model === 'string' && model.length > 0 ? { _sema_selected_model: model } : {};
 }
@@ -496,17 +601,28 @@ function cutoffParts(r, message, fallbackMessage, code) {
         ...(salvaged !== undefined ? { salvagedResult: salvaged } : {}),
     };
 }
+function localWayOutFacts(r, rejection) {
+    const apiFailure = guardedRead(() => readOwnDataValue(r, 'apiFailure'));
+    const apiFailureStatus = typeof apiFailure === 'object' && apiFailure !== null && guardedRead(() => !Array.isArray(apiFailure) || undefined) === true
+        ? guardedRead(() => readOwnDataFiniteNumber(apiFailure, 'status'))
+        : undefined;
+    const status = apiFailureStatus ?? rejection?.status;
+    return {
+        ...(status !== undefined ? { status } : {}),
+        ...(rejection?.providerCondition !== undefined ? { providerCondition: rejection.providerCondition } : {}),
+        ...(rejection?.route !== undefined ? { credentialSource: rejection.route.credentialSource } : {}),
+    };
+}
 function errorResult(ctx, parts) {
-    return stamp(ctx, {
-        uuid: parts.uuid,
-        session_id: undefined,
-        type: 'result',
-        subtype: parts.subtype,
+    const errors = parts.errors.map(washCredentials);
+    const arm = parts.arm;
+    const result = arm.subtype === 'success' ? (parts.lastRowText ?? errors.join('\n')) : undefined;
+    const head = {
         duration_ms: parts.durationMs,
         duration_api_ms: parts.durationMs,
-        is_error: true,
+        is_error: arm.is_error,
         num_turns: parts.stats?.turns ?? 0,
-        stop_reason: null,
+        stop_reason: arm.stop_reason,
         total_cost_usd: costOrNull(parts.stats),
         usage: flattenUsage(parts.stats),
         modelUsage: modelUsageFor(parts.stats, parts.model),
@@ -514,8 +630,9 @@ function errorResult(ctx, parts) {
         ...costFactParts(parts.stats, parts.observed),
         ...reemitEffectiveFacts(parts.facts),
         ...nestedUsageByTaskParts(parts.stats, parts.observed?.nestedUsageByTask),
-        errors: parts.errors.map(washCredentials),
-        ...terminalReasonParts(parts.subtype, true),
+    };
+    const tail = {
+        ...terminalReasonParts(arm.subtype, arm.is_error),
         ...(parts.errorCode !== undefined && parts.errorCode.length > 0 ? { _sema_error_code: parts.errorCode } : {}),
         ...(parts.degraded !== undefined ? { _sema_model_degraded: parts.degraded } : {}),
         ...selectedModelParts(parts.model),
@@ -524,8 +641,39 @@ function errorResult(ctx, parts) {
         ...(parts.parkFailedReason !== undefined ? { _sema_park_failed_reason: washCredentials(parts.parkFailedReason) } : {}),
         ...(parts.abortCause !== undefined ? { _sema_abort_cause: parts.abortCause } : {}),
         ...(parts.route !== undefined ? { _sema_route: routeOnFrame(parts.route) } : {}),
+        ...('limit' in arm && arm.limit !== undefined ? { _sema_limit: arm.limit } : {}),
+        ...(parts.wayOut !== undefined ? { _sema_wayOut: wayOutOnFrame(parts.wayOut) } : {}),
+        ...(parts.codedDetail !== undefined ? { _sema_coded_detail: parts.codedDetail } : {}),
+        ...(parts.errorCode !== undefined && parts.errorCode.length > 0 && errorsStateCode(errors[0], parts.errorCode) ? { _sema_error_code_in_text: true } : {}),
+    };
+    if (arm.subtype === 'success') {
+        return stamp(ctx, {
+            uuid: parts.uuid,
+            session_id: undefined,
+            type: 'result',
+            subtype: 'success',
+            ...head,
+            result,
+            errors,
+            ...tail,
+        });
+    }
+    return stamp(ctx, {
+        uuid: parts.uuid,
+        session_id: undefined,
+        type: 'result',
+        subtype: arm.subtype,
+        ...head,
+        errors,
+        ...tail,
     });
 }
+function errorsStateCode(first, code) {
+    return typeof first === 'string' && (first === code || first.startsWith(`${code}\n`) || first.includes(` (${code})`));
+}
+function wayOutOnFrame(wayOut) {
+    return { word: wayOut.word, ...(wayOut.keySource !== undefined ? { keySource: wayOut.keySource } : {}) };
+}
 function routeOnFrame(route) {
     return {
         credentialSource: route.credentialSource,
@@ -534,6 +682,19 @@ function routeOnFrame(route) {
         root: route.root,
     };
 }
+function lastRowOf(observed) {
+    if (observed === undefined || !Object.hasOwn(observed, 'lastRow'))
+        return null;
+    return observed.lastRow ?? null;
+}
+function lastRowTextOf(reading) {
+    if (reading.text === undefined)
+        return undefined;
+    return reading.errorRow === true ? washCredentials(reading.text) : reading.text;
+}
+function failedEventTerminal(code) {
+    return typeof code === 'string' && code.length > 0 ? { kind: 'failed', plane: 'flat', code } : { kind: 'failed', plane: 'flat' };
+}
 export function doneToSdkResult(ev, ctx, observed) {
     const msg = doneToSdkResultBody(ev, ctx, observed);
     return isReplayedTerminal(ev) ? Object.assign({}, msg, { _sema_replay: true }) : msg;
@@ -549,29 +710,40 @@ function doneToSdkResultBody(ev, ctx, observed) {
     if (typeof echoedSid === 'string' && echoedSid.length > 0)
         ctx.sessionId = echoedSid;
     const terminal = readRunTerminal(ev.result);
+    const armReading = printArmReadingOf({ terminal: terminal ?? null, lastRow: lastRowOf(observed) });
+    const arm = armReading.arm;
     const durationMs = elapsedMs(ctx);
     const errorCode = runTerminalCode(terminal);
     const degraded = degradedOf(r);
     const parkFailedReason = readFrameStringKey(ev, '_sema_park_failed_reason');
     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) };
+    const errorBase = { uuid: resultUuid, arm, lastRowText: lastRowTextOf(armReading), 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;
-        const failedSubtype = subtypeForErrorCode(failedCode);
+        const failedLimit = 'limit' in arm ? arm.limit : undefined;
+        const failedCoded = observed !== undefined && Object.hasOwn(observed, 'codedDetail') ? observed.codedDetail : runTerminalCodedDetail(terminal);
         if (failedCode !== undefined && CUTOFF_EXCEEDED_CODES.has(failedCode)) {
             return errorResult(ctx, {
                 ...errorBase,
-                subtype: failedSubtype,
+                ...(failedCoded !== undefined ? { codedDetail: failedCoded } : {}),
                 ...cutoffParts(r, failedMessage, failedCode === LIMITS_MAX_TOKENS_EXCEEDED
                     ? 'run exhausted its token budget'
                     : 'run hit its wall-clock limit', failedCode),
             });
         }
+        const rejection = terminal.detail?.kind === 'provider_rejected' ? terminal.detail : undefined;
+        const wayOutFacts = observed !== undefined && Object.hasOwn(observed, 'wayOutFacts')
+            ? observed.wayOutFacts
+            : failedLimit !== undefined || isLimitsExceededCode(failedCode)
+                ? undefined
+                : localWayOutFacts(r, rejection);
+        const failedWayOut = wayOutFacts === undefined || failedLimit !== undefined ? undefined : wayOutOfApiErrorFacts(wayOutFacts);
         return errorResult(ctx, {
             ...errorBase,
-            subtype: failedSubtype,
+            ...(failedWayOut !== undefined ? { wayOut: failedWayOut } : {}),
+            ...(failedCoded !== undefined ? { codedDetail: failedCoded } : {}),
             ...(terminal.detail?.kind === 'provider_rejected' && terminal.detail.route !== undefined ? { route: terminal.detail.route } : {}),
             errors: [
                 withTerminalNote(isRewindFamilyCode(failedCode) && failedMessage
@@ -583,7 +755,6 @@ function doneToSdkResultBody(ev, ctx, observed) {
     if (terminal?.kind === 'blocked') {
         return errorResult(ctx, {
             ...errorBase,
-            subtype: 'error_during_execution',
             errors: [runBlockedText(terminal)],
         });
     }
@@ -599,7 +770,6 @@ function doneToSdkResultBody(ev, ctx, observed) {
             : `Answer it in the interactive REPL${sid ? ` (sema --resume ${sid})` : ''}, or decide the pending approval via the engine approvals API${sid ? ` (POST /v1/approvals/${sid}/decide)` : ''}.`;
         return errorResult(ctx, {
             ...errorBase,
-            subtype: 'error_during_execution',
             errors: [
                 `Turn suspended awaiting ${awaiting} that no one can provide in -p (non-interactive) mode${runId ? ` (run ${runId})` : ''}. ${wayOut}`,
             ],
@@ -608,7 +778,6 @@ function doneToSdkResultBody(ev, ctx, observed) {
     if (terminal === null || terminal === undefined) {
         return errorResult(ctx, {
             ...errorBase,
-            subtype: 'error_during_execution',
             outcomeUnknown: true,
             errors: [
                 'run ended with no terminal record — outcome unknown, not a failure verdict (this client cannot tell whether the run succeeded; treat the result as unverified)',
@@ -618,7 +787,6 @@ function doneToSdkResultBody(ev, ctx, observed) {
     if (terminal?.kind === 'unknown') {
         return errorResult(ctx, {
             ...errorBase,
-            subtype: 'error_during_execution',
             outcomeUnknown: true,
             errors: [
                 terminal.message ??
@@ -629,24 +797,25 @@ function doneToSdkResultBody(ev, ctx, observed) {
             ],
         });
     }
+    const completedArm = arm;
     return stamp(ctx, {
         uuid: resultUuid,
         session_id: undefined,
         type: 'result',
-        subtype: 'success',
+        subtype: completedArm.subtype,
         duration_ms: durationMs,
         duration_api_ms: durationMs,
-        is_error: false,
+        is_error: completedArm.is_error,
         num_turns: stats?.turns ?? 0,
         result: r.result ?? '',
         ...structuredOutputParts(r),
         ...(degraded !== undefined ? { _sema_model_degraded: degraded } : {}),
-        stop_reason: null,
+        stop_reason: completedArm.stop_reason,
         total_cost_usd: costOrNull(stats),
         usage: flattenUsage(stats),
         modelUsage: modelUsageFor(stats, r.model),
         ...permissionDenialParts(stats, observed),
-        ...terminalReasonParts('success', false),
+        ...terminalReasonParts(completedArm.subtype, completedArm.is_error),
         ...costFactParts(stats, observed),
         ...effectiveFactParts(rec),
         ...nestedUsageByTaskParts(stats, observed?.nestedUsageByTask),
@@ -654,9 +823,10 @@ function doneToSdkResultBody(ev, ctx, observed) {
     });
 }
 export function failedToSdkResult(ev, ctx, observed) {
-    const subtype = subtypeForErrorCode(ev.errorCode);
+    const armReading = printArmReadingOf({ terminal: failedEventTerminal(ev.errorCode), lastRow: lastRowOf(observed) });
     return errorResult(ctx, {
-        subtype,
+        arm: armReading.arm,
+        lastRowText: lastRowTextOf(armReading),
         observed,
         durationMs: elapsedMs(ctx),
         errorCode: ev.errorCode,

package/dist/adapter/runStream.d.ts

@@ -1,7 +1,10 @@
 import type { AgentEvent } from '@sema-agent/sdk';
 import { type SDKMessage, type EmitContext, type ModelUsage } from './types.js';
 import { type EngineTurnUsage } from './downstream/turnUsageToModelUsage.js';
+import type { ObservedTerminalParts } from './downstream/terminalToSdkResult.js';
 import { type ToolHistoryErrorCarrier } from '../toolHistoryMismatch.js';
+import { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESSAGE_PREFIX, RUN_STOPPED_MESSAGE_PREFIX } from '../rowKind.js';
+export { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESSAGE_PREFIX, RUN_STOPPED_MESSAGE_PREFIX };
 export interface ActiveRunPendingGate {
     readonly kind: string | null;
     readonly decidePath: string | null;
@@ -16,13 +19,9 @@ export interface ActiveRunBusySignal {
     readonly msSinceLastActivity?: number;
 }
 export declare function activeRunBusySignal(ev: unknown): ActiveRunBusySignal | null;
-export declare const RUN_STOPPED_MESSAGE_PREFIX = "Run stopped";
-export declare const RUN_BLOCKED_MESSAGE_PREFIX = "Run blocked";
 export declare function isGovernanceStopRowText(text: string): boolean;
-export declare const MODEL_OUTPUT_ERROR_PREFIX = "Model output error";
 export declare function isModelOutputErrorText(text: string): boolean;
 export declare function isModelOutputErrorRowText(text: string): boolean;
-export declare const OUTCOME_UNKNOWN_ROW_PREFIX = "Outcome unknown";
 export declare function isOutcomeUnknownRowText(text: string): boolean;
 export declare function isGovernanceTerminal(input: {
     status: string | undefined;
@@ -36,6 +35,7 @@ export interface RunStreamHandle {
     latestUsage?: ModelUsage;
     latestEngineUsage?: EngineTurnUsage | undefined;
     latestUsageMissing?: true;
+    observedTerminalParts?: () => ObservedTerminalParts;
 }
 export declare function isRunStreamActive(): boolean;
 export declare function runStream(events: AsyncIterable<AgentEvent>, ctx: EmitContext, handle?: RunStreamHandle): AsyncGenerator<SDKMessage>;