@sema-agent/client-core 0.97.0 → 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

@@ -0,0 +1,18 @@
+export interface EngineToolDirectorySource {
+    readonly requestMcpServers?: readonly {
+        readonly name: string;
+    }[] | null;
+    readonly deploymentMcpServers?: readonly {
+        readonly name: string;
+    }[] | null;
+}
+export type EngineToolDirectory = {
+    readonly state: 'not_landed';
+} | {
+    readonly state: 'unreadable';
+} | {
+    readonly state: 'directory';
+    readonly mcpServerPrefixes: ReadonlySet<string>;
+};
+export declare function engineToolDirectoryOf(source: EngineToolDirectorySource | null | undefined): EngineToolDirectory;
+export declare function deniedEntryToolName(entry: string): string | undefined;

package/dist/engineToolDirectory.js

@@ -0,0 +1,85 @@
+import { frozenSet } from './frozenSet.js';
+import { ownDataField } from './ownKey.js';
+import { hasCoreValuePort, mcpNamespace, mintNamespacePrefix } from './coreValuePorts.js';
+const notLanded = () => Object.freeze({ state: 'not_landed' });
+const unreadable = () => Object.freeze({ state: 'unreadable' });
+function readHalf(half) {
+    if (half === undefined || half === null)
+        return 'absent';
+    if (!Array.isArray(half))
+        return 'unreadable';
+    const names = [];
+    const n = ownDataField(half, 'length');
+    if (typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0)
+        return 'unreadable';
+    for (let i = 0; i < n; i++) {
+        if (!Object.hasOwn(half, i))
+            return 'unreadable';
+        const row = ownDataField(half, String(i));
+        if (row === null || typeof row !== 'object')
+            return 'unreadable';
+        const name = ownDataField(row, 'name');
+        if (typeof name !== 'string' || name.length === 0)
+            return 'unreadable';
+        names.push(name);
+    }
+    return names;
+}
+export function engineToolDirectoryOf(source) {
+    if (source === undefined || source === null)
+        return notLanded();
+    try {
+        if (typeof source !== 'object')
+            return unreadable();
+        const request = readHalf(ownDataField(source, 'requestMcpServers'));
+        const deployment = readHalf(ownDataField(source, 'deploymentMcpServers'));
+        if (request === 'unreadable' || deployment === 'unreadable')
+            return unreadable();
+        if (request === 'absent' || deployment === 'absent')
+            return notLanded();
+        const ns = namingPorts();
+        if (ns === undefined)
+            return unreadable();
+        const prefixes = [];
+        for (const name of [...request, ...deployment]) {
+            const prefix = mintNamespacePrefix(ns, name);
+            if (typeof prefix !== 'string' || prefix.length === 0)
+                return unreadable();
+            prefixes.push(prefix);
+        }
+        return Object.freeze({ state: 'directory', mcpServerPrefixes: frozenSet(prefixes) });
+    }
+    catch {
+        return unreadable();
+    }
+}
+function namingPorts() {
+    if (!hasCoreValuePort('protocolOf') || !hasCoreValuePort('mintNamespacePrefix'))
+        return undefined;
+    return mcpNamespace();
+}
+function unescapedIndexOf(s, ch, last) {
+    for (let k = 0; k < s.length; k++) {
+        const i = last ? s.length - 1 - k : k;
+        if (s[i] !== ch)
+            continue;
+        let backslashes = 0;
+        for (let j = i - 1; j >= 0 && s[j] === '\\'; j--)
+            backslashes++;
+        if (backslashes % 2 === 0)
+            return i;
+    }
+    return -1;
+}
+export function deniedEntryToolName(entry) {
+    if (entry !== entry.trim())
+        return undefined;
+    const open = unescapedIndexOf(entry, '(', false);
+    if (open === -1)
+        return entry;
+    const close = unescapedIndexOf(entry, ')', true);
+    if (close === -1 || close <= open || close !== entry.length - 1)
+        return entry;
+    const name = entry.substring(0, open);
+    return name.length === 0 ? entry : name.trim();
+}

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' });
+}

package/dist/eventLeg.d.ts

@@ -0,0 +1,92 @@
+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';
+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 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;