@sema-agent/client-core 0.101.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/toolResult.js

@@ -4,7 +4,7 @@ import { parseWorkflowPollEnvelope, projectWorkflowTaskOutput } from './workflow
 import { asModelFallbackReason } from './engineErrorCodes.js';
 import { frozenSet } from './frozenSet.js';
 import { bashExitOf, bashExitReadingFailed } from './bashExitReading.js';
-import { guardedRead, ownSnapshotWhenTyped, readFrameTrueMark, readFrameTrueMarkReading, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue, } from './ownKey.js';
+import { guardedRead, ownDataField, ownSnapshotWhenTyped, readFrameTrueMark, readFrameTrueMarkReading, readOwnDataFiniteNumber, readOwnDataNonEmptyString, readOwnDataValue, toolResultBlockOf, } from './ownKey.js';
 import { displayUntrusted } from './displayUntrusted.js';
 import { isCoreSemaTaskTerminal } from './terminalStatuses.js';
 import { CORE_ENGINE_CARD_TYPES } from './generated/engineFactTables.js';
@@ -285,29 +285,7 @@ const TOOL_CARD_DEGRADED_TEXT = {
     unrecognised: 'This tool call carries a result marker this client does not recognise, so no result is shown for it.',
 };
 const cardDegraded = (cause) => ({ kind: 'degraded', cause, text: TOOL_CARD_DEGRADED_TEXT[cause] });
-function cardOwnData(o, key) {
-    const d = Object.getOwnPropertyDescriptor(o, key);
-    if (d === undefined)
-        return undefined;
-    if (!Object.hasOwn(d, 'value'))
-        throw new TypeError(`own property "${key}" is an accessor`);
-    return d.value;
-}
 const isCardRecordObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
-function toolResultBlockOf(record) {
-    const message = cardOwnData(record, 'message');
-    if (!isCardRecordObject(message))
-        return undefined;
-    const content = cardOwnData(message, 'content');
-    if (!Array.isArray(content))
-        return undefined;
-    for (let i = 0; i < content.length; i++) {
-        const block = cardOwnData(content, String(i));
-        if (isCardRecordObject(block) && cardOwnData(block, 'type') === 'tool_result')
-            return block;
-    }
-    return undefined;
-}
 export function readToolCardOutcome(record) {
     try {
         if (!isCardRecordObject(record))
@@ -327,7 +305,7 @@ export function readToolCardOutcome(record) {
             return { kind: 'unreadable' };
         if (markerDesc.value !== TOOL_RESULT_DEGRADED_WIRE_NO_OUTPUT)
             return cardDegraded('unrecognised');
-        return cardDegraded(cardOwnData(block, 'is_error') === true ? 'error-without-detail' : 'no-result');
+        return cardDegraded(ownDataField(block, 'is_error') === true ? 'error-without-detail' : 'no-result');
     }
     catch {
         return { kind: 'unreadable' };