@sema-agent/client-core 0.84.0 → 0.85.0

package/dist/engineNoticeCodes.js

@@ -1,169 +1,24 @@
-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;
+}
 export function engineNoticeInCatalog(code) {
-    return typeof code === 'string' && CATALOG.has(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) {
-    const row = typeof code === 'string' && Object.hasOwn(ENGINE_NOTICE_AUDIENCE, code)
-        ? ENGINE_NOTICE_AUDIENCE[code]
-        : undefined;
-    return row ?? 'operator';
+    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))
@@ -348,3 +203,104 @@ function readRootGrantNoticeOf(notice) {
     const reason = str(o.reason);
     return { outcome: 'rejected', toolCallId, ...(reason !== undefined ? { reason } : {}), ...(sessionId !== undefined ? { sessionId } : {}) };
 }
+function ownPathOrNull(o, key) {
+    if (!Object.hasOwn(o, key))
+        return undefined;
+    const v = o[key];
+    if (v === null)
+        return null;
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+export function readInstructionsSourceChanged(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    try {
+        const n = notice;
+        if (n.code !== 'instructions.source_changed')
+            return undefined;
+        const d = n.detail;
+        if (typeof d !== 'object' || d === null || Array.isArray(d))
+            return undefined;
+        const o = d;
+        const previous = ownPathOrNull(o, 'previous');
+        const current = ownPathOrNull(o, 'current');
+        const sessionId = typeof o.sessionId === 'string' && o.sessionId.length > 0 ? o.sessionId : undefined;
+        if (previous === undefined || current === undefined || sessionId === undefined)
+            return undefined;
+        return { previous, current, sessionId };
+    }
+    catch {
+        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,
+    'config.durable_gate_unavailable': readDurableGateUnavailable,
+    'skills.listing_truncated': readSkillsListingTruncated,
+    'mcp.server_redialed': readMcpServerRedialed,
+    'instructions.source_changed': readInstructionsSourceChanged,
+    'approval.read_root_granted': readReadRootGrantNotice,
+    'approval.read_root_grant_rejected': readReadRootGrantNotice,
+    'session.records_skipped': readSessionRecordsSkipped,
+});
+const _factReaderTablePin = true;
+void _factReaderTablePin;
+export function readEngineNoticeFacts(notice) {
+    if (typeof notice !== 'object' || notice === null || Array.isArray(notice))
+        return undefined;
+    let code;
+    let detail;
+    try {
+        code = notice.code;
+        if (typeof code !== 'string' || !Object.hasOwn(ENGINE_NOTICE_FACT_READERS, code))
+            return undefined;
+        detail = notice.detail;
+    }
+    catch {
+        return undefined;
+    }
+    const k = code;
+    const facts = ENGINE_NOTICE_FACT_READERS[k]({ code: k, detail });
+    if (facts === undefined)
+        return undefined;
+    return { code: k, audience: noticeAudienceOf(k), facts };
+}

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>;