@sema-agent/client-core 0.97.1 → 0.99.0

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/engineWireFor.js

@@ -1,6 +1,7 @@
 import { settleWithinDeadline } from './abortableSleep.js';
 import { makeEngineWireClient } from './engineWireSdk.js';
 import { engineWireTargetFor } from './engineWireTarget.js';
+import { readThrownSlot } from './wireFailureShape.js';
 export const INJECTED_WIRE_SETTLE_MS = 60_000;
 export function engineWireFor(wire, sessionKey, usable) {
     if (wire !== undefined) {
@@ -285,15 +286,9 @@ function abortedBeforeSendError() {
     return e;
 }
 function answeredByEngine(e) {
-    try {
-        if (e === null || typeof e !== 'object')
-            return false;
-        const o = e;
-        return typeof o.status === 'number' || typeof o.errorCode === 'string';
-    }
-    catch {
+    if (e === null || typeof e !== 'object')
         return false;
-    }
+    return typeof readThrownSlot(e, 'status', 'data') === 'number' || typeof readThrownSlot(e, 'errorCode', 'data') === 'string';
 }
 const SETTLED_BY_PACKAGE_BRAND = Symbol.for('@sema-agent/client-core:engine-wire-settled');
 function settledByPackage(value) {

package/dist/env/uiLanguage.d.ts

@@ -1,5 +1,15 @@
-export type UiLanguage = 'en' | 'zh';
+import { SETTINGS_UI_LANGUAGE_VALUES } from '../generated/settingsSchemaTables.js';
+export type UiLanguage = (typeof SETTINGS_UI_LANGUAGE_VALUES)[number];
 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

@@ -1,12 +1,48 @@
 import { parseLocaleTag } from './localeTag.js';
-export const UI_LANGUAGES = ['en', 'zh'];
+import { SETTINGS_UI_LANGUAGE_VALUES } from '../generated/settingsSchemaTables.js';
+export const UI_LANGUAGES = SETTINGS_UI_LANGUAGE_VALUES;
 export const UI_LANGUAGE_ENDONYMS = {
     en: 'English',
     zh: '中文',
 };
 export function isUiLanguage(v) {
-    return v === 'en' || v === 'zh';
+    return typeof v === 'string' && UI_LANGUAGES.includes(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' });
+}

package/dist/eventLeg.d.ts

@@ -0,0 +1,100 @@
+import type { AgentEvent } from '@sema-agent/sdk';
+import type { EngineBoundRun } from './engineRowRef.js';
+import { type AskGateWireDeps } from './hitl/askGateWire.js';
+import { type ActiveRunBusySignal } from './adapter/runStream.js';
+import type { ApprovalRequestChromeEvent, ApprovalRevokeChromeEvent } from './seam.js';
+export declare const EVENT_LEG_KINDS: readonly ["live", "durable", "continuation"];
+export type EventLegKind = (typeof EVENT_LEG_KINDS)[number];
+export type EventLegStage = 'bindRun' | 'stampOwner' | 'hitlFrames' | 'askBridge' | 'idleTriage';
+export interface EventLegRow {
+    readonly stages: readonly EventLegStage[];
+    readonly windowIsCurrent: boolean;
+}
+export declare const EVENT_LEG_TABLE: Readonly<Record<EventLegKind, EventLegRow>>;
+export interface EventLegLiveSpec {
+    readonly kind: 'live';
+}
+export interface EventLegRunSpec {
+    readonly kind: 'durable' | 'continuation';
+    readonly runId: string;
+}
+export type EventLegSpec = EventLegLiveSpec | EventLegRunSpec;
+export type EventLegBindCause = 'open' | 'frame' | 'handoff';
+export interface EventLegBoundInfo {
+    readonly cause: EventLegBindCause;
+    readonly leg: EventLegKind;
+}
+export interface EventLegFrameInfo {
+    readonly leg: EventLegKind;
+}
+export interface EventLegHitlEnvelope {
+    readonly windowIsCurrent: boolean;
+    readonly leg: EventLegKind;
+}
+export type EventLegQuestionFrame = Extract<AgentEvent, {
+    type: 'question' | 'question_complete';
+}>;
+export type EventLegElicitationFrame = Extract<AgentEvent, {
+    type: 'elicitation' | 'elicitation_complete';
+}>;
+export type EventLegToolApprovalFrame = Extract<AgentEvent, {
+    type: 'tool_approval' | 'tool_approval_complete';
+}>;
+export interface EventLegRunPorts {
+    headerRunId?(): string | undefined;
+    onBound?(binding: EngineBoundRun, info: EventLegBoundInfo): void;
+    onRefused?(refusal: EventLegRefusal, info: EventLegFrameInfo): void;
+    onTerminal?(frame: AgentEvent, binding: EngineBoundRun | undefined, info: EventLegFrameInfo): void;
+    isCurrent?(): boolean;
+}
+export interface EventLegRefusal {
+    readonly kind: 'busy' | 'not_created';
+    readonly candidateRunId?: string;
+    readonly busy?: ActiveRunBusySignal;
+    readonly errorCode?: string;
+}
+export interface EventLegOwnerPorts {
+    readonly sessionKey?: string;
+}
+export interface EventLegHitlPorts {
+    question?(frame: EventLegQuestionFrame, env: EventLegHitlEnvelope): void;
+    elicitation?(frame: EventLegElicitationFrame, env: EventLegHitlEnvelope): void;
+    toolApproval?(frame: EventLegToolApprovalFrame, env: EventLegHitlEnvelope): void;
+}
+export interface EventLegIdleTriagePorts {
+    readonly baseUrl: string;
+}
+export type EventLegTap = (frame: AgentEvent) => void;
+export type EventLegStreamDecorator = (stream: AsyncGenerator<AgentEvent>, ctx: EventLegStreamContext) => AsyncGenerator<AgentEvent>;
+export interface EventLegStreamContext {
+    readonly leg: EventLegKind;
+    readonly runId: string | undefined;
+}
+export interface ApprovalFrameContext {
+    readonly leg: EventLegKind;
+    readonly windowIsCurrent: boolean;
+    readonly receivedAtMs: number;
+    readonly streamEnded: AbortSignal;
+}
+export declare function approvalFrameContextOf(arm: ApprovalRequestChromeEvent | ApprovalRevokeChromeEvent): ApprovalFrameContext | undefined;
+export interface EventLegPorts {
+    readonly run?: EventLegRunPorts;
+    readonly owner?: EventLegOwnerPorts;
+    readonly hitl?: EventLegHitlPorts;
+    readonly askBridge?: AskGateWireDeps;
+    readonly idleTriage?: EventLegIdleTriagePorts;
+    readonly signal?: AbortSignal;
+    readonly taps?: readonly EventLegTap[];
+    readonly perStream?: readonly EventLegStreamDecorator[];
+}
+export type EventLegPortName = 'run.headerRunId' | 'run.onBound' | 'run.onRefused' | 'run.onTerminal' | 'run.isCurrent' | 'hitl.question' | 'hitl.elicitation' | 'hitl.toolApproval' | 'askBridge.respondToolApproval' | 'taps' | 'perStream';
+export interface EventLegReport {
+    readonly missingPorts: readonly EventLegPortName[];
+    readonly portFaults: Readonly<Partial<Record<EventLegPortName, number>>>;
+    readonly hitlUndelivered: number;
+}
+export interface EventLeg {
+    readonly events: AsyncGenerator<AgentEvent>;
+    report(): EventLegReport;
+}
+export declare function composeEventLeg(source: AsyncIterable<AgentEvent>, leg: EventLegSpec, ports: EventLegPorts): EventLeg;