@sema-agent/client-core 0.100.0 → 0.102.0

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/downstream/wiringManifestView.d.ts

@@ -46,3 +46,4 @@ export declare function readInstructionsSegment(holder: object, key: 'instructio
 } | undefined;
 export declare function readFleetSegment(holder: object, key: 'fleet' | '_sema_fleet'): WiringManifestFleetView | undefined;
 export declare function wiringManifestViewOf(s: WiringManifestSections): WiringManifestView | undefined;
+export declare function modRowsOf(records: unknown): readonly WiringManifestModView[] | undefined;

package/dist/adapter/downstream/wiringManifestView.js

@@ -1,3 +1,4 @@
+import { appendOwnElement } from '../../ownKey.js';
 const _viewPin = true;
 void _viewPin;
 const _viewKeysPin = true;
@@ -67,3 +68,140 @@ export function wiringManifestViewOf(s) {
         view.eventId = s.eventId;
     return view;
 }
+const isModRecordObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function ownSlot(o, key) {
+    try {
+        const d = Object.getOwnPropertyDescriptor(o, key);
+        if (d === undefined)
+            return { state: 'absent' };
+        if (!Object.hasOwn(d, 'value'))
+            return { state: 'unreadable' };
+        return d.value === undefined ? { state: 'absent' } : { state: 'value', value: d.value };
+    }
+    catch {
+        return { state: 'unreadable' };
+    }
+}
+function ownLength(v) {
+    const s = ownSlot(v, 'length');
+    return s.state === 'value' && typeof s.value === 'number' && Number.isSafeInteger(s.value) && s.value >= 0 ? s.value : undefined;
+}
+const nonEmpty = (s) => (s.state === 'value' && typeof s.value === 'string' && s.value.length > 0 ? s.value : undefined);
+function ownStringList(v) {
+    try {
+        if (!Array.isArray(v))
+            return undefined;
+        const n = ownLength(v);
+        if (n === undefined)
+            return undefined;
+        const out = [];
+        for (let i = 0; i < n; i++) {
+            const x = ownSlot(v, String(i));
+            if (x.state !== 'value' || typeof x.value !== 'string')
+                return undefined;
+            appendOwnElement(out, x.value);
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}
+function skipOf(x) {
+    try {
+        if (!isModRecordObject(x))
+            return undefined;
+        const registration = nonEmpty(ownSlot(x, 'registration'));
+        const cause = nonEmpty(ownSlot(x, 'cause'));
+        const reason = nonEmpty(ownSlot(x, 'reason'));
+        return registration === undefined || cause === undefined || reason === undefined ? undefined : { registration, cause, reason };
+    }
+    catch {
+        return undefined;
+    }
+}
+function modRowOf(r) {
+    try {
+        if (!isModRecordObject(r))
+            return undefined;
+        const name = nonEmpty(ownSlot(r, 'name'));
+        const seat = nonEmpty(ownSlot(r, 'seat'));
+        const tier = nonEmpty(ownSlot(r, 'tier'));
+        if (name === undefined || seat === undefined || tier === undefined)
+            return undefined;
+        const events = ownSlot(r, 'events');
+        const observe = ownSlot(r, 'observe');
+        const skipped = ownSlot(r, 'skipped');
+        const refusedBy = ownSlot(r, 'refusedBy');
+        const reason = ownSlot(r, 'reason');
+        const hasMountedKey = events.state !== 'absent' || observe.state !== 'absent' || skipped.state !== 'absent';
+        const hasRefusedKey = refusedBy.state !== 'absent' || reason.state !== 'absent';
+        if (hasMountedKey && hasRefusedKey)
+            return undefined;
+        if (hasRefusedKey) {
+            const by = nonEmpty(refusedBy);
+            const why = nonEmpty(reason);
+            if (by === undefined || why === undefined)
+                return undefined;
+            const refused = { name, seat, tier, refusedBy: by, reason: why };
+            return refused;
+        }
+        const eventList = events.state === 'value' ? ownStringList(events.value) : undefined;
+        if (eventList === undefined)
+            return undefined;
+        const observeList = observe.state === 'value' ? ownStringList(observe.value) : undefined;
+        const skipList = skipped.state === 'value' ? skipListOf(skipped.value) : undefined;
+        const mounted = {
+            name,
+            seat,
+            tier,
+            events: eventList,
+            ...(observeList !== undefined ? { observe: observeList } : {}),
+            ...(skipList !== undefined && skipList.length > 0 ? { skipped: skipList } : {}),
+        };
+        return mounted;
+    }
+    catch {
+        return undefined;
+    }
+}
+function skipListOf(v) {
+    try {
+        if (!Array.isArray(v))
+            return undefined;
+        const n = ownLength(v);
+        if (n === undefined)
+            return undefined;
+        const out = [];
+        for (let i = 0; i < n; i++) {
+            const x = ownSlot(v, String(i));
+            const s = x.state === 'value' ? skipOf(x.value) : undefined;
+            if (s !== undefined)
+                appendOwnElement(out, s);
+        }
+        return out;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function modRowsOf(records) {
+    try {
+        if (!Array.isArray(records))
+            return undefined;
+        const n = ownLength(records);
+        if (n === undefined)
+            return undefined;
+        const rows = [];
+        for (let i = 0; i < n; i++) {
+            const x = ownSlot(records, String(i));
+            const row = x.state === 'value' ? modRowOf(x.value) : undefined;
+            if (row !== undefined)
+                appendOwnElement(rows, row);
+        }
+        return n > 0 && rows.length === 0 ? undefined : rows;
+    }
+    catch {
+        return undefined;
+    }
+}

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>;