@sema-agent/client-core 0.99.0 → 0.100.0

package/dist/hostTurnSettings.js

@@ -1,6 +1,9 @@
 import { SETTINGS_CLASSIFY_HOOKS_CONFIG } from './generated/settingsSchemaFns.js';
 import { hooksWirePlanShapeOf } from './pluginHooksWire.js';
-export const HOST_SUPPLIED_KEYS = Object.freeze(['settings.hooks', 'settings.resolved', 'settings.webSearch', 'settings.outputStyle']);
+import { resolveWebSearchVerdict, webSearchVerdictMessage } from './webSearchWireCaps.js';
+import { fileHistoryTightenVerdict, fileHistoryUnjudgedRefusal } from './fileHistoryCaptureCapability.js';
+import { msg, renderMessage } from './i18n/translate.js';
+export const HOST_SUPPLIED_KEYS = Object.freeze(['settings.hooks', 'settings.resolved', 'settings.webSearch', 'settings.outputStyle', 'memory', 'fileHistory']);
 export const HOST_SETTING_CAUSES = Object.freeze([
     'carried',
     'entries_dropped',
@@ -10,6 +13,7 @@ export const HOST_SETTING_CAUSES = Object.freeze([
     'empty',
     'no_source',
     'host_port_missing',
+    'value_malformed',
 ]);
 export const HOST_SETTING_DISPOSITIONS = Object.freeze(['carry', 'carry_partial', 'withhold_notice', 'refuse_turn', 'unwired', 'nothing_to_carry']);
 const HOST_SETTING_NOTICE_TEXT = {
@@ -17,12 +21,17 @@ const HOST_SETTING_NOTICE_TEXT = {
     'HS-MANAGED-REJECTED': () => 'Managed settings: the hooks your administrator configured could not be loaded, so requests are not sent until the managed settings are fixed.',
     'HS-PROJECTION': () => 'The hooks for this request could not be checked before sending, so the request is not sent. Reload your settings and try again.',
     'HS-SOURCE-UNREADABLE': (what) => `This app could not read ${what} from your settings, so the request is not sent. Reload your settings and try again.`,
+    'HS-WEBSEARCH-MALFORMED': (sentence) => sentence,
+    'HS-SWITCH-MALFORMED': () => renderMessage(msg('session.hostSettings.memorySwitchMalformed')),
+    'HS-FILEHISTORY-UNJUDGED': (sentence) => sentence,
 };
 const KEY_NOUN = {
     'settings.hooks': 'the hooks',
     'settings.resolved': 'the permission rules',
     'settings.webSearch': 'the web search setup',
     'settings.outputStyle': 'the output style',
+    memory: 'auto-memory',
+    fileHistory: 'file checkpoints',
 };
 const BASE_DISPOSITION = {
     carried: 'carry',
@@ -33,6 +42,7 @@ const BASE_DISPOSITION = {
     empty: 'nothing_to_carry',
     no_source: 'nothing_to_carry',
     host_port_missing: 'unwired',
+    value_malformed: 'refuse_turn',
 };
 const freeze = (o) => Object.freeze(o);
 const mint = (o) => o;
@@ -69,8 +79,11 @@ function hooksPassJudge(wire) {
         return false;
     }
 }
+class HostSourceShapeError extends TypeError {
+    code = 'host_source_shape';
+}
 function badSource(key, want) {
-    return new TypeError(`hostTurnSettings: sources.${key.replace(/^settings\./, '')} must be 'none' or ${want} — got something else (the value is not echoed).`);
+    return new HostSourceShapeError(`hostTurnSettings: sources.${key.replace(/^settings\./, '')} must be 'none' or ${want} — got something else (the value is not echoed).`);
 }
 const missingArm = (key) => ({
     row: freeze({ key, cause: 'host_port_missing', disposition: BASE_DISPOSITION.host_port_missing }),
@@ -132,6 +145,131 @@ function hooksArm(src) {
         return { row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [], plan };
     return { ...carriedArm(key, carried), plan };
 }
+function webSearchArm(src) {
+    const key = 'settings.webSearch';
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const v = src.value;
+    if (v === 'none')
+        return noSourceArm(key);
+    let section;
+    let env;
+    let apiKeyFor;
+    try {
+        if (!isRecordShape(v) || !Object.hasOwn(v, 'env') || Object.hasOwn(v, 'settings'))
+            throw badSource(key, "{ section, env } with the raw webSearch section of the settings and the environment (since 0.100.0 the entry judges it; do not pass the judged settings)");
+        section = v.section;
+        env = v.env;
+        apiKeyFor = v.apiKeyFor;
+    }
+    catch (e) {
+        if (e instanceof HostSourceShapeError)
+            throw e;
+        return unreadableArm(key);
+    }
+    if (!isRecordShape(env))
+        throw badSource(key, '{ section, env } where env is the environment record (pass {} where there is none)');
+    if (apiKeyFor !== undefined && typeof apiKeyFor !== 'function')
+        throw badSource(key, '{ section, env, apiKeyFor? } where apiKeyFor is a function');
+    const verdict = resolveWebSearchVerdict(env, section, apiKeyFor);
+    if (verdict.kind === 'absent')
+        return { row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [] };
+    if (verdict.kind === 'honored')
+        return carriedArm(key, freeze({ ...verdict.settings }));
+    return {
+        row: freeze({ key, cause: 'value_malformed', disposition: BASE_DISPOSITION.value_malformed }),
+        notices: [notice('HS-WEBSEARCH-MALFORMED', 'turn', webSearchVerdictMessage(verdict, 'submit') ?? '')],
+    };
+}
+function memoryArm(src, judge) {
+    const key = 'memory';
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const v = src.value;
+    if (v === 'none')
+        return noSourceArm(key);
+    let flag;
+    let settingsMemory;
+    try {
+        if (!isRecordShape(v))
+            throw badSource(key, '{ flag?, settingsMemory? } with the --memory flag word and the memory section of the settings');
+        flag = v.flag;
+        settingsMemory = v.settingsMemory;
+    }
+    catch (e) {
+        if (e instanceof HostSourceShapeError)
+            throw e;
+        return unreadableArm(key);
+    }
+    if (judge({ flag }))
+        return carriedArm(key, 'off');
+    let bySettings;
+    try {
+        bySettings = judge({ settingsMemory });
+    }
+    catch {
+        return { row: freeze({ key, cause: 'value_malformed', disposition: 'withhold_notice' }), notices: [notice('HS-SWITCH-MALFORMED', 'session')] };
+    }
+    if (bySettings)
+        return carriedArm(key, 'off');
+    return { row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [] };
+}
+const UNOBSERVED_READING = Object.freeze({ kind: 'unobserved' });
+function fileHistoryReadingSnapshot(reading) {
+    try {
+        if (typeof reading !== 'object' || reading === null)
+            return UNOBSERVED_READING;
+        const kind = reading.kind;
+        if (kind === 'present') {
+            const word = reading.word;
+            return Object.freeze({ kind, word });
+        }
+        return Object.freeze({ kind });
+    }
+    catch {
+        return UNOBSERVED_READING;
+    }
+}
+function fileHistoryArm(src) {
+    const key = 'fileHistory';
+    if (src.kind === 'missing')
+        return missingArm(key);
+    if (src.kind === 'threw')
+        return unreadableArm(key);
+    const v = src.value;
+    if (v === 'none')
+        return noSourceArm(key);
+    let reading;
+    let captureOff;
+    try {
+        if (!isRecordShape(v) || !Object.hasOwn(v, 'captureOff'))
+            throw badSource(key, '{ reading, captureOff } with the engine capability reading and the switch');
+        reading = v.reading;
+        captureOff = v.captureOff;
+    }
+    catch (e) {
+        if (e instanceof HostSourceShapeError)
+            throw e;
+        return unreadableArm(key);
+    }
+    if (typeof captureOff !== 'boolean')
+        throw badSource(key, '{ reading, captureOff } where captureOff is a boolean');
+    const snap = fileHistoryReadingSnapshot(reading);
+    const verdict = fileHistoryTightenVerdict(snap, captureOff);
+    if (verdict === 'declare')
+        return carriedArm(key, 'disabled');
+    if (verdict === 'unjudged') {
+        return {
+            row: freeze({ key, cause: 'value_malformed', disposition: 'refuse_turn' }),
+            notices: [notice('HS-FILEHISTORY-UNJUDGED', 'turn', fileHistoryUnjudgedRefusal(snap, true) ?? fileHistoryUnjudgedRefusal(UNOBSERVED_READING, true) ?? '')],
+        };
+    }
+    return { row: freeze({ key, cause: 'empty', disposition: BASE_DISPOSITION.empty }), notices: [] };
+}
 function passArm(key, field, src, want) {
     if (src.kind === 'missing')
         return missingArm(key);
@@ -155,7 +293,8 @@ export function rethrowHostResolvedDeferred(product) {
     if (box !== undefined)
         throw box.error;
 }
-export function buildHostTurnSettings(input, materialize) {
+export function buildHostTurnSettings(input, judges) {
+    const materialize = judges.materialize;
     let sources;
     let sourcesThrew = false;
     try {
@@ -177,9 +316,11 @@ export function buildHostTurnSettings(input, materialize) {
         }
     }
     const hooks = hooksArm(read('hooks'));
-    const webSearch = passArm('settings.webSearch', 'settings', read('webSearch'), '{ settings } with the web search settings');
+    const webSearch = webSearchArm(read('webSearch'));
     const outputStyle = passArm('settings.outputStyle', 'name', read('outputStyle'), '{ name } with the output style name');
-    const arms = [hooks, resolved, webSearch, outputStyle];
+    const memory = memoryArm(read('memory'), judges.memoryOffDeclared);
+    const fileHistory = fileHistoryArm(read('fileHistory'));
+    const arms = [hooks, resolved, webSearch, outputStyle, memory, fileHistory];
     const rows = freeze(arms.map((a) => a.row));
     const notices = freeze(arms.flatMap((a) => a.notices));
     const refusal = arms.find((a) => a.row.disposition === 'refuse_turn');
@@ -189,6 +330,8 @@ export function buildHostTurnSettings(input, materialize) {
         ...(resolvedCarried !== undefined ? { resolved: resolvedCarried } : {}),
         ...(webSearch.carried !== undefined ? { webSearch: webSearch.carried } : {}),
         ...(outputStyle.carried !== undefined ? { outputStyle: outputStyle.carried } : {}),
+        ...(memory.carried !== undefined ? { memory: 'off' } : {}),
+        ...(fileHistory.carried !== undefined ? { fileHistory: 'disabled' } : {}),
     });
     const product = { verdict, rows, notices, hooks: hooks.plan, carried };
     if (resolvedError !== undefined)
@@ -218,6 +361,7 @@ export function hostSettingsSelfCheck(product) {
         return HOST_SUPPLIED_KEYS;
     }
 }
+export const hostProjectionNotice = () => notice('HS-PROJECTION', 'turn');
 export class HostSettingsRefused extends Error {
     notice;
     constructor(n) {
@@ -260,9 +404,13 @@ export function hostTurnSettingsOf(v, depth = 'full') {
         const p = view;
         const rows = p.rows;
         const carried = p.carried;
-        const subs = HOST_SUPPLIED_KEYS.map((k) => k.slice('settings.'.length));
+        const subs = HOST_SUPPLIED_KEYS.map(carriedKeyOf);
         if (Object.keys(carried).some((k) => !subs.includes(k)))
             return undefined;
+        if (carried.memory !== undefined && carried.memory !== 'off')
+            return undefined;
+        if (carried.fileHistory !== undefined && carried.fileHistory !== 'disabled')
+            return undefined;
         let refuses = false;
         for (const [i, r] of rows.entries()) {
             const disposition = r.disposition;
@@ -288,4 +436,257 @@ export function hostTurnSettingsOf(v, depth = 'full') {
         return undefined;
     }
 }
-export const UNWIRED_HOST_TURN_SETTINGS = buildHostTurnSettings({ sources: {} }, (snapshot) => snapshot);
+function wireFormOf(v) {
+    const text = JSON.stringify(v);
+    return text === undefined ? undefined : JSON.parse(text);
+}
+function sameJson(a, b) {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null)
+        return false;
+    if (Array.isArray(a) !== Array.isArray(b))
+        return false;
+    if (Array.isArray(a) && Array.isArray(b))
+        return a.length === b.length && a.every((x, i) => sameJson(x, b[i]));
+    const ra = a;
+    const rb = b;
+    const ka = Object.keys(ra);
+    if (ka.length !== Object.keys(rb).length)
+        return false;
+    return ka.every((k) => Object.hasOwn(rb, k) && sameJson(ra[k], rb[k]));
+}
+function groupHead(g) {
+    if (!isRecordShape(g))
+        return undefined;
+    const head = {};
+    for (const k of Object.keys(g))
+        if (k !== 'hooks')
+            head[k] = g[k];
+    return head;
+}
+export function intersectHostHooks(sent, now) {
+    try {
+        return intersectHostHooksUnguarded(sent, now);
+    }
+    catch {
+        return { hooks: undefined, dropped: 0, judged: false };
+    }
+}
+function intersectHostHooksUnguarded(sentIn, nowIn) {
+    const sent = wireFormOf(sentIn);
+    const now = nowIn === undefined ? undefined : wireFormOf(nowIn);
+    const entriesOf = (cfg) => {
+        if (!isRecordShape(cfg))
+            return 0;
+        let n = 0;
+        for (const ev of Object.keys(cfg)) {
+            const groups = cfg[ev];
+            if (!Array.isArray(groups))
+                continue;
+            for (const g of groups)
+                if (isRecordShape(g) && Array.isArray(g.hooks))
+                    n += g.hooks.length;
+        }
+        return n;
+    };
+    const total = entriesOf(sent);
+    if (!isRecordShape(sent))
+        return { hooks: undefined, dropped: 0, judged: true };
+    if (!isRecordShape(now))
+        return { hooks: undefined, dropped: total, judged: true };
+    const out = {};
+    let kept = 0;
+    for (const ev of Object.keys(sent)) {
+        const groups = sent[ev];
+        const nowGroups = now[ev];
+        if (!Array.isArray(groups) || !Array.isArray(nowGroups))
+            continue;
+        const pool = nowGroups.map((g) => ({ head: groupHead(g), left: isRecordShape(g) && Array.isArray(g.hooks) ? [...g.hooks] : [] }));
+        const evOut = [];
+        for (const g of groups) {
+            const head = groupHead(g);
+            if (head === undefined || !isRecordShape(g) || !Array.isArray(g.hooks))
+                continue;
+            const keep = [];
+            for (const entry of g.hooks) {
+                for (const slot of pool) {
+                    if (slot.head === undefined || !sameJson(slot.head, head))
+                        continue;
+                    const at = slot.left.findIndex((x) => sameJson(x, entry));
+                    if (at < 0)
+                        continue;
+                    slot.left.splice(at, 1);
+                    keep.push(entry);
+                    break;
+                }
+            }
+            if (keep.length > 0)
+                evOut.push({ ...head, hooks: keep });
+            kept += keep.length;
+        }
+        if (evOut.length > 0)
+            out[ev] = evOut;
+    }
+    const hooks = Object.keys(out).length > 0 ? out : undefined;
+    return { hooks, dropped: total - kept, judged: hooks === undefined || hooksPassJudge(hooks) };
+}
+function ownDataOf(o, k) {
+    try {
+        if (typeof o !== 'object' || o === null)
+            return { ok: false };
+        const d = Object.getOwnPropertyDescriptor(o, k);
+        if (d === undefined)
+            return { ok: true, value: undefined };
+        if (!('value' in d))
+            return { ok: false };
+        return { ok: true, value: d.value };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+function noticeCopyOf(n) {
+    const id = ownDataOf(n, 'id');
+    const plane = ownDataOf(n, 'plane');
+    const text = ownDataOf(n, 'text');
+    if (!id.ok || !plane.ok || !text.ok || typeof id.value !== 'string' || typeof plane.value !== 'string' || typeof text.value !== 'string')
+        return undefined;
+    return freeze({ id: id.value, plane: plane.value, text: text.value });
+}
+function turnNoticesOf(product) {
+    try {
+        return turnNoticesUnguarded(product);
+    }
+    catch {
+        return undefined;
+    }
+}
+function turnNoticesUnguarded(product) {
+    const ns = ownDataOf(product, 'notices');
+    if (!ns.ok || !Array.isArray(ns.value))
+        return undefined;
+    const len = ownDataOf(ns.value, 'length');
+    if (!len.ok || typeof len.value !== 'number')
+        return undefined;
+    const out = [];
+    for (let i = 0; i < len.value; i++) {
+        const e = ownDataOf(ns.value, String(i));
+        const copy = e.ok ? noticeCopyOf(e.value) : undefined;
+        if (copy === undefined)
+            return undefined;
+        if (copy.plane === 'turn')
+            out.push(copy);
+    }
+    return freeze(out);
+}
+function deepFreeze(v) {
+    if (typeof v === 'object' && v !== null) {
+        for (const x of Object.values(v))
+            deepFreeze(x);
+        Object.freeze(v);
+    }
+    return v;
+}
+export function hostIntakeSnapshotOf(product, onResolved) {
+    try {
+        return intakeSnapshotUnguarded(product, onResolved);
+    }
+    catch {
+        return undefined;
+    }
+}
+function intakeSnapshotUnguarded(product, onResolved) {
+    if (product === UNWIRED_HOST_TURN_SETTINGS) {
+        return freeze({
+            carried: freeze({}),
+            refuses: false,
+            dispositions: freeze(Object.fromEntries(HOST_SUPPLIED_KEYS.map((k) => [k, 'unwired']))),
+            refusingKeys: freeze([]),
+            turnNotices: freeze([]),
+            notice: undefined,
+        });
+    }
+    const c = ownDataOf(product, 'carried');
+    if (!c.ok || !isRecordShape(c.value))
+        return undefined;
+    const carriedIn = c.value;
+    const subs = HOST_SUPPLIED_KEYS.map(carriedKeyOf);
+    let keys;
+    try {
+        keys = Reflect.ownKeys(carriedIn);
+    }
+    catch {
+        return undefined;
+    }
+    if (keys.some((k) => typeof k !== 'string' || !subs.includes(k)))
+        return undefined;
+    const values = {};
+    const resolvedR = ownDataOf(carriedIn, 'resolved');
+    if (!resolvedR.ok)
+        return undefined;
+    onResolved?.(resolvedR.value);
+    if (resolvedR.value !== undefined)
+        values.resolved = resolvedR.value;
+    for (const sub of subs.filter((x) => x !== 'resolved')) {
+        const r = ownDataOf(carriedIn, sub);
+        if (!r.ok)
+            return undefined;
+        const copy = deepFreeze(wireFormOf(r.value));
+        if (copy !== undefined)
+            values[sub] = copy;
+    }
+    const rowsR = ownDataOf(product, 'rows');
+    if (!rowsR.ok || !Array.isArray(rowsR.value) || rowsR.value.length !== HOST_SUPPLIED_KEYS.length)
+        return undefined;
+    let refuses = false;
+    const refusingKeys = [];
+    const dispositions = {};
+    for (const [i, key] of HOST_SUPPLIED_KEYS.entries()) {
+        const rowR = ownDataOf(rowsR.value, String(i));
+        if (!rowR.ok)
+            return undefined;
+        const k = ownDataOf(rowR.value, 'key');
+        const d = ownDataOf(rowR.value, 'disposition');
+        if (!k.ok || !d.ok || k.value !== key || !HOST_SETTING_DISPOSITIONS.includes(d.value))
+            return undefined;
+        if (d.value === 'refuse_turn') {
+            refuses = true;
+            refusingKeys.push(key);
+        }
+        dispositions[key] = d.value;
+        if ((values[carriedKeyOf(key)] !== undefined) !== CARRYING.has(d.value))
+            return undefined;
+    }
+    if (values.memory !== undefined && values.memory !== 'off')
+        return undefined;
+    if (values.fileHistory !== undefined && values.fileHistory !== 'disabled')
+        return undefined;
+    if (values.hooks !== undefined && !hooksPassJudge(values.hooks))
+        return undefined;
+    const v = ownDataOf(product, 'verdict');
+    if (!v.ok)
+        return undefined;
+    const kind = ownDataOf(v.value, 'kind');
+    if (!kind.ok || kind.value !== (refuses ? 'refuse' : 'send'))
+        return undefined;
+    const noticeR = refuses ? ownDataOf(v.value, 'notice') : undefined;
+    const notice = noticeR === undefined ? undefined : ((noticeR.ok ? noticeCopyOf(noticeR.value) : undefined) ?? hostProjectionNotice());
+    return freeze({
+        carried: freeze(values),
+        refuses,
+        dispositions: freeze(dispositions),
+        refusingKeys: freeze(refusingKeys),
+        turnNotices: turnNoticesOf(product),
+        notice,
+    });
+}
+export const UNWIRED_HOST_TURN_SETTINGS = buildHostTurnSettings({ sources: {} }, {
+    materialize: (snapshot) => snapshot,
+    memoryOffDeclared: () => false,
+});
+function carriedKeyOf(k) {
+    return k.startsWith('settings.') ? k.slice('settings.'.length) : k;
+}
+const _armsPin = [true, true, true, true];
+void _armsPin;

package/dist/humanTurn.d.ts

@@ -3,6 +3,7 @@ import type { ImageInput } from './imagesWireCaps.js';
 import type { ImageVision } from './liveModelCatalog.js';
 import { type UserAttachmentDescriptor } from './userAttachmentEnvelope.js';
 import type { UserAttachmentSeatReading } from './userAttachmentSeat.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 export interface HumanTurnRider {
     readonly uuid: string;
     readonly role: 'image_meta' | 'attachment' | 'skill_body' | (string & {});
@@ -98,7 +99,7 @@ export interface HumanTurnDelivered {
     readonly full: readonly string[];
     readonly partial: readonly string[];
 }
-export declare function imageSentOnUnknownVision(notices: readonly HumanTurnNotice[] | undefined): string | undefined;
+export declare function imageSentOnUnknownVision(notices: readonly HumanTurnNotice[] | undefined, lang?: UiLanguage): string | undefined;
 export declare function encodeHumanTurn(input: HumanTurnInput): HumanTurnEncoding;
 export declare function deliveredUuidsOf(encoding: HumanTurnEncoding): HumanTurnDelivered;
 export {};

package/dist/humanTurn.js

@@ -1,6 +1,7 @@
 import { CORE_MAX_PENDING_STEER_CHARS, CORE_MCP_IMAGE_MAX_BASE64, CORE_USER_ATTACHMENT_LABEL_MAX } from './generated/engineFactTables.js';
 import { mintEnvelopeOf, mintReferenceOf, seatTextOf } from './userAttachmentEnvelope.js';
 import { readEncodingShares, readHumanTurnInput } from './humanTurnRead.js';
+import { msg, renderMessage } from './i18n/translate.js';
 const REQUEST_BODY_MAX_BYTES = 8 * 1024 * 1024;
 const IMAGE_SEAT_MAX_COUNT = 20;
 const IMAGE_SEAT_MAX_BASE64_CHARS_TOTAL = 6 * 1024 * 1024;
@@ -172,7 +173,7 @@ function noticesKey(v, items, placements) {
     }
     return notices.length > 0 ? { notices } : {};
 }
-export function imageSentOnUnknownVision(notices) {
+export function imageSentOnUnknownVision(notices, lang) {
     let n = 0;
     try {
         if (!Array.isArray(notices))
@@ -186,8 +187,7 @@ export function imageSentOnUnknownVision(notices) {
     }
     if (n === 0)
         return undefined;
-    const what = n === 1 ? 'An @-mentioned image was' : `${n} @-mentioned images were`;
-    return `${what} sent with this message, although the engine's model list does not say whether the model this message uses accepts image input — if it does not, the images may be dropped or the message may be refused`;
+    return renderMessage(n === 1 ? msg('session.humanTurn.imageUnknownVision.one') : msg('session.humanTurn.imageUnknownVision.other', { count: n }), lang);
 }
 function encodeObjective(v) {
     const { items } = v;