@sema-agent/client-core 0.97.1 → 0.98.0

package/dist/engineSessionMessages.js

@@ -0,0 +1,364 @@
+import { ownDataField, ownSendableField } from './ownKey.js';
+const isObjectLike = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+function optionalOwn(o, key) {
+    try {
+        return ownDataField(o, key);
+    }
+    catch {
+        return undefined;
+    }
+}
+function itemsOf(a) {
+    if (!Array.isArray(a))
+        return undefined;
+    const n = ownDataField(a, 'length');
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+        return undefined;
+    const out = [];
+    for (let i = 0; i < n; i += 1)
+        out.push(ownDataField(a, String(i)));
+    return out;
+}
+const JSON_MAX_DEPTH = 64;
+const JSON_MAX_NODES = 200_000;
+const NOT_JSON = Symbol('not-json');
+function isPlainShape(o) {
+    const proto = Object.getPrototypeOf(o);
+    return proto === null || (typeof proto === 'object' && Object.getPrototypeOf(proto) === null);
+}
+function jsonSnapshot(v, depth, budget) {
+    budget.nodes += 1;
+    if (budget.nodes > JSON_MAX_NODES || depth > JSON_MAX_DEPTH)
+        return NOT_JSON;
+    if (v === null || typeof v === 'string' || typeof v === 'boolean')
+        return v;
+    if (typeof v === 'number')
+        return Number.isFinite(v) ? v : NOT_JSON;
+    if (typeof v !== 'object')
+        return NOT_JSON;
+    if (Array.isArray(v)) {
+        const n = ownDataField(v, 'length');
+        if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+            return NOT_JSON;
+        const out = [];
+        for (let i = 0; i < n; i += 1) {
+            const item = jsonSnapshot(ownSendableField(v, String(i)), depth + 1, budget);
+            if (item === NOT_JSON)
+                return NOT_JSON;
+            out.push(item);
+        }
+        return out;
+    }
+    if (!isPlainShape(v))
+        return NOT_JSON;
+    const out = {};
+    for (const k of Reflect.ownKeys(v)) {
+        if (typeof k !== 'string')
+            continue;
+        const item = jsonSnapshot(ownSendableField(v, k), depth + 1, budget);
+        if (item === NOT_JSON)
+            return NOT_JSON;
+        Object.defineProperty(out, k, { value: item, enumerable: true, writable: true, configurable: true });
+    }
+    return out;
+}
+function jsonSnapshotOf(v) {
+    try {
+        const snap = jsonSnapshot(v, 0, { nodes: 0 });
+        return snap === NOT_JSON ? undefined : snap;
+    }
+    catch {
+        return undefined;
+    }
+}
+function mapBlock(b) {
+    if (!isObjectLike(b))
+        return undefined;
+    const type = ownDataField(b, 'type');
+    if (typeof type !== 'string')
+        return undefined;
+    switch (type) {
+        case 'text': {
+            const text = ownDataField(b, 'text');
+            return typeof text === 'string' ? { type: 'text', text } : undefined;
+        }
+        case 'thinking': {
+            const thinking = ownDataField(b, 'thinking');
+            if (typeof thinking !== 'string')
+                return undefined;
+            const signature = optionalOwn(b, 'thinkingSignature');
+            return typeof signature === 'string' ? { type: 'thinking', thinking, signature } : { type: 'thinking', thinking };
+        }
+        case 'toolCall': {
+            const id = ownDataField(b, 'id');
+            const name = ownDataField(b, 'name');
+            if (typeof id !== 'string' || id.length === 0 || typeof name !== 'string' || name.length === 0)
+                return undefined;
+            const args = ownDataField(b, 'arguments');
+            if (!isObjectLike(args))
+                return { type: 'tool_use', id, name, input: {} };
+            const input = jsonSnapshotOf(args);
+            if (input === undefined || input === null || typeof input !== 'object' || Array.isArray(input))
+                return undefined;
+            return { type: 'tool_use', id, name, input: input };
+        }
+        case 'image':
+        case 'document': {
+            const data = ownDataField(b, 'data');
+            const mimeType = ownDataField(b, 'mimeType');
+            if (typeof data !== 'string' || typeof mimeType !== 'string' || mimeType.length === 0)
+                return undefined;
+            return { type, source: { type: 'base64', media_type: mimeType, data } };
+        }
+        default: {
+            const opaque = jsonSnapshotOf(b);
+            return opaque !== undefined && opaque !== null && typeof opaque === 'object' && !Array.isArray(opaque) ? opaque : undefined;
+        }
+    }
+}
+function mapBlockCounted(raw, tally) {
+    let mapped;
+    try {
+        mapped = mapBlock(raw);
+    }
+    catch {
+        mapped = undefined;
+    }
+    if (mapped === undefined)
+        tally.droppedBlocks += 1;
+    return mapped;
+}
+function mapBlocks(items, tally) {
+    const out = [];
+    for (const raw of items) {
+        const mapped = mapBlockCounted(raw, tally);
+        if (mapped !== undefined)
+            out.push(mapped);
+    }
+    return out;
+}
+function engineRegionsOf(row, flatLength) {
+    if (optionalOwn(row, 'engineMinted') === true)
+        return 'whole';
+    const segments = optionalOwn(row, 'engineSegments');
+    if (segments !== undefined) {
+        let items;
+        try {
+            items = itemsOf(segments);
+        }
+        catch {
+            items = undefined;
+        }
+        if (items === undefined)
+            return 'verbatim';
+        const out = [];
+        let floor = 0;
+        for (const item of items) {
+            if (!isObjectLike(item))
+                return 'verbatim';
+            const start = optionalOwn(item, 'start');
+            const end = optionalOwn(item, 'end');
+            if (typeof start !== 'number' || typeof end !== 'number' || !Number.isInteger(start) || !Number.isInteger(end))
+                return 'verbatim';
+            if (start < floor || end <= start || end > flatLength)
+                return 'verbatim';
+            out.push([start, end]);
+            floor = end;
+        }
+        return out;
+    }
+    const prefix = optionalOwn(row, 'enginePrefixChars');
+    if (prefix === undefined)
+        return 'verbatim';
+    if (typeof prefix !== 'number' || !Number.isInteger(prefix) || prefix <= 0 || prefix > flatLength)
+        return 'verbatim';
+    return [[0, prefix]];
+}
+function cutRegions(text, offset, regions) {
+    const end = offset + text.length;
+    let out = '';
+    let cursor = offset;
+    let touched = false;
+    for (const [rs, re] of regions) {
+        if (re <= offset || rs >= end)
+            continue;
+        touched = true;
+        const cutStart = Math.max(rs, offset);
+        const cutEnd = Math.min(re, end);
+        out += text.slice(cursor - offset, cutStart - offset);
+        cursor = cutEnd;
+    }
+    if (!touched)
+        return text;
+    out += text.slice(cursor - offset);
+    const kept = out.trim();
+    return kept === '' ? undefined : kept;
+}
+const unreadable = () => ({ kind: 'skip', why: 'unreadable' });
+const invisible = () => ({ kind: 'skip', why: 'noVisibleContent' });
+function flatTextOf(item) {
+    if (!isObjectLike(item))
+        return '';
+    const type = optionalOwn(item, 'type');
+    if (type !== 'text')
+        return '';
+    const text = optionalOwn(item, 'text');
+    return text === undefined || text === null ? '' : String(text);
+}
+function userBody(row, tally) {
+    const content = ownDataField(row, 'content');
+    if (typeof content === 'string') {
+        if (content === '')
+            return invisible();
+        const regions = engineRegionsOf(row, content.length);
+        if (regions === 'whole')
+            return invisible();
+        if (regions === 'verbatim')
+            return { kind: 'message', role: 'user', body: { role: 'user', content } };
+        const kept = cutRegions(content, 0, regions);
+        return kept === undefined ? invisible() : { kind: 'message', role: 'user', body: { role: 'user', content: kept } };
+    }
+    const items = itemsOf(content);
+    if (items === undefined)
+        return unreadable();
+    if (items.length === 0)
+        return invisible();
+    const texts = items.map(flatTextOf);
+    const flatLength = texts.reduce((n, t) => n + t.length, 0) + (items.length - 1);
+    const regions = engineRegionsOf(row, flatLength);
+    if (regions === 'whole')
+        return invisible();
+    const out = [];
+    let offset = 0;
+    for (let i = 0; i < items.length; i += 1) {
+        const text = texts[i];
+        const at = offset;
+        offset += text.length + 1;
+        const mapped = mapBlockCounted(items[i], tally);
+        if (mapped === undefined)
+            continue;
+        if (mapped.type === 'text' && regions !== 'verbatim') {
+            const kept = cutRegions(text, at, regions);
+            if (kept === undefined)
+                continue;
+            out.push(kept === text ? mapped : { type: 'text', text: kept });
+            continue;
+        }
+        out.push(mapped);
+    }
+    return out.length === 0 ? invisible() : { kind: 'message', role: 'user', body: { role: 'user', content: out } };
+}
+function assistantBody(row, tally) {
+    const content = ownDataField(row, 'content');
+    let blocks;
+    if (typeof content === 'string') {
+        blocks = [{ type: 'text', text: content }];
+    }
+    else {
+        const items = itemsOf(content);
+        if (items === undefined)
+            return unreadable();
+        blocks = mapBlocks(items, tally);
+    }
+    const model = optionalOwn(row, 'model');
+    return {
+        kind: 'message',
+        role: 'assistant',
+        body: typeof model === 'string' && model.length > 0 ? { role: 'assistant', content: blocks, model } : { role: 'assistant', content: blocks },
+    };
+}
+function toolResultBody(row, tally) {
+    const id = ownDataField(row, 'toolCallId');
+    if (typeof id !== 'string' || id.length === 0)
+        return unreadable();
+    const content = ownDataField(row, 'content');
+    let blocks;
+    if (content === undefined) {
+        blocks = [];
+    }
+    else if (typeof content === 'string') {
+        blocks = [{ type: 'text', text: content }];
+    }
+    else {
+        const items = itemsOf(content);
+        if (items === undefined)
+            return unreadable();
+        blocks = mapBlocks(items, tally);
+    }
+    const isError = ownDataField(row, 'isError') === true;
+    return { kind: 'message', role: 'user', body: { role: 'user', content: [{ type: 'tool_result', tool_use_id: id, content: blocks, is_error: isError }] } };
+}
+function projectRow(row, tally) {
+    if (!isObjectLike(row))
+        return unreadable();
+    const role = ownDataField(row, 'role');
+    if (role === 'user')
+        return userBody(row, tally);
+    if (role === 'assistant')
+        return assistantBody(row, tally);
+    if (role === 'toolResult')
+        return toolResultBody(row, tally);
+    return { kind: 'skip', why: 'unknownRole' };
+}
+function timestampOf(row) {
+    const ms = optionalOwn(row, 'timestamp');
+    if (typeof ms !== 'number' || !Number.isFinite(ms))
+        return undefined;
+    const at = new Date(ms);
+    return Number.isNaN(at.getTime()) ? undefined : at.toISOString();
+}
+function sessionIdOf(opts) {
+    let sessionId;
+    try {
+        sessionId = typeof opts === 'object' && opts !== null ? ownDataField(opts, 'sessionId') : undefined;
+    }
+    catch {
+        sessionId = undefined;
+    }
+    if (typeof sessionId !== 'string' || sessionId.length === 0) {
+        throw new TypeError('projectEngineSessionMessages: opts.sessionId must be a non-empty string (the engine session id)');
+    }
+    return sessionId;
+}
+export function projectEngineSessionMessages(rows, opts) {
+    if (!Array.isArray(rows))
+        throw new TypeError('projectEngineSessionMessages: rows must be an array');
+    const sessionId = sessionIdOf(opts);
+    let count;
+    try {
+        count = ownDataField(rows, 'length');
+    }
+    catch {
+        count = undefined;
+    }
+    if (typeof count !== 'number' || !Number.isSafeInteger(count) || count < 0)
+        throw new TypeError('projectEngineSessionMessages: rows length could not be read');
+    const tally = { unreadable: 0, unknownRole: 0, noVisibleContent: 0, droppedBlocks: 0 };
+    const messages = [];
+    for (let i = 0; i < count; i += 1) {
+        let outcome;
+        let timestamp;
+        try {
+            const row = ownDataField(rows, String(i));
+            outcome = projectRow(row, tally);
+            timestamp = outcome.kind === 'message' && isObjectLike(row) ? timestampOf(row) : undefined;
+        }
+        catch {
+            outcome = unreadable();
+            timestamp = undefined;
+        }
+        if (outcome.kind === 'skip') {
+            tally[outcome.why] += 1;
+            continue;
+        }
+        messages.push({
+            type: outcome.role,
+            uuid: `restored-${sessionId}-${messages.length + 1}`,
+            session_id: sessionId,
+            ...(timestamp !== undefined ? { timestamp } : {}),
+            message: outcome.body,
+            parent_tool_use_id: null,
+        });
+    }
+    return Object.freeze({ messages, skipped: Object.freeze({ ...tally }) });
+}

package/dist/engineToolDirectory.d.ts

@@ -15,13 +15,4 @@ export type EngineToolDirectory = {
     readonly mcpServerPrefixes: ReadonlySet<string>;
 };
 export declare function engineToolDirectoryOf(source: EngineToolDirectorySource | null | undefined): EngineToolDirectory;
-export type McpEntryReading = 'outside' | 'unchecked' | 'unparsable' | 'answers' | 'unanswered';
-export declare function mcpEntryReadingOf(toolName: string, directory: EngineToolDirectory | undefined): McpEntryReading;
 export declare function deniedEntryToolName(entry: string): string | undefined;
-export interface ExcludeToolsAgainstDirectory {
-    readonly send: string[];
-    readonly omitted: string[];
-    readonly verdict: 'directory_absent' | 'filtered';
-    readonly disclosure?: string;
-}
-export declare function excludeToolsAgainstDirectory(exclude: readonly string[], directory: EngineToolDirectory | undefined): ExcludeToolsAgainstDirectory;

package/dist/engineToolDirectory.js

@@ -1,7 +1,6 @@
 import { frozenSet } from './frozenSet.js';
 import { ownDataField } from './ownKey.js';
-import { hasCoreValuePort, mcpNamespace, mintNamespacePrefix, protocolOf } from './coreValuePorts.js';
-import { CORE_PROTOCOL_PREFIXES } from './generated/toolNameTables.js';
+import { hasCoreValuePort, mcpNamespace, mintNamespacePrefix } from './coreValuePorts.js';
 const notLanded = () => Object.freeze({ state: 'not_landed' });
 const unreadable = () => Object.freeze({ state: 'unreadable' });
 function readHalf(half) {
@@ -54,77 +53,11 @@ export function engineToolDirectoryOf(source) {
         return unreadable();
     }
 }
-export function mcpEntryReadingOf(toolName, directory) {
-    let ns;
-    try {
-        const mcp = namingPorts();
-        if (mcp === undefined)
-            return CORE_PROTOCOL_PREFIXES.some((p) => toolName.startsWith(p)) ? 'unchecked' : 'outside';
-        ns = protocolOf(toolName);
-        if (ns === undefined || ns.id !== mcp.id)
-            return 'outside';
-    }
-    catch {
-        return CORE_PROTOCOL_PREFIXES.some((p) => toolName.startsWith(p)) ? 'unchecked' : 'outside';
-    }
-    const prefixes = prefixesInHand(directory);
-    if (prefixes === undefined)
-        return 'unchecked';
-    let prefix;
-    try {
-        const peer = peerSegmentOf(ns, toolName);
-        if (peer === undefined || peer.includes('*'))
-            return 'unparsable';
-        prefix = mintNamespacePrefix(ns, peer);
-    }
-    catch {
-        return 'unparsable';
-    }
-    if (typeof prefix !== 'string' || prefix.length === 0)
-        return 'unchecked';
-    try {
-        return prefixes.has(prefix) ? 'answers' : 'unanswered';
-    }
-    catch {
-        return 'unchecked';
-    }
-}
-function prefixesInHand(directory) {
-    try {
-        if (directory === undefined || directory === null || typeof directory !== 'object' || directory.state !== 'directory')
-            return undefined;
-        const prefixes = directory.mcpServerPrefixes;
-        if (prefixes === null || typeof prefixes !== 'object' || typeof prefixes.has !== 'function')
-            return undefined;
-        return prefixes;
-    }
-    catch {
-        return undefined;
-    }
-}
 function namingPorts() {
     if (!hasCoreValuePort('protocolOf') || !hasCoreValuePort('mintNamespacePrefix'))
         return undefined;
     return mcpNamespace();
 }
-function peerSegmentOf(ns, toolName) {
-    const read = (n) => {
-        const parsed = ns.parse(n);
-        if (parsed === null || typeof parsed !== 'object')
-            return undefined;
-        const peer = ownDataField(parsed, 'peer');
-        return typeof peer === 'string' && peer.length > 0 ? peer : undefined;
-    };
-    const direct = read(toolName);
-    if (direct !== undefined)
-        return direct;
-    if (!toolName.startsWith(ns.prefix))
-        return undefined;
-    const rest = toolName.slice(ns.prefix.length);
-    if (rest.length === 0)
-        return undefined;
-    return read(ns.makeName(rest, 'x')) === rest ? rest : undefined;
-}
 function unescapedIndexOf(s, ch, last) {
     for (let k = 0; k < s.length; k++) {
         const i = last ? s.length - 1 - k : k;
@@ -150,29 +83,3 @@ export function deniedEntryToolName(entry) {
     const name = entry.substring(0, open);
     return name.length === 0 ? entry : name.trim();
 }
-export function excludeToolsAgainstDirectory(exclude, directory) {
-    if (!Array.isArray(exclude))
-        throw new TypeError('excludeToolsAgainstDirectory: exclude must be an array of tool names');
-    const verdict = prefixesInHand(directory) !== undefined ? 'filtered' : 'directory_absent';
-    const send = [];
-    const omitted = [];
-    for (const entry of exclude) {
-        if (verdict === 'filtered' && typeof entry === 'string') {
-            const name = deniedEntryToolName(entry);
-            if (name !== undefined && mcpEntryReadingOf(name, directory) === 'unanswered') {
-                omitted.push(entry);
-                continue;
-            }
-        }
-        send.push(entry);
-    }
-    if (omitted.length === 0)
-        return { send, omitted, verdict };
-    const one = omitted.length === 1;
-    return {
-        send,
-        omitted,
-        verdict,
-        disclosure: `excludeTools: ${omitted.map((e) => JSON.stringify(e)).join(', ')} ${one ? 'names' : 'name'} no tool this deployment answers to (no MCP server of that name is declared for this session) — omitted. Excluding a tool that cannot be mounted changes nothing; the engine refuses a request that names one.`,
-    };
-}

package/dist/engineUrl.d.ts

@@ -0,0 +1,18 @@
+export type EngineBaseUrlRefusalReason = 'empty' | 'scheme' | 'unparseable' | 'userinfo' | 'query_or_fragment';
+export type EngineBaseUrlReading = {
+    readonly ok: true;
+    readonly url: string;
+} | {
+    readonly ok: false;
+    readonly reason: EngineBaseUrlRefusalReason;
+};
+export type EngineUrlTransportRefusalReason = 'plaintext_remote' | 'not_http_url';
+export type EngineUrlTransportVerdict = {
+    readonly ok: true;
+    readonly loopback: boolean;
+} | {
+    readonly ok: false;
+    readonly reason: EngineUrlTransportRefusalReason;
+};
+export declare function normalizeEngineBaseUrl(raw: string | null | undefined): EngineBaseUrlReading;
+export declare function engineUrlTransportVerdict(url: string): EngineUrlTransportVerdict;

package/dist/engineUrl.js

@@ -0,0 +1,52 @@
+import { isLoopbackWireUrl } from './engineWireSdk.js';
+const SLASH = 47;
+function refusedBase(reason) {
+    return Object.freeze({ ok: false, reason });
+}
+function refusedTransport(reason) {
+    return Object.freeze({ ok: false, reason });
+}
+function withoutTrailingSlashes(s) {
+    let end = s.length;
+    while (end > 0 && s.charCodeAt(end - 1) === SLASH)
+        end--;
+    return s.slice(0, end);
+}
+export function normalizeEngineBaseUrl(raw) {
+    if (typeof raw !== 'string')
+        return refusedBase('empty');
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return refusedBase('empty');
+    if (!/^https?:\/\//i.test(trimmed))
+        return refusedBase('scheme');
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return refusedBase('unparseable');
+    }
+    if (parsed.username !== '' || parsed.password !== '')
+        return refusedBase('userinfo');
+    if (trimmed.includes('?') || trimmed.includes('#'))
+        return refusedBase('query_or_fragment');
+    return Object.freeze({ ok: true, url: withoutTrailingSlashes(trimmed) });
+}
+export function engineUrlTransportVerdict(url) {
+    if (typeof url !== 'string')
+        return refusedTransport('not_http_url');
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return refusedTransport('not_http_url');
+    }
+    const loopback = isLoopbackWireUrl(url);
+    if (parsed.protocol === 'https:')
+        return Object.freeze({ ok: true, loopback });
+    if (parsed.protocol === 'http:')
+        return loopback ? Object.freeze({ ok: true, loopback: true }) : refusedTransport('plaintext_remote');
+    return refusedTransport('not_http_url');
+}

package/dist/env/uiLanguage.d.ts

@@ -3,3 +3,12 @@ export declare const UI_LANGUAGES: readonly UiLanguage[];
 export declare const UI_LANGUAGE_ENDONYMS: Record<UiLanguage, string>;
 export declare function isUiLanguage(v: unknown): v is UiLanguage;
 export declare function pickUiLanguage(localeTag: string | undefined): UiLanguage;
+export type UiLanguageSource = 'saved' | 'host' | 'default';
+export interface UiLanguageResolution {
+    readonly language: UiLanguage;
+    readonly source: UiLanguageSource;
+}
+export declare function resolveUiLanguageFrom(input: {
+    readonly saved?: string | null | undefined;
+    readonly hostTags?: readonly (string | null | undefined)[] | null | undefined;
+} | null | undefined): UiLanguageResolution;

package/dist/env/uiLanguage.js

@@ -10,3 +10,38 @@ export function isUiLanguage(v) {
 export function pickUiLanguage(localeTag) {
     return parseLocaleTag(localeTag).language === 'zh' ? 'zh' : 'en';
 }
+const HOST_TAGS_READ_LIMIT = 64;
+function ownDataOf(v, key) {
+    if (v === null || typeof v !== 'object')
+        return undefined;
+    try {
+        const d = Object.getOwnPropertyDescriptor(v, key);
+        return d !== undefined && 'value' in d ? d.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resolveUiLanguageFrom(input) {
+    const saved = ownDataOf(input, 'saved');
+    if (isUiLanguage(saved))
+        return Object.freeze({ language: saved, source: 'saved' });
+    const tags = ownDataOf(input, 'hostTags');
+    let isList = false;
+    try {
+        isList = Array.isArray(tags);
+    }
+    catch {
+        isList = false;
+    }
+    if (isList) {
+        const n = ownDataOf(tags, 'length');
+        const limit = typeof n === 'number' && Number.isSafeInteger(n) && n > 0 ? Math.min(n, HOST_TAGS_READ_LIMIT) : 0;
+        for (let i = 0; i < limit; i += 1) {
+            const tag = ownDataOf(tags, String(i));
+            if (typeof tag === 'string' && tag.length > 0)
+                return Object.freeze({ language: pickUiLanguage(tag), source: 'host' });
+        }
+    }
+    return Object.freeze({ language: 'en', source: 'default' });
+}