@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/httpHookPolicy.d.ts

@@ -0,0 +1,37 @@
+import type { WireHooksConfig } from './finalVerifyWire.js';
+import type { WorkspaceTrustState } from './hostSettingsSource.js';
+import type { HookSettingsSource } from './pluginHooksWire.js';
+export declare const HTTP_POLICY_DROP_REASONS: readonly ["url_not_listed", "url_list_empty", "url_list_malformed", "env_list_malformed", "layer_unreadable"];
+export type HttpPolicyDropReason = (typeof HTTP_POLICY_DROP_REASONS)[number];
+export interface HttpPolicyDropRow {
+    readonly event: string;
+    readonly reason: HttpPolicyDropReason;
+    readonly layer: HookSettingsSource;
+    readonly urlShown: string;
+    readonly notice: string;
+}
+export type HttpHookListReading = {
+    readonly kind: 'absent';
+} | {
+    readonly kind: 'list';
+    readonly patterns: readonly string[];
+} | {
+    readonly kind: 'malformed';
+} | {
+    readonly kind: 'unreadable';
+};
+export interface HttpHookLayerReading {
+    readonly layer: HookSettingsSource;
+    readonly urls: HttpHookListReading;
+    readonly envs: HttpHookListReading;
+}
+export interface HttpHookPolicyReading {
+    readonly layers: readonly HttpHookLayerReading[];
+}
+export declare function httpHookAdmittedSources(sources: readonly HookSettingsSource[], trust: WorkspaceTrustState | 'unreadable'): readonly HookSettingsSource[];
+export declare function readHttpHookPolicy(admitted: readonly HookSettingsSource[], docOf: (layer: HookSettingsSource) => object | null | undefined): HttpHookPolicyReading;
+export declare function wireHasHttpEntry(wire: WireHooksConfig): boolean;
+export declare function applyHttpHookPolicy(wire: WireHooksConfig, policy: HttpHookPolicyReading): {
+    readonly wire: WireHooksConfig | undefined;
+    readonly rows: readonly HttpPolicyDropRow[];
+};

package/dist/httpHookPolicy.js

@@ -0,0 +1,176 @@
+import { appendOwnElement } from './ownKey.js';
+import { displayUntrusted } from './displayUntrusted.js';
+import { SETTINGS_URL_ALLOW_PATTERN_MATCHES } from './generated/settingsSchemaFns.js';
+import { admittedLayers } from './settingsLayerAdmission.js';
+import { hostLog } from './host.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { HOOK_SETTINGS_SOURCE_TEXT } from './settingsHooksSalvage.js';
+export const HTTP_POLICY_DROP_REASONS = Object.freeze(['url_not_listed', 'url_list_empty', 'url_list_malformed', 'env_list_malformed', 'layer_unreadable']);
+const ABSENT = Object.freeze({ kind: 'absent' });
+const MALFORMED = Object.freeze({ kind: 'malformed' });
+const UNREADABLE = Object.freeze({ kind: 'unreadable' });
+const HTTP_HOOK_ALLOWLISTS_CATEGORY = 'httpHookAllowlists';
+export function httpHookAdmittedSources(sources, trust) {
+    return admittedLayers(sources, trust, HTTP_HOOK_ALLOWLISTS_CATEGORY);
+}
+function readList(doc, key) {
+    try {
+        if (typeof doc !== 'object' || doc === null)
+            return ABSENT;
+        const d = Object.getOwnPropertyDescriptor(doc, key);
+        if (d === undefined)
+            return ABSENT;
+        if (!Object.hasOwn(d, 'value'))
+            return MALFORMED;
+        const v = d.value;
+        if (v === undefined)
+            return ABSENT;
+        if (!Array.isArray(v))
+            return MALFORMED;
+        const patterns = [];
+        for (let i = 0; i < v.length; i++) {
+            const ed = Object.getOwnPropertyDescriptor(v, i);
+            if (ed === undefined || !Object.hasOwn(ed, 'value') || typeof ed.value !== 'string')
+                return MALFORMED;
+            appendOwnElement(patterns, ed.value);
+        }
+        return { kind: 'list', patterns };
+    }
+    catch {
+        return MALFORMED;
+    }
+}
+export function readHttpHookPolicy(admitted, docOf) {
+    const layers = [];
+    for (const layer of admitted) {
+        let doc;
+        try {
+            doc = docOf(layer);
+        }
+        catch {
+            hostLog('debug', `http-hook-list-layer-read-threw: ${layer}`);
+            layers.push(Object.freeze({ layer, urls: UNREADABLE, envs: UNREADABLE }));
+            continue;
+        }
+        const urls = readList(doc, 'allowedHttpHookUrls');
+        const envs = readList(doc, 'httpHookAllowedEnvVars');
+        if (urls.kind === 'absent' && envs.kind === 'absent')
+            continue;
+        layers.push(Object.freeze({ layer, urls, envs }));
+    }
+    return Object.freeze({ layers: Object.freeze(layers) });
+}
+function httpHookPolicyIsUnrestricted(p) {
+    return p.layers.length === 0;
+}
+export function wireHasHttpEntry(wire) {
+    for (const groups of Object.values(wire)) {
+        if (!Array.isArray(groups))
+            continue;
+        for (const g of groups) {
+            if (typeof g !== 'object' || g === null || !Array.isArray(g.hooks))
+                continue;
+            for (const h of g.hooks)
+                if (h?.type === 'http')
+                    return true;
+        }
+    }
+    return false;
+}
+function patternAdmits(url, pattern) {
+    try {
+        return SETTINGS_URL_ALLOW_PATTERN_MATCHES(url, pattern);
+    }
+    catch {
+        return false;
+    }
+}
+function urlListed(url, patterns) {
+    return patterns.some((p) => patternAdmits(url, p));
+}
+const DROP_KEY = {
+    url_not_listed: 'config.hooks.httpPolicy.urlNotListed',
+    url_list_empty: 'config.hooks.httpPolicy.urlListEmpty',
+    url_list_malformed: 'config.hooks.httpPolicy.urlListMalformed',
+    env_list_malformed: 'config.hooks.httpPolicy.envListMalformed',
+    layer_unreadable: 'config.hooks.httpPolicy.layerUnreadable',
+};
+const URL_SHOWN_MAX = 200;
+const EVENT_SHOWN_MAX = 80;
+function rowOf(event, reason, layer, url) {
+    const urlShown = typeof url === 'string' && url !== '' ? displayUntrusted(url, { max: URL_SHOWN_MAX }) : '(no URL)';
+    const eventShown = displayUntrusted(event, { max: EVENT_SHOWN_MAX });
+    const layerShown = HOOK_SETTINGS_SOURCE_TEXT[layer] ?? 'Settings';
+    return Object.freeze({ event, reason, layer, urlShown, notice: renderMessage(msg(DROP_KEY[reason], { url: urlShown, event: eventShown, layer: layerShown })) });
+}
+function judgeEntry(entry, event, policy) {
+    const e = entry;
+    for (const l of policy.layers) {
+        const urls = l.urls;
+        if (urls.kind === 'absent')
+            continue;
+        if (urls.kind === 'unreadable')
+            return { keep: undefined, rows: [rowOf(event, 'layer_unreadable', l.layer, e.url)] };
+        if (urls.kind === 'malformed')
+            return { keep: undefined, rows: [rowOf(event, 'url_list_malformed', l.layer, e.url)] };
+        if (urls.patterns.length === 0)
+            return { keep: undefined, rows: [rowOf(event, 'url_list_empty', l.layer, e.url)] };
+        if (typeof e.url !== 'string' || !urlListed(e.url, urls.patterns))
+            return { keep: undefined, rows: [rowOf(event, 'url_not_listed', l.layer, e.url)] };
+    }
+    const envLayers = policy.layers.filter((l) => l.envs.kind !== 'absent');
+    if (envLayers.length === 0 || !Array.isArray(e.allowedEnvVars))
+        return { keep: entry, rows: [] };
+    const own = e.allowedEnvVars;
+    const lists = envLayers.map((l) => (l.envs.kind === 'list' ? l.envs.patterns : []));
+    const narrowed = own.filter((v) => typeof v === 'string' && lists.every((list) => list.includes(v)));
+    if (narrowed.length === own.length)
+        return { keep: entry, rows: [] };
+    const bad = envLayers.find((l) => l.envs.kind === 'malformed');
+    return { keep: { ...entry, allowedEnvVars: narrowed }, rows: bad !== undefined && own.length > 0 ? [rowOf(event, 'env_list_malformed', bad.layer, e.url)] : [] };
+}
+export function applyHttpHookPolicy(wire, policy) {
+    if (httpHookPolicyIsUnrestricted(policy))
+        return { wire, rows: [] };
+    const rows = [];
+    let changed = false;
+    const out = {};
+    for (const [event, groups] of Object.entries(wire)) {
+        if (!Array.isArray(groups)) {
+            out[event] = groups;
+            continue;
+        }
+        const keptGroups = [];
+        for (const g of groups) {
+            if (typeof g !== 'object' || g === null || !Array.isArray(g.hooks) || g.hooks.length === 0) {
+                keptGroups.push(g);
+                continue;
+            }
+            const hooks = [];
+            for (const h of g.hooks) {
+                if (h?.type !== 'http') {
+                    hooks.push(h);
+                    continue;
+                }
+                const j = judgeEntry(h, event, policy);
+                rows.push(...j.rows);
+                if (j.keep !== undefined)
+                    hooks.push(j.keep);
+            }
+            const same = hooks.length === g.hooks.length && hooks.every((h, i) => h === g.hooks[i]);
+            if (!same)
+                changed = true;
+            if (hooks.length > 0)
+                keptGroups.push(same ? g : { ...g, hooks });
+        }
+        if (keptGroups.length > 0)
+            out[event] = keptGroups;
+        else if (groups.length === 0)
+            out[event] = groups;
+        else
+            changed = true;
+    }
+    if (!changed)
+        return { wire, rows };
+    return { wire: Object.keys(out).length > 0 ? out : undefined, rows };
+}

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 & {});
@@ -66,7 +67,7 @@ export interface HumanTurnDegraded {
 export interface HumanTurnNotice {
     readonly uuid: string;
     readonly kind: 'image';
-    readonly ref: string;
+    readonly ref: string | number;
     readonly why: 'vision_unknown';
 }
 export type HumanTurnEncoding = {
@@ -98,7 +99,8 @@ export interface HumanTurnDelivered {
     readonly full: readonly string[];
     readonly partial: readonly string[];
 }
-export declare function imageSentOnUnknownVision(notices: readonly HumanTurnNotice[] | undefined): string | undefined;
+export declare function otherBodyBytesOf(request: object | null | undefined): number | 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,8 @@
 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 { putOwnKey } from './ownKey.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;
@@ -29,6 +31,29 @@ function utf8Length(s) {
     return n;
 }
 const jsonBytes = (v) => utf8Length(JSON.stringify(v));
+const ENCODER_BODY_KEYS = new Set(['objective', 'images', 'attachmentIds', 'userAttachments']);
+export function otherBodyBytesOf(request) {
+    if (typeof request !== 'object' || request === null)
+        return undefined;
+    try {
+        if (Array.isArray(request))
+            return undefined;
+        const rest = {};
+        for (const k of Object.keys(request)) {
+            if (ENCODER_BODY_KEYS.has(k))
+                continue;
+            const d = Object.getOwnPropertyDescriptor(request, k);
+            if (d === undefined || !Object.hasOwn(d, 'value'))
+                return undefined;
+            putOwnKey(rest, k, d.value);
+        }
+        const json = JSON.stringify(rest);
+        return json === undefined ? undefined : utf8Length(json);
+    }
+    catch {
+        return undefined;
+    }
+}
 function bodyBytes(other, objective, images, ids, entries) {
     const keys = [jsonBytes('objective') + 1 + jsonBytes(objective)];
     if (images.length > 0)
@@ -162,17 +187,23 @@ function sharesAndDegraded(items, recs) {
     }
     return { shares, degraded };
 }
-function noticesKey(v, items, placements) {
+function noticesKey(v, items, placements, pastedWhy) {
     if (v.vision !== 'unknown')
         return {};
     const notices = [];
-    for (const p of placements) {
-        if (p.form === 'content' && p.seated && p.a.pixels !== undefined)
-            notices.push({ uuid: items[p.item].uuid, kind: 'image', ref: p.a.uuid, why: 'vision_unknown' });
-    }
+    items.forEach((it, i) => {
+        it.images.forEach((_, k) => {
+            if (pastedWhy[i]?.[k] === undefined)
+                notices.push({ uuid: it.uuid, kind: 'image', ref: k, why: 'vision_unknown' });
+        });
+        for (const p of placements) {
+            if (p.item === i && p.form === 'content' && p.seated && p.a.pixels !== undefined)
+                notices.push({ uuid: it.uuid, kind: 'image', ref: p.a.uuid, why: 'vision_unknown' });
+        }
+    });
     return notices.length > 0 ? { notices } : {};
 }
-export function imageSentOnUnknownVision(notices) {
+export function imageSentOnUnknownVision(notices, lang) {
     let n = 0;
     try {
         if (!Array.isArray(notices))
@@ -186,8 +217,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;
@@ -204,7 +234,7 @@ function encodeObjective(v) {
         total += len;
         return undefined;
     };
-    const pastedWhy = items.map((it) => it.images.map((img) => seat('data' in img ? img.data.length : 0)));
+    const pastedWhy = items.map((it) => it.images.map((img) => (v.vision === 'no' ? 'vision_no' : seat('data' in img ? img.data.length : 0))));
     const placements = [];
     items.forEach((it, i) => {
         for (const a of it.attachments) {
@@ -260,7 +290,7 @@ function encodeObjective(v) {
                 ...(entries.length > 0 ? { userAttachments: entries, userAttachmentOrdinals: seated.map((p) => p.a.uuid) } : {}),
                 shares,
                 degraded,
-                ...noticesKey(v, items, placements),
+                ...noticesKey(v, items, placements, pastedWhy),
             };
         }
         let pick = -1;

package/dist/humanTurnRead.js

@@ -1,3 +1,4 @@
+import { appendOwnElement } from './ownKey.js';
 import { userAttachmentSeatAdmits } from './userAttachmentSeat.js';
 const descriptorKindsAligned = true;
 void descriptorKindsAligned;
@@ -15,7 +16,7 @@ function ownData(o, key) {
     const d = Object.getOwnPropertyDescriptor(o, key);
     if (d === undefined)
         return undefined;
-    if (!('value' in d))
+    if (!Object.hasOwn(d, 'value'))
         bad();
     return d.value;
 }
@@ -29,9 +30,9 @@ function ownArray(x) {
     const out = [];
     for (let i = 0; i < n; i += 1) {
         const d = Object.getOwnPropertyDescriptor(arr, i);
-        if (d === undefined || !('value' in d))
+        if (d === undefined || !Object.hasOwn(d, 'value'))
             bad();
-        out.push(d.value);
+        appendOwnElement(out, d.value);
     }
     return out;
 }

package/dist/humanTurnSentences.d.ts

@@ -0,0 +1,10 @@
+import type { HumanTurnDegraded, HumanTurnEncoding } from './humanTurn.js';
+import type { UiLanguage } from './env/uiLanguage.js';
+import type { ImageVision } from './liveModelCatalog.js';
+export declare function humanTurnRefusalSentence(answer: HumanTurnEncoding | null | undefined, lang?: UiLanguage): string | undefined;
+export declare function humanTurnDegradedSentence(degraded: readonly HumanTurnDegraded[] | null | undefined, lang?: UiLanguage, ctx?: {
+    readonly modelName?: string;
+}): string | undefined;
+export declare function printImageVisionSentence(vision: ImageVision | undefined, lang?: UiLanguage, ctx?: {
+    readonly modelName?: string;
+}): string | undefined;

package/dist/humanTurnSentences.js

@@ -0,0 +1,74 @@
+import { msg, renderMessage } from './i18n/translate.js';
+import { guardedRead, readOwnDataValue } from './ownKey.js';
+const own = (o, key) => guardedRead(() => readOwnDataValue(o, key));
+const REFUSAL_KEYS = {
+    empty: 'session.humanTurn.refused.empty',
+    malformed_input: 'session.humanTurn.refused.malformedInput',
+    malformed_item: 'session.humanTurn.refused.malformedItem',
+    duplicate_uuid: 'session.humanTurn.refused.duplicateUuid',
+    rider_collides_primary: 'session.humanTurn.refused.riderCollidesPrimary',
+    oversize: 'session.humanTurn.refused.oversize',
+};
+const HOLD_KEYS = {
+    no_text: 'session.humanTurn.held.noText',
+    reminder_tag: 'session.humanTurn.held.reminderTag',
+    control_char: 'session.humanTurn.held.controlChar',
+    too_long: 'session.humanTurn.held.tooLong',
+};
+export function humanTurnRefusalSentence(answer, lang) {
+    if (own(answer, 'ok') !== false)
+        return undefined;
+    const reason = own(answer, 'reason');
+    if (typeof reason !== 'string')
+        return undefined;
+    if (reason === 'steer_hold') {
+        const why = own(answer, 'why');
+        return typeof why === 'string' && Object.hasOwn(HOLD_KEYS, why) ? renderMessage(msg(HOLD_KEYS[why]), lang) : undefined;
+    }
+    return Object.hasOwn(REFUSAL_KEYS, reason) ? renderMessage(msg(REFUSAL_KEYS[reason]), lang) : undefined;
+}
+const DEGRADED_KEYS = {
+    vision_no: ['session.humanTurn.degraded.visionNo.one', 'session.humanTurn.degraded.visionNo.other'],
+    image_too_large: ['session.humanTurn.degraded.imageTooLarge.one', 'session.humanTurn.degraded.imageTooLarge.other'],
+    seat_count: ['session.humanTurn.degraded.seatCount.one', 'session.humanTurn.degraded.seatCount.other'],
+    seat_total: ['session.humanTurn.degraded.seatTotal.one', 'session.humanTurn.degraded.seatTotal.other'],
+    body_budget: ['session.humanTurn.degraded.bodyBudget.one', 'session.humanTurn.degraded.bodyBudget.other'],
+    steer_admission: ['session.humanTurn.degraded.steerAdmission.one', 'session.humanTurn.degraded.steerAdmission.other'],
+    lane_has_no_image_seat: ['session.humanTurn.degraded.noImageSeat.one', 'session.humanTurn.degraded.noImageSeat.other'],
+    lane_has_no_attachment_id_seat: ['session.humanTurn.degraded.noAttachmentIdSeat.one', 'session.humanTurn.degraded.noAttachmentIdSeat.other'],
+};
+function modelFragment(modelName, lang) {
+    return typeof modelName === 'string' && modelName.length > 0 ? renderMessage(msg('session.humanTurn.modelFragment', { model: modelName }), lang) : '';
+}
+export function humanTurnDegradedSentence(degraded, lang, ctx) {
+    const counts = new Map();
+    try {
+        if (!Array.isArray(degraded))
+            return undefined;
+        for (const d of degraded) {
+            const why = own(d, 'why');
+            if (typeof why !== 'string' || !Object.hasOwn(DEGRADED_KEYS, why))
+                continue;
+            const k = why;
+            counts.set(k, (counts.get(k) ?? 0) + 1);
+        }
+    }
+    catch {
+        return undefined;
+    }
+    if (counts.size === 0)
+        return undefined;
+    const modelName = ctx === undefined ? undefined : own(ctx, 'modelName');
+    const lines = [];
+    for (const [why, n] of counts) {
+        const [one, other] = DEGRADED_KEYS[why];
+        lines.push(renderMessage(msg(n === 1 ? one : other, { count: n, model: modelFragment(modelName, lang) }), lang));
+    }
+    return lines.join('\n');
+}
+export function printImageVisionSentence(vision, lang, ctx) {
+    if (vision !== 'no' && vision !== 'unknown')
+        return undefined;
+    const model = modelFragment(ctx === undefined ? undefined : own(ctx, 'modelName'), lang);
+    return renderMessage(msg(vision === 'no' ? 'session.humanTurn.printVision.no' : 'session.humanTurn.printVision.unknown', { model }), lang);
+}