@sema-agent/client-core 0.97.1 → 0.98.0

package/dist/agentsWireCaps.js

@@ -1,21 +1,18 @@
 import { hostEnv } from './hostEnv.js';
-import { ownDataField } from './ownKey.js';
 import { makeEngineWireClient } from './engineWireSdk.js';
 import { frozenSet } from './frozenSet.js';
 import { settleWithinDeadline } from './abortableSleep.js';
+import { engineCapValue, engineCapValueVia, engineCapsGeneration, engineCapsLandingOf, engineCapsSettled, kickEngineCapsProbe } from './engineCapsCache.js';
 import { ruleToolNameVerdictOf } from './protocolSegment.js';
 import { CORE_PROTOCOL_PREFIXES } from './generated/toolNameTables.js';
 import { rosterMountedNames } from './rosterMountedNames.js';
 import { capForDisplay } from './fleetTaskDesc.js';
-import { deniedEntryToolName, mcpEntryReadingOf } from './engineToolDirectory.js';
+import { deniedEntryToolName } from './engineToolDirectory.js';
+import { assemblyRefusal } from './wireFailureShape.js';
 export const MAX_TASK_AGENTS = 32;
-export const MAX_AGENT_NAME_CHARS = 64;
 export const MAX_AGENT_TEXT_CHARS = 4_096;
 export const MAX_AGENT_SYSTEM_PROMPT_CHARS = 65_536;
-export const MAX_AGENT_TOOLS = 64;
-export const MAX_AGENT_TOOL_NAME_CHARS = 128;
 export const MAX_AGENT_SKILL_CONTENT_CHARS = 1_048_576;
-export const MAX_AGENT_MAX_TURNS = 1_000;
 export const TASK_AGENT_WIRE_FIELDS = [
     'name',
     'whenToUse',
@@ -120,10 +117,6 @@ export function projectAgentsForWire(defs, deps) {
         const name = def.agentType;
         if (typeof name !== 'string' || name.length === 0)
             continue;
-        if (name.length > MAX_AGENT_NAME_CHARS) {
-            warnings.push(`agents wire: agent name "${name.slice(0, 40)}…" exceeds ${MAX_AGENT_NAME_CHARS} chars — definition skipped`);
-            continue;
-        }
         if (seen.has(name))
             continue;
         seen.add(name);
@@ -137,27 +130,19 @@ export function projectAgentsForWire(defs, deps) {
                 warnings.push(`agents wire: agent "${name}" description truncated to ${MAX_AGENT_TEXT_CHARS} chars`);
             }
         }
-        const projectTools = (list, label) => {
-            if (!Array.isArray(list) || list.length === 0)
-                return undefined;
-            const kept = list.filter(t => typeof t === 'string' && t.length > 0 && t.length <= MAX_AGENT_TOOL_NAME_CHARS);
-            if (kept.length !== list.length) {
+        const toolEntries = (list, label) => {
+            const entries = list.filter((t) => typeof t === 'string' && t.length > 0);
+            if (entries.length !== list.length)
                 warnings.push(`agents wire: agent "${name}" ${label} had invalid entries — dropped`);
-            }
-            if (kept.length === 0)
-                return undefined;
-            if (kept.length > MAX_AGENT_TOOLS) {
-                warnings.push(`agents wire: agent "${name}" ${label} truncated to ${MAX_AGENT_TOOLS} entries`);
-                return kept.slice(0, MAX_AGENT_TOOLS);
-            }
-            return kept;
+            return entries;
         };
-        const allowTools = projectTools(def.tools, 'tools');
-        if (allowTools)
-            item.allowTools = allowTools;
-        const denyTools = projectTools(def.disallowedTools, 'disallowedTools');
-        if (denyTools)
-            item.denyTools = denyTools;
+        if (Array.isArray(def.tools))
+            item.allowTools = toolEntries(def.tools, 'tools');
+        if (Array.isArray(def.disallowedTools)) {
+            const denyTools = toolEntries(def.disallowedTools, 'disallowedTools');
+            if (denyTools.length > 0)
+                item.denyTools = denyTools;
+        }
         let whoMemo;
         const whoOf = () => {
             if (whoMemo !== undefined)
@@ -172,67 +157,29 @@ export function projectAgentsForWire(defs, deps) {
             whoMemo = `agent "${name}"${typeof source === 'string' && source.length > 0 ? ` (${capForDisplay(source, 120)})` : ''}`;
             return whoMemo;
         };
-        const flaws = agentToolListFlaws([item], deps.toolRoster);
-        const flawedEntries = new Set(flaws.map((f) => `${f.list}\u0000${f.entry}`));
-        const omittedAllowFlaws = new Set(flaws.filter((f) => f.list === 'tools' && f.kind !== 'unjudged').map((f) => f.entry));
+        const rosterInHand = typeof rosterMountedNames(deps.toolRoster) === 'object';
+        const flaws = agentToolListFlaws([item], deps.toolRoster).map((f) => {
+            if (!rosterInHand || f.list !== 'disallowedTools' || f.kind !== 'retired' || f.currentName === undefined || f.toolName !== undefined)
+                return f;
+            const to = f.currentName;
+            if (item.denyTools !== undefined)
+                item.denyTools = item.denyTools.map((e) => (e === f.entry ? to : e));
+            return { ...f, rewritten: true };
+        });
         if (flaws.length > 0) {
             const who = whoOf();
             toolListFlaws.push(...flaws);
-            const denyFlaws = flaws.filter(f => f.list === 'disallowedTools');
-            const withhold = denyFlaws.length > 0 && deps.withholdRefusedDenyLists === true;
-            if (denyFlaws.length > 0) {
-                const what = `its disallowedTools ${denyFlaws.length === 1 ? 'entry' : 'entries'} ${denyFlaws.map(toolListFlawPhrase).join('; ')}`;
-                warnings.push(withhold
-                    ? `agents wire: ${who} is not sent to the engine — ${what}, and this engine refuses to start a run whose agent definitions name a tool that way. Fix the entry in the agent definition; until then this agent is not available.`
-                    : `agents wire: ${who}: ${what} — tool names are matched exactly, so ${denyFlaws.length === 1 ? 'this entry hides' : 'these entries hide'} nothing from the agent, and newer engines refuse to start a run with it. Fix the entry in the agent definition.`);
-            }
-            if (!withhold) {
-                for (const f of flaws) {
-                    if (f.list !== 'tools')
-                        continue;
-                    warnings.push(f.kind === 'unjudged'
-                        ? `agents wire: ${who}: its tools entry ${toolListFlawPhrase(f)} — tool names are matched exactly, so this entry does not give the agent that tool. Fix the entry in the agent definition.`
-                        : `agents wire: ${who}: its tools entry ${toolListFlawPhrase(f)} — tool names are matched exactly, so no tool answers to this entry; it is omitted (newer engines refuse a request whose agent definitions name it). Fix the entry in the agent definition.`);
-                }
-            }
-            if (withhold)
-                continue;
-        }
-        const filterList = (key, label) => {
-            const entries = item[key];
-            if (entries === undefined)
-                return;
-            const kept = [];
-            for (const entry of entries) {
-                if (label === 'tools' && omittedAllowFlaws.has(entry))
-                    continue;
-                if (flawedEntries.has(`${label}\u0000${entry}`)) {
-                    kept.push(entry);
+            for (const f of flaws) {
+                if (f.rewritten !== true)
                     continue;
-                }
-                const toolName = label === 'disallowedTools' ? deniedEntryToolName(entry) : entry;
-                const reading = toolName === undefined ? 'outside' : mcpEntryReadingOf(toolName, deps.toolDirectory);
-                if (reading === 'unanswered') {
-                    warnings.push(`agents wire: ${whoOf()} ${label} entry ${JSON.stringify(entry)} names no tool this deployment answers to — omitted: no MCP server of that name is declared for this session, so there is nothing to ${label === 'tools' ? 'give' : 'hide'}, and newer engines refuse a request whose agent definitions name such a tool. Remove the entry or configure the server.`);
-                    continue;
-                }
-                if (reading === 'unchecked') {
-                    warnings.push(`agents wire: ${whoOf()} ${label} entry ${JSON.stringify(entry)} could not be checked against the MCP servers this session declares — sent as written; if no such server is declared, newer engines refuse the whole request until the entry is removed.`);
-                }
-                kept.push(entry);
-            }
-            if (key === 'allowTools') {
-                item.allowTools = kept;
-            }
-            else if (kept.length > 0) {
-                item.denyTools = kept;
+                warnings.push(`agents wire: ${who}: its disallowedTools entry ${toolListFlawPhrase(f)} — rewritten to ${JSON.stringify(f.currentName)} for this run (this run's tools include none named ${JSON.stringify(f.entry)}). Update the entry in the agent definition.`);
             }
-            else {
-                delete item.denyTools;
+            for (const f of flaws) {
+                if (f.list !== 'tools')
+                    continue;
+                warnings.push(`agents wire: ${who}: its tools entry ${toolListFlawPhrase(f)} — sent as written; tool names are matched exactly, so this entry gives the agent nothing unless this run has a tool with exactly that name. Fix the entry in the agent definition.`);
             }
-        };
-        filterList('denyTools', 'disallowedTools');
-        filterList('allowTools', 'tools');
+        }
         if (def.memory !== undefined) {
             if (typeof def.memory === 'string' && AGENT_MEMORY_WORDS.has(def.memory)) {
                 item.memory = { scopes: [`agent:${name}`], writeScope: `agent:${name}` };
@@ -297,62 +244,58 @@ export function projectAgentsForWire(defs, deps) {
                 item.systemPrompt = prompt;
             }
         }
-        if (def.maxTurns !== undefined) {
-            if (typeof def.maxTurns === 'number' &&
-                Number.isInteger(def.maxTurns) &&
-                def.maxTurns >= 1 &&
-                def.maxTurns <= MAX_AGENT_MAX_TURNS) {
-                item.maxTurns = def.maxTurns;
-            }
-            else {
-                warnings.push(`agents wire: agent "${name}" maxTurns ${String(def.maxTurns)} out of range (1..${MAX_AGENT_MAX_TURNS}) — dropped`);
-            }
-        }
+        if (def.maxTurns !== undefined)
+            item.maxTurns = def.maxTurns;
         out.push(item);
     }
     return { agents: out.length > 0 ? out : undefined, warnings, ...(toolListFlaws.length > 0 ? { toolListFlaws } : {}) };
 }
+function taskAgentsVerdictOf(v) {
+    switch (v.kind) {
+        case 'value':
+            return v.value === true;
+        case 'unobserved':
+        case 'unreadable':
+            return undefined;
+        default:
+            return false;
+    }
+}
+const TASK_AGENTS_CAPS_SETTLE_MS = 3000;
 export async function engineSupportsTaskAgents(baseUrl, opts) {
+    const budget = opts?.timeoutMs ?? TASK_AGENTS_CAPS_SETTLE_MS;
     if (opts?.client !== undefined) {
         const injected = opts.client;
         if (typeof injected?.capabilities !== 'function')
             return undefined;
-        const got = await settleWithinDeadline(opts.timeoutMs ?? 3000, (signal) => injected.capabilities({ signal }));
-        return got.kind === 'value' ? taskAgentsOf(got.value) : undefined;
+        return taskAgentsVerdictOf(await engineCapValueVia(undefined, 'taskAgents', async () => {
+            const got = await settleWithinDeadline(budget, (signal) => injected.capabilities({ signal }));
+            if (got.kind !== 'value')
+                throw new Error('capabilities probe did not settle within its budget');
+            return got.value;
+        }));
     }
     const client = makeEngineWireClient({
         baseUrl,
         ...(opts?.authToken ? { token: opts.authToken } : {}),
         ...(opts?.principal ? { principal: opts.principal } : {}),
-        timeoutMs: opts?.timeoutMs ?? 3000,
+        timeoutMs: budget,
         ...(opts?.fetchImpl ? { fetchImpl: opts.fetchImpl } : {}),
     });
     if (!client)
         return undefined;
-    try {
-        const caps = await client.capabilities();
-        return taskAgentsOf(caps);
-    }
-    catch {
-        return undefined;
-    }
-}
-function taskAgentsOf(caps) {
-    if (caps === null || typeof caps !== 'object')
-        return false;
-    try {
-        return ownDataField(caps, 'taskAgents') === true;
-    }
-    catch {
-        return undefined;
-    }
+    return taskAgentsVerdictOf(await engineCapValueVia(undefined, 'taskAgents', () => client.capabilities()));
 }
 let activeProjector = null;
 let preparedKey = null;
+let preparedCapsGen = null;
 let preparedPromise = null;
 let payload;
-let capsVerdict;
-let settleGeneration = null;
+let currentGeneration = null;
+function concludeGeneration(generation, outcome) {
+    if (generation !== null && preparedPromise === generation && currentGeneration !== null)
+        currentGeneration.outcome = outcome;
+}
 const emittedWarnings = new Set();
 function warnOnce(msg) {
     if (emittedWarnings.has(msg))
@@ -360,45 +303,60 @@ function warnOnce(msg) {
     emittedWarnings.add(msg);
     console.error(`[sema] ${msg}`);
 }
+function capsVerdictAt(baseUrl) {
+    return baseUrl === null ? undefined : taskAgentsVerdictOf(engineCapValue(baseUrl, 'taskAgents'));
+}
+function capsSettledAt(baseUrl) {
+    return baseUrl === null ? Promise.resolve() : engineCapsSettled(baseUrl, { withinMs: TASK_AGENTS_CAPS_SETTLE_MS });
+}
+function kickTaskAgentsCaps(cfg) {
+    if (engineCapsLandingOf(cfg.baseUrl).kind !== 'not_landed')
+        return;
+    const client = makeEngineWireClient({
+        baseUrl: cfg.baseUrl,
+        ...(cfg.authToken ? { token: cfg.authToken } : {}),
+        ...(cfg.principal ? { principal: cfg.principal } : {}),
+        timeoutMs: TASK_AGENTS_CAPS_SETTLE_MS,
+    });
+    if (!client)
+        return;
+    kickEngineCapsProbe(cfg.baseUrl, () => client.capabilities());
+}
+function watchCapsVerdict(baseUrl) {
+    void engineCapsSettled(baseUrl).then(() => {
+        if (preparedKey !== baseUrl || capsVerdictAt(baseUrl) !== false)
+            return;
+        payload = undefined;
+        concludeGeneration(preparedPromise, 'ok');
+        currentGeneration?.settle();
+    });
+}
 function applyProjectionIfCurrent(generation, projected) {
     if (generation === null || preparedPromise !== generation)
         return false;
-    const accepted = capsVerdict !== false;
+    const accepted = capsVerdictAt(preparedKey) !== false;
     if (accepted) {
         for (const w of projected.warnings)
             warnOnce(w);
         payload = projected.agents;
     }
-    settleGeneration?.();
+    else {
+        payload = undefined;
+    }
+    concludeGeneration(generation, 'ok');
+    currentGeneration?.settle();
     return accepted;
 }
-function startCapsProbe(cfg) {
-    const land = (verdict) => {
-        if (capsVerdict !== probe)
-            return verdict;
-        capsVerdict = verdict;
-        if (verdict === false) {
-            payload = undefined;
-            settleGeneration?.();
-        }
-        return verdict;
-    };
-    const probe = engineSupportsTaskAgents(cfg.baseUrl, {
-        authToken: cfg.authToken,
-        principal: cfg.principal,
-    }).then(land, () => land(undefined));
-    capsVerdict = probe;
-    return probe;
-}
-function capsSettled() {
-    return capsVerdict instanceof Promise ? capsVerdict : Promise.resolve();
-}
-async function runPrepare(cfg, projector, probe, generation) {
+async function runPrepare(cfg, projector, generation) {
     try {
-        const [caps, projected] = await Promise.all([probe, projector()]);
-        if (caps === false) {
-            if (projected.agents && preparedKey === cfg.baseUrl) {
-                warnOnce(`agents wire: this engine does not support per-task custom agents (capabilities.taskAgents is not true: the engine does not report it, or this deployment turns it off, for example a multi-tenant one; this client cannot tell which) — ${projected.agents.length} custom agent definition(s) will NOT be sent`);
+        const [, projected] = await Promise.all([capsSettledAt(cfg.baseUrl), projector()]);
+        if (capsVerdictAt(cfg.baseUrl) === false) {
+            if (preparedKey === cfg.baseUrl) {
+                payload = undefined;
+                concludeGeneration(generation, 'ok');
+                if (projected.agents) {
+                    warnOnce(`agents wire: this engine does not support per-task custom agents (capabilities.taskAgents is not true: the engine does not report it, or this deployment turns it off, for example a multi-tenant one; this client cannot tell which) — ${projected.agents.length} custom agent definition(s) will NOT be sent`);
+                }
             }
             return;
         }
@@ -411,29 +369,33 @@ async function runPrepare(cfg, projector, probe, generation) {
     catch (e) {
         if (preparedPromise === generation)
             payload = undefined;
+        concludeGeneration(generation, 'failed');
         if (hostEnv().SEMA_DEBUG) {
-            console.error('[sema] agents wire prepare soft-failed (no agents stamped):', e);
+            console.error('[sema] agents wire prepare failed (the readiness gate refuses this turn):', e);
         }
     }
 }
 export function prepareTaskAgentsWireWith(cfg, projector) {
     const key = cfg.baseUrl;
-    if (preparedPromise && preparedKey === key)
+    kickTaskAgentsCaps(cfg);
+    const capsGen = engineCapsGeneration(key);
+    if (preparedPromise && preparedKey === key && preparedCapsGen === capsGen)
         return preparedPromise;
     preparedKey = key;
+    preparedCapsGen = capsGen;
     activeProjector = projector;
-    const probe = startCapsProbe(cfg);
-    return startGeneration(generation => runPrepare(cfg, projector, probe, generation));
+    watchCapsVerdict(key);
+    return startGeneration(generation => runPrepare(cfg, projector, generation));
 }
 function startGeneration(run) {
     let settle;
     const generation = new Promise(resolve => {
         settle = resolve;
     });
-    const superseded = settleGeneration;
+    const superseded = currentGeneration;
     preparedPromise = generation;
-    settleGeneration = settle;
-    superseded?.();
+    currentGeneration = { settle, outcome: undefined };
+    superseded?.settle();
     void run(generation).then(settle, settle);
     return generation;
 }
@@ -445,28 +407,36 @@ export function invalidateTaskAgentsWire() {
     return startGeneration(generation => runReproject(projector, generation));
 }
 async function runReproject(projector, generation) {
+    const base = preparedKey;
     try {
         let projected;
         try {
             projected = await projector();
         }
         catch (e) {
+            concludeGeneration(generation, 'failed');
             if (hostEnv().SEMA_DEBUG) {
-                console.error('[sema] agents wire re-project soft-failed (no agents stamped until the next successful projection):', e);
+                console.error('[sema] agents wire re-project failed (the readiness gate refuses until a projection succeeds):', e);
             }
             return;
         }
-        await capsSettled();
+        await capsSettledAt(base);
         applyProjectionIfCurrent(generation, projected);
     }
     catch {
+        concludeGeneration(generation, 'failed');
     }
 }
 export async function awaitTaskAgentsWire(timeoutMs = 4000) {
     if (!preparedPromise)
-        return;
-    if (capsVerdict === false)
-        return;
+        return taskAgentsReady();
+    if (capsVerdictAt(preparedKey) === false)
+        return taskAgentsReady();
+    const projector = activeProjector;
+    if (currentGeneration?.outcome === 'failed' && projector !== null) {
+        payload = undefined;
+        void startGeneration(generation => runReproject(projector, generation));
+    }
     let timeoutHandle;
     let timedOut = false;
     const deadline = new Promise(resolve => {
@@ -486,33 +456,56 @@ export async function awaitTaskAgentsWire(timeoutMs = 4000) {
         if (timeoutHandle !== undefined)
             clearTimeout(timeoutHandle);
     }
+    if (preparedPromise === null || capsVerdictAt(preparedKey) === false)
+        return taskAgentsReady();
+    const outcome = currentGeneration?.outcome;
+    if (outcome === 'ok')
+        return taskAgentsReady();
+    if (outcome === 'failed')
+        return Object.freeze({ ok: false, refusal: assemblyRefusal('agents_projection_failed') });
+    kickTaskAgentsRefresh();
+    return Object.freeze({ ok: false, refusal: assemblyRefusal('agents_not_ready') });
+}
+function taskAgentsReady() {
+    return Object.freeze({ ok: true });
+}
+function kickTaskAgentsRefresh() {
+    const projector = activeProjector;
+    if (!preparedPromise || projector === null)
+        return false;
+    const generation = preparedPromise;
+    const base = preparedKey;
+    let refreshing;
+    try {
+        refreshing = projector();
+    }
+    catch {
+        return false;
+    }
+    void refreshing
+        .then(async (p) => {
+        await capsSettledAt(base);
+        applyProjectionIfCurrent(generation, p);
+    })
+        .catch(() => { });
+    return true;
 }
 export function taskAgentsField() {
-    const current = payload;
-    if (preparedPromise && capsVerdict !== false && activeProjector) {
-        const generation = preparedPromise;
-        let refreshing;
-        try {
-            refreshing = activeProjector();
-        }
-        catch {
-            return current ? { agents: current } : {};
-        }
-        void refreshing
-            .then(async (p) => {
-            await capsSettled();
-            applyProjectionIfCurrent(generation, p);
-        })
-            .catch(() => { });
+    const base = preparedKey;
+    if (capsVerdictAt(base) === false) {
+        payload = undefined;
+        return {};
     }
+    const current = payload;
+    kickTaskAgentsRefresh();
     return current ? { agents: current } : {};
 }
 export function _resetAgentsWireForTest() {
     activeProjector = null;
     preparedKey = null;
+    preparedCapsGen = null;
     preparedPromise = null;
-    settleGeneration = null;
+    currentGeneration = null;
     payload = undefined;
-    capsVerdict = undefined;
     emittedWarnings.clear();
 }

package/dist/approvalDecidedByCapability.d.ts

@@ -9,9 +9,5 @@ export type ApprovalDecidedByReading = {
     value: true;
 };
 export declare function projectApprovalDecidedByCapability(caps: unknown): ApprovalDecidedByReading | undefined;
-export declare function noteEngineCapsForApprovalDecidedBy(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedApprovalDecidedBy(baseUrl?: string | undefined): ApprovalDecidedByReading;
 export declare function approvalDecidedByAdmitted(reading: ApprovalDecidedByReading | undefined): boolean;
-export declare function __resetApprovalDecidedByReadingsForTests(): void;

package/dist/approvalDecidedByCapability.js

@@ -18,9 +18,6 @@ const reader = createEngineCapReader({
     name: 'approvalDecidedBy',
     project: projectApprovalDecidedByCapability,
 });
-export function noteEngineCapsForApprovalDecidedBy(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedApprovalDecidedBy(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -36,6 +33,3 @@ export function approvalDecidedByAdmitted(reading) {
         return false;
     }
 }
-export function __resetApprovalDecidedByReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/approvalsStreamLiveCapability.d.ts

@@ -9,10 +9,6 @@ export type ApprovalsStreamLiveReading = {
     live: boolean;
 };
 export declare function projectApprovalsStreamLiveCapability(caps: unknown): ApprovalsStreamLiveReading | undefined;
-export declare function noteEngineCapsForApprovalsStreamLive(baseUrl: string, caps: unknown, opts?: {
-    generation?: number;
-}): void;
 export declare function observedApprovalsStreamLive(baseUrl?: string | undefined): ApprovalsStreamLiveReading;
 export declare function livePendingNeedsReconcile(reading: ApprovalsStreamLiveReading): boolean;
 export declare function approvalsStreamLiveDoctorDetail(reading: ApprovalsStreamLiveReading): string;
-export declare function __resetApprovalsStreamLiveReadingsForTests(): void;

package/dist/approvalsStreamLiveCapability.js

@@ -22,9 +22,6 @@ const reader = createEngineCapReader({
     name: 'approvalsStreamLive',
     project: projectApprovalsStreamLiveCapability,
 });
-export function noteEngineCapsForApprovalsStreamLive(baseUrl, caps, opts) {
-    reader.note(baseUrl, caps, opts);
-}
 export function observedApprovalsStreamLive(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
@@ -45,6 +42,3 @@ export function approvalsStreamLiveDoctorDetail(reading) {
                 : 'live approval push off on this deployment (no checkpoint store or tool approvals disabled; the engine reports one bit for both, so this client cannot tell which) — suspended asks are only visible through the reconcile cadence, so the client polls for them';
     }
 }
-export function __resetApprovalsStreamLiveReadingsForTests() {
-    reader.__resetForTests();
-}

package/dist/assistantInbox.d.ts

@@ -0,0 +1,34 @@
+import type { AgentClient } from '@sema-agent/sdk';
+export type AssistantInboxVerb = Pick<AgentClient['assistant'], 'inbox'>;
+export interface AssistantInboxEntry {
+    readonly sessionId: string;
+    readonly scope?: string;
+    readonly gateKind?: string;
+    readonly severity?: 1 | 2 | 3 | 4 | 5;
+    readonly spentMicroUsd?: number;
+    readonly deadlineMs?: number;
+    readonly createdAtMs?: number;
+    readonly objective?: string;
+    readonly inputPreview?: string;
+    readonly requiresRealApproval?: true;
+    readonly mandated?: true;
+    readonly hasBidiControls?: true;
+}
+export type AssistantInboxUnavailableReason = 'unauthorized' | 'unreadable' | 'failed';
+export type AssistantInboxReading = {
+    readonly kind: 'present';
+    readonly entries: readonly AssistantInboxEntry[];
+    readonly dropped: number;
+} | {
+    readonly kind: 'unavailable';
+    readonly reason: AssistantInboxUnavailableReason;
+    readonly status?: number;
+    readonly errorCode?: string;
+} | {
+    readonly kind: 'not-reported';
+    readonly via: 'lane-absent' | 'unarmed';
+};
+export declare function isAssistantLaneAbsent(err: {} | null | undefined): boolean;
+export declare function readAssistantInbox(assistant: AssistantInboxVerb | null | undefined, opts?: {
+    readonly signal?: AbortSignal | undefined;
+}): Promise<AssistantInboxReading>;