@sema-agent/client-core 0.100.0 → 0.102.0

package/dist/thinkingLatch.js

@@ -0,0 +1,255 @@
+import { readOwnDataValue } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { quoteUntrustedForSentence } from './displayUntrusted.js';
+import { seatCapabilityUnavailableDetail } from './seatContract.js';
+import { THINKING_LATCH_EVENTS, } from './thinkingLatchWords.js';
+const UNSET_WHYS = Object.freeze(['no_port', 'never_set', 'unreadable', 'malformed']);
+const THINKING_LATCH_TRANSITIONS = Object.freeze({
+    on: Object.freeze({ on: 'on', off: 'off', toggle: 'off', clear: 'unset' }),
+    off: Object.freeze({ on: 'on', off: 'off', toggle: 'on', clear: 'unset' }),
+    unset: Object.freeze({ on: 'on', off: 'off', toggle: 'off', clear: 'unset' }),
+});
+const storedOf = (state) => (state === 'on' ? true : state === 'off' ? false : undefined);
+const setReading = (state) => Object.freeze({ state });
+const unsetReading = (why) => Object.freeze({ state: 'unset', why });
+function normalizedReading(v) {
+    try {
+        if (typeof v !== 'object' || v === null)
+            return unsetReading('malformed');
+        const state = readOwnDataValue(v, 'state');
+        if (state === 'on' || state === 'off')
+            return setReading(state);
+        if (state !== 'unset')
+            return unsetReading('malformed');
+        const why = readOwnDataValue(v, 'why');
+        return typeof why === 'string' && UNSET_WHYS.includes(why) ? unsetReading(why) : unsetReading('malformed');
+    }
+    catch {
+        return unsetReading('malformed');
+    }
+}
+export function readThinkingLatch(port) {
+    if (port === undefined || port === null)
+        return unsetReading('no_port');
+    let stored;
+    try {
+        const read = port.read;
+        if (typeof read !== 'function')
+            return unsetReading('unreadable');
+        stored = Reflect.apply(read, port, []);
+    }
+    catch {
+        return unsetReading('unreadable');
+    }
+    if (stored === true)
+        return setReading('on');
+    if (stored === false)
+        return setReading('off');
+    if (stored === undefined)
+        return unsetReading('never_set');
+    return unsetReading('malformed');
+}
+export function writeThinkingLatch(port, event) {
+    if (port === undefined || port === null)
+        return Object.freeze({ kind: 'not_saved', why: 'no_port', previous: unsetReading('no_port') });
+    const previous = readThinkingLatch(port);
+    const ev = event;
+    if (typeof ev !== 'string' || !THINKING_LATCH_EVENTS.includes(ev)) {
+        return Object.freeze({ kind: 'not_saved', why: 'bad_event', previous });
+    }
+    const target = THINKING_LATCH_TRANSITIONS[previous.state][ev];
+    const clean = previous.why === undefined || previous.why === 'never_set';
+    if (clean && target === previous.state)
+        return Object.freeze({ kind: 'unchanged', state: target });
+    let wrote = false;
+    try {
+        const write = port.write;
+        if (typeof write === 'function') {
+            Reflect.apply(write, port, [storedOf(target)]);
+            wrote = true;
+        }
+    }
+    catch {
+        wrote = false;
+    }
+    if (!wrote)
+        return Object.freeze({ kind: 'not_saved', why: 'write_failed', attempted: target, now: readThinkingLatch(port) });
+    return Object.freeze({ kind: 'saved', previous, state: target });
+}
+const ownSlotOf = (v, key) => {
+    try {
+        const d = Object.getOwnPropertyDescriptor(v, key);
+        if (d === undefined)
+            return { kind: 'absent' };
+        return Object.hasOwn(d, 'value') ? { kind: 'data', value: d.value } : { kind: 'unreadable' };
+    }
+    catch {
+        return { kind: 'unreadable' };
+    }
+};
+function capabilityReadingOf(capability) {
+    if (typeof capability !== 'object' || capability === null)
+        return Object.freeze({ kind: 'malformed' });
+    const kind = ownSlotOf(capability, 'kind');
+    if (kind.kind !== 'data')
+        return Object.freeze({ kind: 'malformed' });
+    if (kind.value === 'not_reported')
+        return Object.freeze({ kind: 'not_reported' });
+    if (kind.value === 'reported') {
+        const available = ownSlotOf(capability, 'available');
+        return available.kind === 'data' && typeof available.value === 'boolean'
+            ? Object.freeze({ kind: 'reported', available: available.value })
+            : Object.freeze({ kind: 'malformed' });
+    }
+    return Object.freeze({ kind: 'malformed' });
+}
+const seatCarries = (capability) => {
+    try {
+        return seatCapabilityUnavailableDetail('thinkingLatch', capabilityReadingOf(capability)) === undefined;
+    }
+    catch {
+        return false;
+    }
+};
+const carrierBlocks = (carrier) => {
+    if (carrier.kind === 'absent')
+        return false;
+    if (carrier.kind === 'unreadable')
+        return true;
+    const c = carrier.value;
+    if (c === undefined)
+        return false;
+    if (typeof c !== 'object' || c === null)
+        return true;
+    const kind = ownSlotOf(c, 'kind');
+    if (kind.kind !== 'data')
+        return true;
+    if (kind.value === 'engine')
+        return false;
+    if (kind.value === 'seat') {
+        const capability = ownSlotOf(c, 'capability');
+        return capability.kind !== 'data' || !seatCarries(capability.value);
+    }
+    return true;
+};
+export function thinkingLatchView(reading, ctx) {
+    const r = normalizedReading(reading);
+    let carrier = { kind: 'absent' };
+    let modelSaysNoThinking = false;
+    if (ctx !== undefined && ctx !== null) {
+        if (typeof ctx !== 'object')
+            carrier = { kind: 'unreadable' };
+        else {
+            carrier = ownSlotOf(ctx, 'carrier');
+            const model = ownSlotOf(ctx, 'model');
+            if (model.kind === 'data' && typeof model.value === 'object' && model.value !== null) {
+                const mk = ownSlotOf(model.value, 'kind');
+                modelSaysNoThinking = mk.kind === 'data' && mk.value === 'not_applicable';
+            }
+        }
+    }
+    const conflict = carrierBlocks(carrier) ? 'seat_cannot_carry' : r.state === 'on' && modelSaysNoThinking ? 'model_cannot_think' : undefined;
+    return Object.freeze({ state: r.state, ...(r.why !== undefined ? { why: r.why } : {}), ...(conflict !== undefined ? { conflict } : {}) });
+}
+const MODEL_NAME_MAX = 120;
+const stateSentence = (state, lang) => state === 'on'
+    ? renderMessage(msg('session.thinking.state.on'), lang)
+    : state === 'off'
+        ? renderMessage(msg('session.thinking.state.off'), lang)
+        : state === 'unset'
+            ? renderMessage(msg('session.thinking.state.unset'), lang)
+            : undefined;
+export function thinkingLatchSentence(subject, lang) {
+    try {
+        if (typeof subject !== 'object' || subject === null)
+            return undefined;
+        const kind = readOwnDataValue(subject, 'kind');
+        if (kind === 'state')
+            return stateSentence(readOwnDataValue(subject, 'state'), lang);
+        if (kind === 'turn') {
+            const p = readOwnDataValue(subject, 'projection');
+            if (typeof p !== 'object' || p === null)
+                return undefined;
+            return readOwnDataValue(p, 'verdict') === 'off' && readOwnDataValue(p, 'ultracodeStamped') === true
+                ? renderMessage(msg('session.thinking.offWithUltracodeOnBody'), lang)
+                : undefined;
+        }
+        if (kind === 'view') {
+            const view = readOwnDataValue(subject, 'view');
+            if (typeof view !== 'object' || view === null)
+                return undefined;
+            const conflict = readOwnDataValue(view, 'conflict');
+            if (conflict === 'seat_cannot_carry') {
+                const carrier = readOwnDataValue(subject, 'carrier');
+                const capability = typeof carrier === 'object' && carrier !== null && readOwnDataValue(carrier, 'kind') === 'seat'
+                    ? readOwnDataValue(carrier, 'capability')
+                    : undefined;
+                return seatCapabilityUnavailableDetail('thinkingLatch', capabilityReadingOf(capability));
+            }
+            if (conflict === 'model_cannot_think') {
+                const model = readOwnDataValue(subject, 'model');
+                const shown = typeof model === 'string' && model.length > 0 ? quoteUntrustedForSentence(model, MODEL_NAME_MAX) : undefined;
+                return shown === undefined ? undefined : renderMessage(msg('session.thinking.modelCannotThink', { model: shown }), lang);
+            }
+            if (conflict !== undefined)
+                return undefined;
+            const r = normalizedReading(view);
+            if (r.why === 'unreadable' || r.why === 'malformed')
+                return renderMessage(msg('session.thinking.storeUnreadable'), lang);
+            return stateSentence(r.state, lang);
+        }
+        if (kind === 'write') {
+            const outcome = readOwnDataValue(subject, 'outcome');
+            if (typeof outcome !== 'object' || outcome === null)
+                return undefined;
+            return readOwnDataValue(outcome, 'kind') === 'not_saved' ? renderMessage(msg('session.thinking.notSaved'), lang) : undefined;
+        }
+        if (kind === 'seat_ack') {
+            const ack = readOwnDataValue(subject, 'ack');
+            if (typeof ack !== 'object' || ack === null)
+                return undefined;
+            return readOwnDataValue(ack, 'ok') === false ? renderMessage(msg('session.thinking.notSaved'), lang) : undefined;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function thinkingLatchRowWordOf(reading) {
+    const r = normalizedReading(reading);
+    if (r.state === 'on' || r.state === 'off')
+        return r.state;
+    if (r.why === 'unreadable')
+        return 'unreadable';
+    if (r.why === 'malformed')
+        return 'malformed';
+    return undefined;
+}
+export function readSeatThinkingLatch(record, capability) {
+    if (!seatCarries(capability))
+        return unsetReading('no_port');
+    const row = record;
+    if (row === undefined || row === null)
+        return unsetReading('no_port');
+    try {
+        if (typeof row !== 'object')
+            return unsetReading('malformed');
+        const d = Object.getOwnPropertyDescriptor(row, 'thinkingLatch');
+        if (d === undefined)
+            return unsetReading('never_set');
+        if (!Object.hasOwn(d, 'value'))
+            return unsetReading('malformed');
+        const w = d.value;
+        if (w === undefined)
+            return unsetReading('never_set');
+        if (w === 'on' || w === 'off')
+            return setReading(w);
+        if (w === 'unreadable')
+            return unsetReading('unreadable');
+        return unsetReading('malformed');
+    }
+    catch {
+        return unsetReading('unreadable');
+    }
+}

package/dist/thinkingLatchWords.d.ts

@@ -0,0 +1,7 @@
+export declare const THINKING_LATCH_STATES: readonly ["on", "off", "unset"];
+export type ThinkingLatchState = (typeof THINKING_LATCH_STATES)[number];
+export declare const THINKING_LATCH_SET_STATES: readonly ["on", "off"];
+export declare const THINKING_LATCH_EVENTS: readonly ["on", "off", "toggle", "clear"];
+export type ThinkingLatchEvent = (typeof THINKING_LATCH_EVENTS)[number];
+export declare const THINKING_LATCH_ROW_WORDS: readonly ["on", "off", "unreadable", "malformed"];
+export type ThinkingLatchRowWord = (typeof THINKING_LATCH_ROW_WORDS)[number];

package/dist/thinkingLatchWords.js

@@ -0,0 +1,4 @@
+export const THINKING_LATCH_STATES = Object.freeze(['on', 'off', 'unset']);
+export const THINKING_LATCH_SET_STATES = Object.freeze(['on', 'off']);
+export const THINKING_LATCH_EVENTS = Object.freeze(['on', 'off', 'toggle', 'clear']);
+export const THINKING_LATCH_ROW_WORDS = Object.freeze(['on', 'off', 'unreadable', 'malformed']);

package/dist/toolHistoryMismatch.d.ts

@@ -29,6 +29,8 @@ export interface ToolHistoryMismatchRowKey {
 }
 export declare function toolHistoryMismatchRowKey(m: ToolHistoryMismatch, consecutive: number | undefined, rewindOffered: boolean): ToolHistoryMismatchRowKey;
 export declare function readToolHistoryMismatchKey(v: object | null | undefined): ToolHistoryMismatchRowKey | undefined;
+export declare const SEMA_TOOL_HISTORY_ACCEPTED_KEY = "_sema_tool_history_accepted";
+export declare function readToolHistoryAcceptedKey(frame: object | null | undefined): true | undefined;
 export declare const TOOL_HISTORY_LEDGER_CAP = 64;
 export declare function openToolHistoryGeneration(): number;
 export interface ToolHistoryTerminalNote {
@@ -38,8 +40,14 @@ export interface ToolHistoryTerminalNote {
     runId: string | undefined;
     replay: boolean;
     mismatch: ToolHistoryMismatch | null;
+    accepted?: boolean;
+}
+export interface ToolHistoryTerminalFacts {
+    readonly consecutive: number | undefined;
+    readonly acceptedSinceMismatch: true | undefined;
 }
 export declare function noteToolHistoryTerminal(note: ToolHistoryTerminalNote): number | undefined;
+export declare function noteToolHistoryTerminalFacts(note: ToolHistoryTerminalNote): ToolHistoryTerminalFacts;
 export declare function _resetToolHistoryLedgerForTest(): void;
 export interface ToolHistoryRow {
     readonly toolUseIds?: readonly string[];

package/dist/toolHistoryMismatch.js

@@ -286,6 +286,18 @@ function ownDataMember(o, k) {
         return undefined;
     }
 }
+export const SEMA_TOOL_HISTORY_ACCEPTED_KEY = '_sema_tool_history_accepted';
+export function readToolHistoryAcceptedKey(frame) {
+    try {
+        if (typeof frame !== 'object' || frame === null)
+            return undefined;
+        const d = Object.getOwnPropertyDescriptor(frame, SEMA_TOOL_HISTORY_ACCEPTED_KEY);
+        return d !== undefined && Object.hasOwn(d, 'value') && d.value === true ? true : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export const TOOL_HISTORY_LEDGER_CAP = 64;
 const PRIOR_RUN_IDS_CAP = 16;
 const ECHOED_SESSION_IDS_CAP = TOOL_HISTORY_LEDGER_CAP * 4;
@@ -308,16 +320,30 @@ export function openToolHistoryGeneration() {
     return toolHistoryGenerationSeq;
 }
 const fingerprintOf = (m) => `${m.kind}\u0000${m.toolUseId ?? ''}`;
+function acceptanceStep(prev, note, attributed) {
+    if (note.replay)
+        return { awaiting: prev, accepted: undefined };
+    if (note.mismatch !== null)
+        return { awaiting: true, accepted: undefined };
+    if (note.accepted === true)
+        return attributed ? { awaiting: false, accepted: prev ? true : undefined } : { awaiting: prev, accepted: undefined };
+    return { awaiting: prev, accepted: undefined };
+}
 export function noteToolHistoryTerminal(note) {
+    return noteToolHistoryTerminalFacts(note).consecutive;
+}
+export function noteToolHistoryTerminalFacts(note) {
+    const none = { consecutive: undefined, acceptedSinceMismatch: undefined };
     const { sessionId, generation, runId, replay, mismatch } = note;
     if (typeof sessionId !== 'string' || sessionId.length === 0) {
         unattributedTerminalSeq += 1;
-        return undefined;
+        return none;
     }
     if (note.sessionEchoed === true)
         rememberEchoedSession(sessionId);
     else if (!echoedSessionIds.has(sessionId))
         unattributedTerminalSeq += 1;
+    const attributed = note.sessionEchoed === true || echoedSessionIds.has(sessionId);
     const row = toolHistoryLedger.get(sessionId);
     const fingerprint = mismatch === null ? null : fingerprintOf(mismatch);
     const run = !replay && typeof runId === 'string' && runId.length > 0 ? runId : undefined;
@@ -330,25 +356,29 @@ export function noteToolHistoryTerminal(note) {
                 unattributedMark: unattributedTerminalSeq,
                 lastRunId: undefined,
                 recentRunIds: run !== undefined ? [...row.recentRunIds, run].slice(-PRIOR_RUN_IDS_CAP) : row.recentRunIds,
+                awaitingAcceptance: row.awaitingAcceptance,
             });
         }
-        return undefined;
+        return none;
     }
     if (row !== undefined)
         row.writtenGeneration = generation;
     const interrupted = row !== undefined && row.unattributedMark < unattributedTerminalSeq;
     if (run !== undefined && row !== undefined && (row.segmentRunIds.has(run) || row.recentRunIds.includes(run))) {
-        return !interrupted && row.lastRunId === run && fingerprint !== null && row.fingerprint === fingerprint ? row.segmentRunIds.size : undefined;
+        const repeated = !interrupted && row.lastRunId === run && fingerprint !== null && row.fingerprint === fingerprint ? row.segmentRunIds.size : undefined;
+        return { consecutive: repeated, acceptedSinceMismatch: undefined };
     }
+    const acceptance = acceptanceStep(row?.awaitingAcceptance ?? false, note, attributed);
     if (row !== undefined && row.fingerprint === fingerprint && !(interrupted && fingerprint !== null && run !== undefined)) {
+        row.awaitingAcceptance = acceptance.awaiting;
         if (run === undefined)
-            return undefined;
+            return { consecutive: undefined, acceptedSinceMismatch: acceptance.accepted };
         if (fingerprint !== null)
             row.segmentRunIds.add(run);
         row.lastRunId = run;
         row.recentRunIds = [...row.recentRunIds, run].slice(-PRIOR_RUN_IDS_CAP);
         touchLedgerRow(sessionId, row);
-        return fingerprint === null ? undefined : row.segmentRunIds.size;
+        return { consecutive: fingerprint === null ? undefined : row.segmentRunIds.size, acceptedSinceMismatch: acceptance.accepted };
     }
     touchLedgerRow(sessionId, {
         fingerprint,
@@ -357,8 +387,9 @@ export function noteToolHistoryTerminal(note) {
         unattributedMark: unattributedTerminalSeq,
         lastRunId: run,
         recentRunIds: run !== undefined ? [...(row?.recentRunIds ?? []), run].slice(-PRIOR_RUN_IDS_CAP) : [...(row?.recentRunIds ?? [])],
+        awaitingAcceptance: acceptance.awaiting,
     });
-    return fingerprint !== null && run !== undefined ? 1 : undefined;
+    return { consecutive: fingerprint !== null && run !== undefined ? 1 : undefined, acceptedSinceMismatch: acceptance.accepted };
 }
 function touchLedgerRow(sessionId, row) {
     toolHistoryLedger.delete(sessionId);

package/dist/toolResult.d.ts

@@ -112,21 +112,31 @@ export interface ToolResultRowFlags {
 }
 export declare function toolResultRowFlagsOf(row: object | null | undefined): ToolResultRowFlags;
 export type ToolKillCause = NonNullable<ReturnType<typeof toolKillCauseAcrossEngineIdentity>> | 'memory_pressure';
-export declare function wireOutputToBody(toolName: string, output: unknown, isError: boolean, truncated: boolean, flatten: FlattenWireOutput, structured?: unknown, leaderLedger?: boolean, killCauseOf?: () => ToolKillCause | undefined): ToolResultBody;
+export declare function wireOutputToBody(toolName: string, output: unknown, isError: boolean, truncated: boolean, flatten: FlattenWireOutput, structuredIn?: unknown, leaderLedger?: boolean, killCauseOf?: () => ToolKillCause | undefined): ToolResultBody;
 export declare function structuredToToolUseResult(structured: unknown, modelText?: string, leaderLedger?: boolean): {
     toolUseResult: unknown;
     isError?: boolean;
 } | null;
+export interface WebSearchSource {
+    readonly title: string;
+    readonly url: string;
+}
+export type WebSearchSources = readonly WebSearchSource[] & {
+    readonly droppedCount: number;
+};
+export declare function webSearchSourcesOf(toolEnd: {} | null | undefined): WebSearchSources | undefined;
 export interface EngineBgShellRegistration {
     kind: 'register';
     taskId: string;
+    toolUseId?: string;
     command: string;
     description?: string;
     receipt: string;
+    outputFile?: string;
     source: 'bash' | 'monitor';
 }
-export declare function detectEngineBgShellReceipt(toolName: string, rawInput: unknown, outputText: string | undefined, structured?: unknown): EngineBgShellRegistration | null;
-export declare function detectEngineBgShellDetach(toolName: string, rawInput: unknown, structured: unknown, outputText: string | undefined): EngineBgShellRegistration | null;
+export declare function detectEngineBgShellReceipt(toolName: string, rawInput: unknown, outputText: string | undefined, structured?: unknown, toolUseId?: string): EngineBgShellRegistration | null;
+export declare function detectEngineBgShellDetach(toolName: string, rawInput: unknown, structured: unknown, outputText: string | undefined, toolUseId?: string): EngineBgShellRegistration | null;
 export declare function todoWriteToolUseResult(rawInput: unknown, oldTodos: unknown[], isError: boolean): {
     toolUseResult: unknown;
     isError: boolean;