@sema-agent/client-core 0.99.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, 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';
@@ -21,6 +21,7 @@ export const INTERNAL_SDK_ARM_TYPES = frozenSet([
     'tool_roster_delta',
     'context_usage',
     'compaction_outcome',
+    'compaction_started',
     'prompt_assembled',
     'workflow_complete',
     'tool_end_result',
@@ -69,15 +70,33 @@ function streamEventArm(ctx, event) {
 const projected = (message) => ({ kind: 'message', message });
 const nothing = (why) => ({ kind: 'none', why });
 const dropped = (why, type) => ({ kind: 'dropped', why, type });
+function isCompactionStartedFrame(ev) {
+    return ev.type === 'compaction_started';
+}
 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;
@@ -85,6 +104,8 @@ function withEngineIdentity(p, ev, ctx) {
     return projected(Object.assign({}, env, { uuid: envelopeUuidOf(eventId, env.type), _sema_engine_ref: ref }));
 }
 function projectEvent(ev, ctx) {
+    if (isCompactionStartedFrame(ev))
+        return compactionStartedProjection(ev, ctx);
     switch (ev.type) {
         case 'task_started':
             return taskStartedProjection(ev, ctx);
@@ -122,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':
@@ -164,6 +188,10 @@ function projectEvent(ev, ctx) {
         }
         case 'compacted': {
             const raw = ev;
+            const pass = typeof raw.pass === 'string' && raw.pass.length > 0 ? raw.pass : undefined;
+            const tokenOf = (v) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined);
+            const tokensBefore = tokenOf(raw.triggerTokensBefore);
+            const tokensAfter = tokenOf(raw.tokensAfter);
             const freedTokens = typeof raw.freedTokens === 'number' && Number.isFinite(raw.freedTokens) && raw.freedTokens >= 0 ? raw.freedTokens : undefined;
             const attachedFiles = raw.attachedFiles;
             const seg = raw.preserved_segment;
@@ -184,6 +212,10 @@ function projectEvent(ev, ctx) {
                         ? { _sema_clamped_ratio: clampedRatio }
                         : {}),
                     ...(freedTokens !== undefined ? { _sema_freed_tokens: freedTokens } : {}),
+                    ...(pass !== undefined ? { _sema_pass: pass } : {}),
+                    ...(tokensBefore !== undefined || tokensAfter !== undefined
+                        ? { _sema_compaction_tokens: { ...(tokensBefore !== undefined ? { before: tokensBefore } : {}), ...(tokensAfter !== undefined ? { after: tokensAfter } : {}) } }
+                        : {}),
                 },
                 ...(Array.isArray(attachedFiles) && attachedFiles.length > 0 ? { _sema_attached_files: attachedFiles } : {}),
             })));
@@ -265,6 +297,7 @@ function projectEvent(ev, ctx) {
             const workflowAgentLabel = ev.workflowAgentLabel;
             const model = ev.model;
             const status = ev.status;
+            const seq = typeof ev.seq === 'number' && Number.isFinite(ev.seq) ? ev.seq : undefined;
             return projected(stamp(ctx, armBody({
                 type: 'task_progress',
                 taskId: ev.taskId,
@@ -284,6 +317,7 @@ function projectEvent(ev, ctx) {
                 ...(ev.parentToolCallId !== undefined
                     ? { parentToolCallId: ev.parentToolCallId }
                     : {}),
+                ...(seq !== undefined ? { seq } : {}),
             })));
         }
         case 'wiring_manifest': {
@@ -297,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({
@@ -582,7 +619,8 @@ function wiringManifestSupersetBody(ev) {
     const fileHistory = projectFileHistorySection(ev);
     const instructions = readInstructionsSegment(ev, 'instructions');
     const fleet = readFleetSegment(ev, 'fleet');
-    if (modelGate === undefined && autoMode === undefined && mcp === undefined && tools === undefined && hooks === undefined && lsp === undefined && writeProtection === undefined && autoConsolidation === undefined && readDeny === undefined && hands === undefined && fileHistory === undefined && instructions === undefined && fleet === undefined)
+    const mods = projectModsSection(ev);
+    if (modelGate === undefined && autoMode === undefined && mcp === undefined && tools === undefined && hooks === undefined && lsp === undefined && writeProtection === undefined && autoConsolidation === undefined && readDeny === undefined && hands === undefined && fileHistory === undefined && instructions === undefined && fleet === undefined && mods === undefined)
         return undefined;
     return {
         ...(modelGate !== undefined ? { _sema_modelGate: modelGate } : {}),
@@ -598,6 +636,7 @@ function wiringManifestSupersetBody(ev) {
         ...(fileHistory !== undefined ? { _sema_fileHistory: fileHistory } : {}),
         ...(instructions !== undefined ? { _sema_instructions: instructions } : {}),
         ...(fleet !== undefined ? { _sema_fleet: fleet } : {}),
+        ...(mods !== undefined ? { _sema_mods: mods } : {}),
     };
 }
 function projectFileHistorySection(holder) {
@@ -636,6 +675,83 @@ function projectReadDenySection(raw) {
         return undefined;
     return { builtinTiers: [...tiers] };
 }
+const _modViewPins = [true, true, true, true, true, true];
+void _modViewPins;
+function projectModsSection(holder) {
+    try {
+        if (!Object.hasOwn(holder, 'mods'))
+            return undefined;
+        const raw = holder.mods;
+        if (!Array.isArray(raw))
+            return undefined;
+        const rows = [];
+        for (const r of raw) {
+            const row = modRowOf(r);
+            if (row !== undefined)
+                rows.push(row);
+        }
+        if (raw.length > 0 && rows.length === 0)
+            return undefined;
+        return rows;
+    }
+    catch {
+        return undefined;
+    }
+}
+function modRowOf(r) {
+    try {
+        if (typeof r !== 'object' || r === null || Array.isArray(r))
+            return undefined;
+        const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+        const strList = (v) => (Array.isArray(v) && v.every((x) => typeof x === 'string') ? [...v] : undefined);
+        const o = r;
+        const name = str(o.name);
+        const seat = str(o.seat);
+        const tier = str(o.tier);
+        if (name === undefined || seat === undefined || tier === undefined)
+            return undefined;
+        const eventsRaw = o.events;
+        const observeRaw = o.observe;
+        const skippedRaw = o.skipped;
+        const refusedByRaw = o.refusedBy;
+        const reasonRaw = o.reason;
+        const hasMountedKey = eventsRaw !== undefined || observeRaw !== undefined || skippedRaw !== undefined;
+        const hasRefusedKey = refusedByRaw !== undefined || reasonRaw !== undefined;
+        if (hasMountedKey && hasRefusedKey)
+            return undefined;
+        if (hasRefusedKey) {
+            const refusedBy = str(refusedByRaw);
+            const reason = str(reasonRaw);
+            return refusedBy === undefined || reason === undefined ? undefined : { name, seat, tier, refusedBy, reason };
+        }
+        const events = strList(eventsRaw);
+        if (events === undefined)
+            return undefined;
+        const observe = observeRaw === undefined ? undefined : strList(observeRaw);
+        const skipped = Array.isArray(skippedRaw)
+            ? skippedRaw.flatMap((x) => {
+                if (typeof x !== 'object' || x === null || Array.isArray(x))
+                    return [];
+                const k = x;
+                const registration = str(k.registration);
+                const cause = str(k.cause);
+                const why = str(k.reason);
+                return registration === undefined || cause === undefined || why === undefined ? [] : [{ registration, cause, reason: why }];
+            })
+            : undefined;
+        return {
+            name,
+            seat,
+            tier,
+            events,
+            ...(observe !== undefined ? { observe } : {}),
+            ...(skipped !== undefined && skipped.length > 0 ? { skipped } : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 function projectHooksSection(raw) {
     if (!Array.isArray(raw))
         return undefined;
@@ -725,14 +841,37 @@ function compactionOutcomeProjection(frame, ctx) {
         return dropped('malformed', 'compaction_outcome');
     const trigger = str(ev.trigger);
     const reason = str(ev.reason);
+    const pass = str(ev.pass);
     return projected(internalArmExit(stamp(ctx, armBody({
         type: 'compaction_outcome',
         outcome,
         ...(trigger !== undefined ? { trigger } : {}),
         ...(reason !== undefined ? { reason } : {}),
+        ...(pass !== undefined ? { pass } : {}),
         ...identity,
     }))));
 }
+function compactionStartedProjection(frame, ctx) {
+    const ev = frame;
+    const { identity, bad } = identityOrMalformed(ev, 'compaction_started');
+    if (bad !== null)
+        return bad;
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const pass = str(ev.pass);
+    const trigger = str(ev.trigger);
+    if (pass === undefined || trigger === undefined)
+        return dropped('malformed', 'compaction_started');
+    const startedAt = typeof ev.startedAt === 'number' && Number.isFinite(ev.startedAt) ? ev.startedAt : undefined;
+    return projected(internalArmExit(stamp(ctx, armBody({
+        type: 'compaction_started',
+        trigger,
+        pass,
+        ...(startedAt !== undefined ? { startedAt } : {}),
+        ...identity,
+    }))));
+}
+const _promptManifestPins = [true, true, true, true, true];
+void _promptManifestPins;
 function promptAssembledProjection(frame, ctx) {
     const ev = frame;
     const { identity, bad } = identityOrMalformed(ev, 'prompt_assembled');
@@ -748,16 +887,13 @@ function promptAssembledProjection(frame, ctx) {
         for (const r of ev.sections) {
             if (typeof r !== 'object' || r === null || Array.isArray(r))
                 continue;
-            const o = r;
-            const id = str(o.id);
-            const chars = size(o.chars);
-            if (id === undefined || chars === undefined)
-                continue;
-            const slot = str(o.slot);
-            rows.push({ id, chars, ...(slot !== undefined ? { slot } : {}) });
+            const row = promptManifestSectionViewOf(r);
+            if (row !== undefined)
+                rows.push(row);
         }
         return rows.length > 0 ? rows : undefined;
     })();
+    const promptIdentity = promptManifestIdentityOfFrame(ev);
     const blocks = (() => {
         if (!Array.isArray(ev.blocks))
             return undefined;
@@ -797,6 +933,7 @@ function promptAssembledProjection(frame, ctx) {
         ...(blocks !== undefined ? { blocks } : {}),
         ...(sections !== undefined ? { sections } : {}),
         ...(tools !== undefined ? { tools } : {}),
+        ...(promptIdentity !== undefined ? { identity: promptIdentity } : {}),
         ...identity,
     }))));
 }

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;