@sema-agent/client-core 0.84.1 → 0.85.1

package/dist/engineNoticeCodes.js

@@ -1,82 +1,10 @@
-export const ENGINE_NOTICE_CODES = Object.freeze([
-    'config.autocompact_window_clamped',
-    'config.env_timeout_discarded',
-    'config.materialize_env_discarded',
-    'config.models_swapped',
-    'config.context_settings_swapped',
-    'config.read_face_swapped',
-    'config.read_face_deployment_clamped',
-    'config.write_face_swapped',
-    'config.write_face_deployment_clamped',
-    'config.tool_model_gate_removed',
-    'config.tool_model_gate_unknown_class',
-    'config.tool_model_gate_env_invalid',
-    'config.artifact_host_invalid',
-    'config.task_root_not_canonical',
-    'config.write_protection_target_view_absent',
-    'config.write_protection_unresolved',
-    'config.execution_env_capability_invalid',
-    'config.tool_card_undeclared',
-    'config.tool_face_undeclared',
-    'config.tool_face_invalid',
-    'config.forward_sink_failed',
-    'config.durable_gate_unavailable',
-    'config.peer_admission_out_of_range',
-    'config.peer_lane_unmounted',
-    'config.secret_env_scrubbed',
-    'peer.inbound_disposition',
-    'peer.held_settled',
-    'peer.idle_subscription',
-    'classifier.denial_limit',
-    'classifier.fallback',
-    'classifier.role_defaulted',
-    'classifier.contract_broken',
-    'checkpoint.execution_outcome_unrecorded',
-    'delegation.transcript_integrity',
-    'delegation.ask_unresolvable',
-    'mcp.injection_dropped',
-    'mcp.revocation_probe_failed',
-    'mcp.server_redialed',
-    'workflow.governance_key_stripped',
-    'workflow.agent_option_ignored',
-    'memory.session_polluted',
-    'memory.harvest_quarantined',
-    'memory.delegation_static_mark_waived',
-    'memory.content_class_declared',
-    'memory.hold_opened',
-    'memory.hold_released',
-    'memory.hold_disposed',
-    'memory.consolidation_recommended',
-    'memory.consolidation_committed',
-    'memory.consolidation_conflict',
-    'memory.consolidation_incomplete',
-    'memory.consolidation_refused',
-    'memory.consolidation_withheld',
-    'memory.restore_withheld',
-    'memory.project_scope_absent',
-    'route.fallback_to_primary',
-    'route.classifier_unroutable',
-    'route.base_url_changed_key_unchanged',
-    'route.response_model_mismatch',
-    'task.user_steer_undrained',
-    'task.user_followup_undrained',
-    'steering.parked_input_blocked',
-    'task.turn_interrupted',
-    'task.halt_unconsumed',
-    'task.late_approval',
-    'task.interrupt_unconsumed',
-    'approval.read_root_granted',
-    'approval.read_root_grant_rejected',
-    'memory.capture_opted_out',
-    'memory.capture_optout_unpersisted',
-    'skills.listing_truncated',
-    'agents.listing_truncated',
-    'tool_result.offload_put_failed',
-]);
+import { CORE_ENGINE_NOTICE_CODES, CORE_MCP_INJECTION_DROP_REASONS, CORE_NOTICE_AUDIENCE } from './generated/engineNoticeTables.js';
+export const ENGINE_NOTICE_CODES = CORE_ENGINE_NOTICE_CODES;
 const CATALOG = new Set(ENGINE_NOTICE_CODES);
 export const SERVER_NOTICE_AUDIENCE = Object.freeze({
     'instructions.source_changed': 'user',
     'memory.layer_locked_legacy': 'operator',
+    'session.records_skipped': 'user',
 });
 function audienceRow(table, code) {
     return Object.hasOwn(table, code) ? table[code] : undefined;
@@ -84,92 +12,13 @@ function audienceRow(table, code) {
 export function engineNoticeInCatalog(code) {
     return typeof code === 'string' && (CATALOG.has(code) || Object.hasOwn(SERVER_NOTICE_AUDIENCE, code));
 }
-export const ENGINE_NOTICE_AUDIENCE = Object.freeze({
-    'config.autocompact_window_clamped': 'operator',
-    'config.env_timeout_discarded': 'operator',
-    'config.materialize_env_discarded': 'operator',
-    'config.models_swapped': 'operator',
-    'config.context_settings_swapped': 'operator',
-    'config.read_face_swapped': 'operator',
-    'config.read_face_deployment_clamped': 'operator',
-    'config.write_face_swapped': 'operator',
-    'config.write_face_deployment_clamped': 'operator',
-    'config.tool_model_gate_removed': 'operator',
-    'config.tool_model_gate_unknown_class': 'operator',
-    'config.tool_model_gate_env_invalid': 'operator',
-    'config.artifact_host_invalid': 'operator',
-    'config.task_root_not_canonical': 'operator',
-    'config.write_protection_target_view_absent': 'operator',
-    'config.write_protection_unresolved': 'operator',
-    'config.execution_env_capability_invalid': 'operator',
-    'config.tool_card_undeclared': 'operator',
-    'config.tool_face_undeclared': 'operator',
-    'config.tool_face_invalid': 'operator',
-    'config.forward_sink_failed': 'operator',
-    'config.durable_gate_unavailable': 'user',
-    'config.peer_admission_out_of_range': 'operator',
-    'config.peer_lane_unmounted': 'operator',
-    'config.secret_env_scrubbed': 'operator',
-    'peer.inbound_disposition': 'user',
-    'peer.held_settled': 'user',
-    'peer.idle_subscription': 'user',
-    'classifier.denial_limit': 'user',
-    'classifier.fallback': 'operator',
-    'classifier.role_defaulted': 'operator',
-    'classifier.contract_broken': 'operator',
-    'checkpoint.execution_outcome_unrecorded': 'operator',
-    'delegation.transcript_integrity': 'operator',
-    'delegation.ask_unresolvable': 'user',
-    'mcp.injection_dropped': 'user',
-    'mcp.revocation_probe_failed': 'operator',
-    'mcp.server_redialed': 'operator',
-    'workflow.governance_key_stripped': 'operator',
-    'workflow.agent_option_ignored': 'operator',
-    'memory.session_polluted': 'user',
-    'memory.harvest_quarantined': 'user',
-    'memory.delegation_static_mark_waived': 'user',
-    'memory.content_class_declared': 'operator',
-    'memory.hold_opened': 'user',
-    'memory.hold_released': 'user',
-    'memory.hold_disposed': 'user',
-    'memory.consolidation_recommended': 'operator',
-    'memory.consolidation_committed': 'operator',
-    'memory.consolidation_conflict': 'operator',
-    'memory.consolidation_incomplete': 'operator',
-    'memory.consolidation_refused': 'operator',
-    'memory.consolidation_withheld': 'operator',
-    'memory.restore_withheld': 'operator',
-    'memory.project_scope_absent': 'operator',
-    'route.fallback_to_primary': 'operator',
-    'route.classifier_unroutable': 'operator',
-    'route.base_url_changed_key_unchanged': 'operator',
-    'route.response_model_mismatch': 'operator',
-    'task.user_steer_undrained': 'user',
-    'task.user_followup_undrained': 'user',
-    'steering.parked_input_blocked': 'user',
-    'task.turn_interrupted': 'user',
-    'task.halt_unconsumed': 'user',
-    'task.late_approval': 'user',
-    'task.interrupt_unconsumed': 'user',
-    'approval.read_root_granted': 'user',
-    'approval.read_root_grant_rejected': 'user',
-    'memory.capture_opted_out': 'user',
-    'memory.capture_optout_unpersisted': 'user',
-    'skills.listing_truncated': 'operator',
-    'agents.listing_truncated': 'operator',
-    'tool_result.offload_put_failed': 'operator',
-});
+export const ENGINE_NOTICE_AUDIENCE = CORE_NOTICE_AUDIENCE;
 export function noticeAudienceOf(code) {
     if (typeof code !== 'string')
         return 'operator';
     return audienceRow(ENGINE_NOTICE_AUDIENCE, code) ?? audienceRow(SERVER_NOTICE_AUDIENCE, code) ?? 'operator';
 }
-export const MCP_INJECTION_DROP_REASONS = Object.freeze([
-    'malformed_entry',
-    'name_reserved_by_deployment',
-    'gate_closed',
-    'over_cap',
-]);
+export const MCP_INJECTION_DROP_REASONS = CORE_MCP_INJECTION_DROP_REASONS;
 const DROP_REASONS = new Set(MCP_INJECTION_DROP_REASONS);
 export function readMcpInjectionDrop(notice) {
     if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
@@ -384,6 +233,44 @@ export function readInstructionsSourceChanged(notice) {
         return undefined;
     }
 }
+function countReading(v) {
+    return typeof v === 'number' && Number.isInteger(v) && v >= 0 ? v : 'unknown';
+}
+export function readSessionRecordsSkipped(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    try {
+        const n = notice;
+        if (n.code !== 'session.records_skipped')
+            return undefined;
+        const d = n.detail;
+        if (typeof d !== 'object' || d === null || Array.isArray(d))
+            return undefined;
+        const o = d;
+        const own = (k) => (Object.hasOwn(o, k) ? o[k] : undefined);
+        const sid = own('sessionId');
+        const sessionId = typeof sid === 'string' && sid.length > 0 ? sid : undefined;
+        if (sessionId === undefined)
+            return undefined;
+        return { dropped: countReading(own('dropped')), entriesKept: countReading(own('entriesKept')), sessionId };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function sessionRecordsSkippedNote(facts) {
+    let kept;
+    try {
+        kept = facts !== null && typeof facts === 'object' ? facts.entriesKept : undefined;
+    }
+    catch {
+        kept = undefined;
+    }
+    if (kept !== 0)
+        return undefined;
+    return ("None of this session's earlier entries could be read, so this turn runs with an empty context — the model sees nothing of the earlier conversation. " +
+        'If that history matters, whoever operates this engine has to repair the stored log of this session.');
+}
 export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'mcp.injection_dropped': readMcpInjectionDrop,
     'delegation.ask_unresolvable': readAskUnresolvable,
@@ -393,6 +280,7 @@ export const ENGINE_NOTICE_FACT_READERS = Object.freeze({
     'instructions.source_changed': readInstructionsSourceChanged,
     'approval.read_root_granted': readReadRootGrantNotice,
     'approval.read_root_grant_rejected': readReadRootGrantNotice,
+    'session.records_skipped': readSessionRecordsSkipped,
 });
 const _factReaderTablePin = true;
 void _factReaderTablePin;

package/dist/engineWireFor.d.ts

@@ -0,0 +1,43 @@
+import type { AgentClient } from '@sema-agent/sdk';
+import { type EngineWireClientConfig, type EngineWireInjection } from './engineWireSdk.js';
+import { type EngineWireTarget } from './engineWireTarget.js';
+export declare const INJECTED_WIRE_SETTLE_MS = 60000;
+export type EngineWireTargetClientOptions = Pick<EngineWireClientConfig, 'timeoutMs' | 'maxRetries'>;
+export interface EngineWireInjected<C> {
+    kind: 'injected';
+    client: C;
+    capsBaseUrl: string | undefined;
+}
+export interface EngineWireFromTarget {
+    kind: 'target';
+    target: EngineWireTarget;
+    make: (opts?: EngineWireTargetClientOptions) => AgentClient | null;
+}
+export interface EngineWireInjectedUnusable {
+    kind: 'injected-unusable';
+}
+export interface EngineWireNoTarget {
+    kind: 'no-target';
+}
+export type EngineWireResolution<C> = EngineWireInjected<C> | EngineWireFromTarget | EngineWireInjectedUnusable | EngineWireNoTarget;
+export declare function engineWireFor<C extends object>(wire: EngineWireInjection<C> | undefined, sessionKey: string, usable: (client: object) => client is C): EngineWireResolution<C>;
+export declare function clientHasVerbs(client: object, verbs: ReadonlyArray<ReadonlyArray<string>>): boolean;
+export interface LinkedAbortSignal {
+    signal: AbortSignal;
+    dispose: () => void;
+}
+export declare function linkedAbortSignal(caller: AbortSignal | null | undefined, deadline: AbortSignal): LinkedAbortSignal;
+export declare function injectedDeadlineDetail(ms?: number): string;
+export declare class EngineWireNoAnswerError extends Error {
+    constructor(message: string);
+}
+export declare function cancelledWaitDetail(): string;
+export declare class EngineWireCancelledError extends Error {
+    constructor();
+}
+export declare function connectionLostDetail(): string;
+export type EngineWireNoAnswerKind = 'deadline' | 'time-limit' | 'connection-lost' | 'cancelled';
+export declare function noAnswerKindOf(e: object | null | undefined): EngineWireNoAnswerKind | null;
+export declare function noAnswerDetailFrom(e: object | null | undefined): string | null;
+export declare function sendOnce<T>(signal: AbortSignal | null | undefined, run: () => Promise<T>): Promise<T>;
+export declare function settleInjected<T>(ms: number, signal: AbortSignal | null | undefined, run: (signal: AbortSignal) => Promise<T>): Promise<T>;

package/dist/engineWireFor.js

@@ -0,0 +1,399 @@
+import { settleWithinDeadline } from './abortableSleep.js';
+import { makeEngineWireClient } from './engineWireSdk.js';
+import { engineWireTargetFor } from './engineWireTarget.js';
+export const INJECTED_WIRE_SETTLE_MS = 60_000;
+export function engineWireFor(wire, sessionKey, usable) {
+    if (wire !== undefined) {
+        let client;
+        let capsBaseUrl;
+        try {
+            if (wire === null || typeof wire !== 'object')
+                return { kind: 'injected-unusable' };
+            client = wire.client;
+            capsBaseUrl = wire.capsBaseUrl;
+        }
+        catch {
+            return { kind: 'injected-unusable' };
+        }
+        if (client === null || typeof client !== 'object')
+            return { kind: 'injected-unusable' };
+        const candidate = client;
+        if (!usable(candidate))
+            return { kind: 'injected-unusable' };
+        return { kind: 'injected', client: candidate, capsBaseUrl: typeof capsBaseUrl === 'string' && capsBaseUrl !== '' ? capsBaseUrl : undefined };
+    }
+    const installed = engineWireTargetFor(sessionKey);
+    if (!installed)
+        return { kind: 'no-target' };
+    const target = Object.freeze({
+        baseUrl: installed.baseUrl,
+        ...(installed.token !== undefined ? { token: installed.token } : {}),
+        ...(installed.principal !== undefined ? { principal: installed.principal } : {}),
+    });
+    return {
+        kind: 'target',
+        target,
+        make: (opts) => makeEngineWireClient({
+            baseUrl: target.baseUrl,
+            ...(target.token ? { token: target.token } : {}),
+            principal: target.principal,
+            ...(opts?.timeoutMs !== undefined ? { timeoutMs: opts.timeoutMs } : {}),
+            ...(opts?.maxRetries !== undefined ? { maxRetries: opts.maxRetries } : {}),
+        }),
+    };
+}
+export function clientHasVerbs(client, verbs) {
+    try {
+        if (client === null || typeof client !== 'object')
+            return false;
+        for (const path of verbs) {
+            let cur = client;
+            for (const seg of path) {
+                if (cur === null || (typeof cur !== 'object' && typeof cur !== 'function'))
+                    return false;
+                cur = cur[seg];
+            }
+            if (typeof cur !== 'function')
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function callerSignalOf(signal) {
+    return signal === null ? undefined : signal;
+}
+function quietlyRemoveAbortListener(signal, listener) {
+    try {
+        signal.removeEventListener('abort', listener);
+    }
+    catch {
+    }
+}
+export function linkedAbortSignal(caller, deadline) {
+    const from = callerSignalOf(caller);
+    if (from === undefined)
+        return { signal: deadline, dispose: () => { } };
+    if (typeof AbortSignal.any === 'function')
+        return { signal: AbortSignal.any([from, deadline]), dispose: () => { } };
+    const ac = new AbortController();
+    if (from.aborted || deadline.aborted) {
+        ac.abort();
+        return { signal: ac.signal, dispose: () => { } };
+    }
+    const onAbort = () => ac.abort();
+    from.addEventListener('abort', onAbort, { once: true });
+    deadline.addEventListener('abort', onAbort, { once: true });
+    return {
+        signal: ac.signal,
+        dispose: () => {
+            quietlyRemoveAbortListener(from, onAbort);
+            quietlyRemoveAbortListener(deadline, onAbort);
+        },
+    };
+}
+export function injectedDeadlineDetail(ms) {
+    const within = ms === undefined ? 'the time limit this client allows' : `${ms} ms`;
+    return `no answer from the engine within ${within} — the request was abandoned (it may still have been received)`;
+}
+const NO_ANSWER_BRAND = Symbol.for('@sema-agent/client-core:engine-wire-no-answer');
+const CANCELLED_BRAND = Symbol.for('@sema-agent/client-core:engine-wire-cancelled');
+function branded(e, brand) {
+    return Object.prototype.hasOwnProperty.call(e, brand) && e[brand] === true;
+}
+export class EngineWireNoAnswerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'EngineWireNoAnswerError';
+        Object.defineProperty(this, NO_ANSWER_BRAND, { value: true, enumerable: false });
+    }
+}
+export function cancelledWaitDetail() {
+    return 'no answer from the engine — the wait was cancelled after the request was sent (cancelling stops only the wait, not the request: it may still have been received)';
+}
+export class EngineWireCancelledError extends Error {
+    constructor() {
+        super(cancelledWaitDetail());
+        this.name = 'EngineWireCancelledError';
+        Object.defineProperty(this, CANCELLED_BRAND, { value: true, enumerable: false });
+    }
+}
+const NOT_SENT_MARK = Symbol.for('@sema-agent/client-core:engine-wire-not-sent');
+function markNotSent(error) {
+    try {
+        if (error !== null && (typeof error === 'object' || typeof error === 'function') && Object.isExtensible(error)) {
+            Object.defineProperty(error, NOT_SENT_MARK, { value: true, enumerable: false, configurable: true, writable: false });
+        }
+    }
+    catch {
+    }
+    return error;
+}
+function clearNotSent(error) {
+    try {
+        if (error !== null && (typeof error === 'object' || typeof error === 'function') && Object.prototype.hasOwnProperty.call(error, NOT_SENT_MARK)) {
+            delete error[NOT_SENT_MARK];
+        }
+    }
+    catch {
+    }
+    return error;
+}
+function markedNotSent(e) {
+    return Object.prototype.hasOwnProperty.call(e, NOT_SENT_MARK) && e[NOT_SENT_MARK] === true;
+}
+export function connectionLostDetail() {
+    return 'no answer from the engine — the connection failed before an answer came back (the request may still have been received)';
+}
+function isPreSendCode(code, syscall) {
+    switch (code) {
+        case 'ECONNREFUSED':
+        case 'ENOTFOUND':
+        case 'EAI_AGAIN':
+        case 'UND_ERR_CONNECT_TIMEOUT':
+        case 'ERR_INVALID_URL':
+        case 'ERR_INVALID_CHAR':
+        case 'ERR_HTTP_INVALID_HEADER_VALUE':
+        case 'ERR_INVALID_ARG_TYPE':
+        case 'ERR_TLS_CERT_ALTNAME_FORMAT':
+        case 'ERR_TLS_CERT_ALTNAME_INVALID':
+        case 'ERR_TLS_DH_PARAM_SIZE':
+        case 'ERR_TLS_HANDSHAKE_TIMEOUT':
+        case 'ERR_TLS_INVALID_CONTEXT':
+        case 'ERR_TLS_INVALID_PROTOCOL_METHOD':
+        case 'ERR_TLS_INVALID_PROTOCOL_VERSION':
+        case 'ERR_TLS_PROTOCOL_VERSION_CONFLICT':
+        case 'CERT_CHAIN_TOO_LONG':
+        case 'CERT_HAS_EXPIRED':
+        case 'CERT_NOT_YET_VALID':
+        case 'CERT_REJECTED':
+        case 'CERT_REVOKED':
+        case 'CERT_SIGNATURE_FAILURE':
+        case 'CERT_UNTRUSTED':
+        case 'CRL_HAS_EXPIRED':
+        case 'CRL_NOT_YET_VALID':
+        case 'CRL_SIGNATURE_FAILURE':
+        case 'DEPTH_ZERO_SELF_SIGNED_CERT':
+        case 'ERROR_IN_CERT_NOT_AFTER_FIELD':
+        case 'ERROR_IN_CERT_NOT_BEFORE_FIELD':
+        case 'ERROR_IN_CRL_LAST_UPDATE_FIELD':
+        case 'ERROR_IN_CRL_NEXT_UPDATE_FIELD':
+        case 'HOSTNAME_MISMATCH':
+        case 'INVALID_CA':
+        case 'INVALID_PURPOSE':
+        case 'PATH_LENGTH_EXCEEDED':
+        case 'SELF_SIGNED_CERT_IN_CHAIN':
+        case 'UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY':
+        case 'UNABLE_TO_DECRYPT_CERT_SIGNATURE':
+        case 'UNABLE_TO_DECRYPT_CRL_SIGNATURE':
+        case 'UNABLE_TO_GET_CRL':
+        case 'UNABLE_TO_GET_ISSUER_CERT':
+        case 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY':
+        case 'UNABLE_TO_VERIFY_LEAF_SIGNATURE':
+            return true;
+        case 'EHOSTUNREACH':
+        case 'ENETUNREACH':
+        case 'ETIMEDOUT':
+            return syscall === 'connect';
+        default:
+            return false;
+    }
+}
+function allAttemptsFailedBeforeSend(errors) {
+    if (!Array.isArray(errors) || errors.length === 0 || errors.length > 16)
+        return false;
+    return errors.every((x) => x !== null && typeof x === 'object' && isPreSendCode(x.code, x.syscall));
+}
+function failedBeforeSend(e) {
+    let cur = e;
+    for (let depth = 0; depth < 4 && cur !== null && typeof cur === 'object'; depth++) {
+        const o = cur;
+        if (isPreSendCode(o.code, o.syscall))
+            return true;
+        if (allAttemptsFailedBeforeSend(o.errors))
+            return true;
+        cur = cur.cause;
+    }
+    return false;
+}
+export function noAnswerKindOf(e) {
+    try {
+        if (e === null || typeof e !== 'object')
+            return null;
+        if (e instanceof EngineWireNoAnswerError || branded(e, NO_ANSWER_BRAND))
+            return 'deadline';
+        if (e instanceof EngineWireCancelledError || branded(e, CANCELLED_BRAND))
+            return 'cancelled';
+        if (markedNotSent(e))
+            return null;
+        const name = e.name;
+        if (name === 'TimeoutError')
+            return 'time-limit';
+        if ((e instanceof TypeError || name === 'TypeError') && !failedBeforeSend(e))
+            return 'connection-lost';
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function noAnswerDetailFrom(e) {
+    const kind = noAnswerKindOf(e);
+    if (kind === 'deadline') {
+        try {
+            return e.message;
+        }
+        catch {
+            return injectedDeadlineDetail();
+        }
+    }
+    if (kind === 'time-limit')
+        return injectedDeadlineDetail();
+    if (kind === 'connection-lost')
+        return connectionLostDetail();
+    if (kind === 'cancelled')
+        return cancelledWaitDetail();
+    return null;
+}
+function signalAborted(signal) {
+    try {
+        return signal !== undefined && signal !== null && signal.aborted === true;
+    }
+    catch {
+        return false;
+    }
+}
+function abortedBeforeSendError() {
+    const e = new Error('This operation was aborted');
+    e.name = 'AbortError';
+    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 {
+        return false;
+    }
+}
+const SETTLED_BY_PACKAGE_BRAND = Symbol.for('@sema-agent/client-core:engine-wire-settled');
+function settledByPackage(value) {
+    try {
+        return value !== null && typeof value === 'object' && branded(value, SETTLED_BY_PACKAGE_BRAND);
+    }
+    catch {
+        return false;
+    }
+}
+function abortReasonIfAborted(signal) {
+    try {
+        return signal !== undefined && signal.aborted === true ? { value: signal.reason } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function sendOnce(signal, run) {
+    const callerSignal = callerSignalOf(signal);
+    const abortedBefore = signalAborted(callerSignal);
+    const reasonBefore = abortedBefore ? abortReasonIfAborted(callerSignal) : undefined;
+    let returned;
+    try {
+        returned = run();
+    }
+    catch (error) {
+        throw markNotSent(error);
+    }
+    const innerSettled = settledByPackage(returned);
+    try {
+        return await Promise.resolve(returned);
+    }
+    catch (error) {
+        if (!innerSettled)
+            clearNotSent(error);
+        if (abortedBefore) {
+            if (reasonBefore !== undefined && error === reasonBefore.value && !answeredByEngine(error))
+                throw markNotSent(error);
+            throw error;
+        }
+        if (signalAborted(callerSignal) &&
+            !answeredByEngine(error) &&
+            noAnswerKindOf(error) !== 'deadline' &&
+            noAnswerKindOf(error) !== 'cancelled' &&
+            !provablyNotSent(error)) {
+            throw new EngineWireCancelledError();
+        }
+        throw error;
+    }
+}
+function provablyNotSent(e) {
+    try {
+        return e !== null && typeof e === 'object' && (markedNotSent(e) || failedBeforeSend(e));
+    }
+    catch {
+        return false;
+    }
+}
+export function settleInjected(ms, signal, run) {
+    const settled = settleInjectedOnce(ms, signal, run);
+    Object.defineProperty(settled, SETTLED_BY_PACKAGE_BRAND, { value: true, enumerable: false });
+    return settled;
+}
+async function settleInjectedOnce(ms, signal, run) {
+    const callerSignal = callerSignalOf(signal);
+    if (signalAborted(callerSignal))
+        throw abortedBeforeSendError();
+    let captured;
+    let cancelled = false;
+    let detach = () => { };
+    let unlink = () => { };
+    const got = await settleWithinDeadline(ms, (deadline) => {
+        let pending;
+        try {
+            const linked = linkedAbortSignal(callerSignal, deadline);
+            unlink = linked.dispose;
+            pending = Promise.resolve(run(linked.signal));
+        }
+        catch (error) {
+            captured = { error: markNotSent(error) };
+            throw error;
+        }
+        const verb = pending.catch((error) => {
+            captured = { error: clearNotSent(error) };
+            throw error;
+        });
+        if (callerSignal === undefined)
+            return verb;
+        return new Promise((resolve, reject) => {
+            const onAbort = () => {
+                cancelled = true;
+                reject(new EngineWireCancelledError());
+            };
+            try {
+                callerSignal.addEventListener('abort', onAbort, { once: true });
+                detach = () => quietlyRemoveAbortListener(callerSignal, onAbort);
+            }
+            catch {
+            }
+            if (signalAborted(callerSignal))
+                onAbort();
+            verb.then(resolve, reject);
+        });
+    });
+    detach();
+    unlink();
+    if (got.kind === 'value')
+        return got.value;
+    if (got.kind === 'deadline')
+        throw new EngineWireNoAnswerError(injectedDeadlineDetail(ms));
+    if (cancelled)
+        throw new EngineWireCancelledError();
+    if (captured !== undefined)
+        throw captured.error;
+    throw new Error(got.detail);
+}

package/dist/engineWireSdk.d.ts

@@ -7,6 +7,10 @@ export declare function isLoopbackWireUrl(url: string): boolean;
 export declare function resolveWireAuth(baseUrl: string | undefined, token?: string): WireAuthToken;
 export declare function wireAuthTokenFor(baseUrl: string, token?: string): WireAuthToken;
 export type EngineProbeClient = Pick<AgentClient, 'capabilities' | 'scenarioCapabilities'>;
+export interface EngineWireInjection<C> {
+    client: C;
+    capsBaseUrl?: string;
+}
 export type EngineProbeOpts = {
     fetchImpl?: typeof fetch;
     timeoutMs?: number;