@sema-agent/client-core 0.97.0 → 0.98.0

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -5,10 +5,11 @@ import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../../gateOutcome.js'
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
 import { projectHandsSection } from '../../handsSeam.js';
 import { readMcpLiveness } from '../../mcpLiveness.js';
-import { markMcpSectionDroppedNamedRows, readFrameTrueMark } from '../../ownKey.js';
+import { contextUsageReadingOf, markMcpSectionDroppedNamedRows, readFrameTrueMark } from '../../ownKey.js';
 import { SEGMENT_END_IDENTITY_KEYS, stripToolUseSideChannels } from '../types.js';
 import { frozenSet } from '../../frozenSet.js';
 import { isCoreWorkflowRunTerminal } from '../../terminalStatuses.js';
+import { envelopeUuidOf, mintEngineRowRef, readBoundRun, wireEventIdOf } from '../../engineRowRef.js';
 function armBody(body) {
     return body;
 }
@@ -23,6 +24,7 @@ export const INTERNAL_SDK_ARM_TYPES = frozenSet([
     'prompt_assembled',
     'workflow_complete',
     'tool_end_result',
+    'terminal_fact',
     'retry_status',
     'task_progress',
     'task_notification',
@@ -69,7 +71,22 @@ const dropped = (why, type) => ({ kind: 'dropped', why, type });
 function assertNeverArm(_ev) {
 }
 export function eventToSdkMessage(ev, ctx) {
+    return withEngineIdentity(projectEvent(ev, ctx), ev, ctx);
+}
+function withEngineIdentity(p, ev, ctx) {
+    if (p.kind !== 'message')
+        return p;
+    const eventId = wireEventIdOf(ev);
+    if (eventId === undefined)
+        return p;
+    const env = p.message;
+    const ref = mintEngineRowRef(eventId, ctx.boundRun === undefined ? undefined : readBoundRun(() => ctx.boundRun?.(ev)));
+    return projected(Object.assign({}, env, { uuid: envelopeUuidOf(eventId, env.type), _sema_engine_ref: ref }));
+}
+function projectEvent(ev, ctx) {
     switch (ev.type) {
+        case 'task_started':
+            return dropped('unsupported_arm', 'task_started');
         case 'text_end':
             return textEndProjection(ev, ctx);
         case 'reasoning_end':
@@ -178,7 +195,6 @@ export function eventToSdkMessage(ev, ctx) {
             const toolEndGatedCallId = ev.gatedCallId;
             const collateralAbort = ev._sema_collateral_abort;
             const denialKind = ccToolDenialKindForToolEnd(ev);
-            const denialUnclassified = denialKind === undefined && toolEndGate?.disposition.kind === 'denied';
             const toolEndNotExecuted = readFrameTrueMark(ev, 'notExecuted');
             return projected(stamp(ctx, armBody({
                 type: 'tool_end_result',
@@ -201,7 +217,6 @@ export function eventToSdkMessage(ev, ctx) {
                     : {}),
                 ...(collateralAbort === true ? { _sema_collateral_abort: true } : {}),
                 ...(denialKind !== undefined ? { _sema_denial_kind: denialKind } : {}),
-                ...(denialUnclassified ? { _sema_denial_unclassified: true } : {}),
                 ...(toolEndNotExecuted ? { notExecuted: true } : {}),
                 ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
                 ...(ev.parentToolCallId !== undefined
@@ -210,19 +225,18 @@ export function eventToSdkMessage(ev, ctx) {
             })));
         }
         case 'status': {
-            const st2 = ev;
             const num = (v) => typeof v === 'number' && Number.isFinite(v) ? v : undefined;
             const attempt = num(ev.attempt);
             const maxRetries = num(ev.maxRetries);
             const retryInMs = num(ev.retryInMs);
-            const retryAtMs = num(st2.retryAtMs);
-            const errorStatus = num(st2.errorStatus);
-            const elapsedMs = num(st2.elapsedMs);
-            const timeoutMs = num(st2.timeoutMs);
+            const retryAtMs = num(ev.retryAtMs);
+            const errorStatus = num(ev.errorStatus);
+            const elapsedMs = num(ev.elapsedMs);
+            const timeoutMs = num(ev.timeoutMs);
             const errClass = typeof ev.errClass === 'string' && ev.errClass.length > 0 ? ev.errClass : undefined;
             const nonEmptyStr = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
-            const providerCondition = nonEmptyStr(st2.providerCondition);
-            const providerConditionSource = nonEmptyStr(st2.providerConditionSource);
+            const providerCondition = nonEmptyStr(ev.providerCondition);
+            const providerConditionSource = nonEmptyStr(ev.providerConditionSource);
             return projected(stamp(ctx, armBody({
                 type: 'retry_status',
                 phase: ev.phase,
@@ -648,33 +662,12 @@ function contextUsageProjection(ev, ctx) {
     const { identity, bad } = identityOrMalformed(ev, 'context_usage');
     if (bad !== null)
         return bad;
-    const fin = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
-    const usedTokens = fin(ev.usedTokens);
-    const windowTokens = fin(ev.windowTokens);
-    const compactAtTokens = fin(ev.compactAtTokens);
-    let sections;
-    if (Array.isArray(ev.sections)) {
-        const rows = [];
-        for (const r of ev.sections) {
-            if (typeof r !== 'object' || r === null || Array.isArray(r))
-                continue;
-            const o = r;
-            const tokens = fin(o.tokens);
-            if (typeof o.id !== 'string' || o.id.length === 0 || tokens === undefined)
-                continue;
-            rows.push({ id: o.id, tokens, ...(typeof o.kind === 'string' && o.kind.length > 0 ? { kind: o.kind } : {}) });
-        }
-        if (rows.length > 0)
-            sections = rows;
-    }
-    if (usedTokens === undefined && windowTokens === undefined && compactAtTokens === undefined && sections === undefined)
+    const reading = contextUsageReadingOf(ev);
+    if (reading === undefined)
         return nothing('empty_payload');
     return projected(internalArmExit(stamp(ctx, armBody({
         type: 'context_usage',
-        ...(usedTokens !== undefined ? { usedTokens } : {}),
-        ...(windowTokens !== undefined ? { windowTokens } : {}),
-        ...(compactAtTokens !== undefined ? { compactAtTokens } : {}),
-        ...(sections !== undefined ? { sections } : {}),
+        ...reading,
         ...identity,
     }))));
 }

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -4,7 +4,8 @@ import { putOwnKey, readFrameStringKey } from '../../ownKey.js';
 import { REDACTION_MARKER_PREFIX, washCredentials } from '../../displayUntrusted.js';
 import { readEffectiveReasoning, readEffectiveMemoryScopes } from '../../effectiveFacts.js';
 import { isReviewPark, readRunTerminal, runTerminalCode, runTerminalGateToolName, } from '../../runTerminal.js';
-import { doneResultView } from '../../replayBody.js';
+import { doneResultView, isReplayedTerminal } from '../../replayBody.js';
+import { terminalRunIdOf, terminalUuidOf } from '../../engineRowRef.js';
 import { toCcModelUsage } from './turnUsageToModelUsage.js';
 import { LIMITS_MAX_COST_EXCEEDED, LIMITS_MAX_TOKENS_EXCEEDED, LIMITS_MAX_TURNS_EXCEEDED, LIMITS_MAX_WALLTIME_EXCEEDED, OUTPUT_INVALID, isCorruptSessionCode, idempotencyPayloadMismatchContent, isIdempotencyPayloadMismatchCode, isRewindFamilyCode, } from '../../engineErrorCodes.js';
 import { corruptSessionContent } from '../../corruptSessionCopy.js';
@@ -497,7 +498,7 @@ function cutoffParts(r, message, fallbackMessage, code) {
 }
 function errorResult(ctx, parts) {
     return stamp(ctx, {
-        uuid: undefined,
+        uuid: parts.uuid,
         session_id: undefined,
         type: 'result',
         subtype: parts.subtype,
@@ -525,6 +526,10 @@ function errorResult(ctx, parts) {
     });
 }
 export function doneToSdkResult(ev, ctx, observed) {
+    const msg = doneToSdkResultBody(ev, ctx, observed);
+    return isReplayedTerminal(ev) ? Object.assign({}, msg, { _sema_replay: true }) : msg;
+}
+function doneToSdkResultBody(ev, ctx, observed) {
     const view = doneResultView(ev.result);
     const rRaw = view.engine;
     const rec = typeof rRaw === 'object' && rRaw !== null ? rRaw : {};
@@ -539,7 +544,9 @@ export function doneToSdkResult(ev, ctx, observed) {
     const errorCode = runTerminalCode(terminal);
     const degraded = degradedOf(r);
     const parkFailedReason = readFrameStringKey(ev, '_sema_park_failed_reason');
-    const errorBase = { durationMs, stats, model: r.model, errorCode, degraded, observed, facts: effectiveFactParts(rec), parkFailedReason, abortCause: abortCauseWordOf(ev) };
+    const terminalRunId = terminalRunIdOf(ev);
+    const resultUuid = terminalRunId === undefined ? undefined : terminalUuidOf(terminalRunId, 'result');
+    const errorBase = { uuid: resultUuid, durationMs, stats, model: r.model, errorCode, degraded, observed, facts: effectiveFactParts(rec), parkFailedReason, abortCause: abortCauseWordOf(ev) };
     if (terminal?.kind === 'failed') {
         const failedCode = terminal.code;
         const failedMessage = terminal.message;
@@ -613,7 +620,7 @@ export function doneToSdkResult(ev, ctx, observed) {
         });
     }
     return stamp(ctx, {
-        uuid: undefined,
+        uuid: resultUuid,
         session_id: undefined,
         type: 'result',
         subtype: 'success',

package/dist/adapter/downstream/turnUsageToModelUsage.d.ts

@@ -12,10 +12,13 @@ export interface EngineUsageLike {
     readonly costMicroUsd?: number | undefined;
     readonly webSearchRequests?: number | undefined;
 }
-export type SemaModelUsage = ModelUsage & {
+export type SemaModelUsage = ModelUsage & SemaModelUsageAbsenceBits;
+export interface SemaModelUsageAbsenceBits {
     readonly _sema_cost_absent?: true;
     readonly _sema_web_search_requests_absent?: true;
-};
+    readonly _sema_context_window_absent?: true;
+    readonly _sema_max_output_tokens_absent?: true;
+}
 export declare function toCcModelUsage(raw: EngineUsageLike): SemaModelUsage;
 export declare function turnUsageToModelUsage(usage: TurnUsage): SemaModelUsage;
 export {};

package/dist/adapter/downstream/turnUsageToModelUsage.js

@@ -15,6 +15,8 @@ export function toCcModelUsage(raw) {
         maxOutputTokens: 0,
         ...(costPriced ? {} : { _sema_cost_absent: true }),
         ...(webSearchKnown ? {} : { _sema_web_search_requests_absent: true }),
+        _sema_context_window_absent: true,
+        _sema_max_output_tokens_absent: true,
     };
 }
 export function turnUsageToModelUsage(usage) {

package/dist/adapter/runStream.js

@@ -2,13 +2,16 @@ import { eventSeq, stamp, } from './types.js';
 import { eventToSdkMessage, turnEndUsage } from './downstream/eventToSdkMessage.js';
 import { turnUsageToModelUsage } from './downstream/turnUsageToModelUsage.js';
 import { readRunCostFacts, terminalToSdkResult, TOOL_INPUT_JOIN_MAX_CALLS } from './downstream/terminalToSdkResult.js';
+import { terminalRunIdOf, terminalUuidOf } from '../engineRowRef.js';
 import { coerceOutput, publishSubagentContentEvent } from '../subagentContentStore.js';
 import { OUTPUT_INVALID, activeRunBusyCarrierOf, classifyActiveRunBusy, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
-import { doneResultView } from '../replayBody.js';
+import { doneResultView, isReplayedTerminal } from '../replayBody.js';
+import { readFrameStringKey } from '../ownKey.js';
 import { corruptSessionContent } from '../corruptSessionCopy.js';
 import { abortCauseNoteOf } from '../runCancelContext.js';
 import { classifyToolHistoryMismatch, noteToolHistoryTerminal, openToolHistoryGeneration, TOOL_HISTORY_REWIND_SENTENCE, toolHistoryMismatchRowKey, toolHistoryRepeatSentence, toolHistoryRewindOffered, } from '../toolHistoryMismatch.js';
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
+import { parkHeldCallIdOf } from '../engineRowRef.js';
 import { providerRejectionResend } from '../providerRejection.js';
 import { washCredentials } from '../displayUntrusted.js';
 import { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD, runBlockedText } from '../promptBlockedCopy.js';
@@ -108,9 +111,9 @@ export function isModelOutputErrorRowText(text) {
     return text.trimStart().startsWith(`${MODEL_OUTPUT_ERROR_PREFIX}:`);
 }
 export const OUTCOME_UNKNOWN_ROW_PREFIX = 'Outcome unknown';
-function syntheticTerminalRow(ctx, text, historyKey, resend) {
+function syntheticTerminalRow(ctx, identity, replayed, text, historyKey, resend) {
     return stamp(ctx, {
-        uuid: undefined,
+        uuid: identity.runId === undefined ? undefined : terminalUuidOf(identity.runId, identity.label),
         session_id: undefined,
         type: 'assistant',
         message: { role: 'assistant', model: '<synthetic>', content: [{ type: 'text', text: washCredentials(text) }] },
@@ -118,12 +121,9 @@ function syntheticTerminalRow(ctx, text, historyKey, resend) {
         _sema_api_error_message: true,
         ...(historyKey !== undefined ? { _sema_tool_history_mismatch: historyKey } : {}),
         ...(resend !== undefined ? { _sema_provider_rejection_resend: { resend: resend.resend, text: resend.text, kind: resend.kind } } : {}),
+        ...(replayed ? { _sema_replay: true } : {}),
     });
 }
-function engineRunIdOf(result) {
-    const v = result?.runId;
-    return typeof v === 'string' && v.length > 0 ? v : undefined;
-}
 function engineResultOf(result) {
     const v = doneResultView(result);
     return v.replay ? (v.engine ?? result) : result;
@@ -142,6 +142,19 @@ export function isGovernanceTerminal(input) {
         return true;
     return input.errorCode === OUTPUT_INVALID;
 }
+function terminalFactOf(ev, doneTerminal) {
+    const engine = ev.type === 'done' ? engineResultOf(ev.result) : ev;
+    const taskId = readFrameStringKey(engine, 'taskId');
+    if (ev.type !== 'done' || doneTerminal?.kind !== 'paused')
+        return { type: 'terminal_fact', ...(taskId !== undefined ? { taskId } : {}) };
+    const checkpointId = doneTerminal.checkpointId;
+    const heldCallId = parkHeldCallIdOf(engine);
+    return {
+        type: 'terminal_fact',
+        ...(taskId !== undefined ? { taskId } : {}),
+        paused: { ...(checkpointId !== undefined ? { checkpointId } : {}), ...(heldCallId !== undefined ? { heldCallId } : {}) },
+    };
+}
 function terminalRowFacts(ev) {
     const doneTerminal = ev.type === 'done' ? readRunTerminal(ev.result) : null;
     const errTextRaw = ev.type === 'failed'
@@ -625,6 +638,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
         if (ev.type === 'done' || ev.type === 'failed') {
             const rowFacts = terminalRowFacts(ev);
             const doneTerminal = rowFacts.doneTerminal;
+            const terminalRunId = terminalRunIdOf(ev);
+            const replayed = isReplayedTerminal(ev);
             const errText = rowFacts.errText;
             if (errText) {
                 const busy = rowFacts.busy;
@@ -655,8 +670,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     sessionId: historyEchoedSid ?? ctx.sessionId,
                     sessionEchoed: historyEchoedSid !== undefined,
                     generation: historyGeneration,
-                    runId: ev.type === 'done' ? engineRunIdOf(engineResultOf(ev.result)) : undefined,
-                    replay: ev.type === 'done' && ev.replay === true,
+                    runId: terminalRunId,
+                    replay: replayed,
                     mismatch: historyMismatch,
                 });
                 const rewindOffered = historyMismatch !== null && ctx.lane !== 'print' && ctx.lane !== 'utility' && toolHistoryRewindOffered(ctx.offersRewind);
@@ -665,7 +680,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     : '';
                 const resend = historyTerminal.detail !== undefined ? providerRejectionResend(historyTerminal.detail, historyTerminal.carrier) : undefined;
                 const resendLine = resend !== undefined ? `\n${resend.text}` : '';
-                yield syntheticTerminalRow(ctx, `${sessionUnreadable ? `${rowText}\n${corruptSessionContent()}` : rowText}${abortNote !== undefined ? `\n${abortNote}` : ''}${rewindLine}${resendLine}`, historyMismatch === null ? undefined : toolHistoryMismatchRowKey(historyMismatch, historyRepeat, rewindOffered), resend);
+                yield syntheticTerminalRow(ctx, { runId: terminalRunId, label: 'terminal-row' }, replayed, `${sessionUnreadable ? `${rowText}\n${corruptSessionContent()}` : rowText}${abortNote !== undefined ? `\n${abortNote}` : ''}${rewindLine}${resendLine}`, historyMismatch === null ? undefined : toolHistoryMismatchRowKey(historyMismatch, historyRepeat, rewindOffered), resend);
             }
             else {
                 const echoedSid = ev.type === 'done' ? engineSessionIdOf(engineResultOf(ev.result)) : undefined;
@@ -673,8 +688,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     sessionId: echoedSid ?? ctx.sessionId,
                     sessionEchoed: echoedSid !== undefined,
                     generation: historyGeneration,
-                    runId: ev.type === 'done' ? engineRunIdOf(engineResultOf(ev.result)) : undefined,
-                    replay: ev.type === 'done' && ev.replay === true,
+                    runId: terminalRunId,
+                    replay: replayed,
                     mismatch: null,
                 });
             }
@@ -707,8 +722,9 @@ async function* runStreamInner(events, ctx, handle = {}) {
             if (outcome === 'unknown') {
                 const errs = resultFrame.errors;
                 const sentence = Array.isArray(errs) && typeof errs[0] === 'string' ? errs[0] : 'the run ended without a terminal record this client can read';
-                yield syntheticTerminalRow(ctx, `${OUTCOME_UNKNOWN_ROW_PREFIX}: ${sentence}`);
+                yield syntheticTerminalRow(ctx, { runId: terminalRunId, label: 'outcome-unknown' }, replayed, `${OUTCOME_UNKNOWN_ROW_PREFIX}: ${sentence}`);
             }
+            yield terminalFactOf(ev, doneTerminal);
             yield resultFrame;
             return;
         }

package/dist/adapter/types.d.ts

@@ -1,11 +1,10 @@
-import type { AgentEvent } from '@sema-agent/sdk';
+import type { AgentEvent, StampedAgentEvent } from '@sema-agent/sdk';
 import type { ModelUsage, SDKMessage } from '@sema-agent/agent-types';
 import type { ChromeEvent } from '../seam.js';
 import type { RequestLane } from '../request/taskRequest.js';
+import type { EngineBoundRun } from '../engineRowRef.js';
 export type { ModelUsage, SDKMessage };
-export type StampedAgentEvent = AgentEvent & {
-    id?: string;
-};
+export type { StampedAgentEvent };
 export declare function eventSeq(ev: AgentEvent): string | undefined;
 export declare function uuid(): string;
 export interface DroppedFrameInfo {
@@ -23,6 +22,7 @@ export interface EmitContext {
     };
     emitChrome?(event: ChromeEvent): void | Promise<void>;
     onDroppedFrame?(info: DroppedFrameInfo): void;
+    boundRun?(frame: AgentEvent): EngineBoundRun | undefined;
 }
 export declare function stamp<T extends {
     uuid?: string | undefined;

package/dist/agentSession/backgroundView.js

@@ -1,4 +1,5 @@
 import { abortableSleep } from '../abortableSleep.js';
+import { isAssistantLaneAbsent } from '../assistantInbox.js';
 import { errCodes } from '../controlRouter.js';
 import { engineWireDebugEnabled } from '../engineWireTarget.js';
 import { hostLog } from '../host.js';
@@ -145,7 +146,7 @@ export function createBackgroundView(client, opts) {
         }
         catch (err) {
             debugLog(`assistant.tasks degrade: ${String(err)}`);
-            const health = isNotImplemented(err)
+            const health = isAssistantLaneAbsent(err)
                 ? 'not-configured'
                 : isReadCredentialRefusal(err)
                     ? 'unauthorized'

package/dist/agentSession/engineAgentRegistryRead.d.ts

@@ -1,4 +1,4 @@
-import type { AgentClient, Capabilities } from '@sema-agent/sdk';
+import type { AgentClient } from '@sema-agent/sdk';
 import type { EngineAgentRegistryListing, EngineAgentRegistryRowView } from '../engineAgentAbsence.js';
 export interface EngineAgentRegistryClient {
     readonly sessions: Pick<AgentClient['sessions'], 'background'>;
@@ -13,6 +13,6 @@ export interface RegistryListingProvenance {
 }
 export declare function registryListingProvenanceOf(listing: EngineAgentRegistryListing | null | undefined): RegistryListingProvenance | undefined;
 export declare function isEngineAgentRegistryListingSuperseded(listing: EngineAgentRegistryListing | null | undefined): boolean;
-export declare function readEngineAgentRegistry(client: EngineAgentRegistryClient, sessionId: string, caps: Pick<Capabilities, 'background'> | null | undefined, opts?: {
+export declare function readEngineAgentRegistry(client: EngineAgentRegistryClient, sessionId: string, capsBaseUrl: string | undefined, opts?: {
     readonly signal?: AbortSignal;
 }): Promise<EngineAgentRegistryListing>;

package/dist/agentSession/engineAgentRegistryRead.js

@@ -1,7 +1,7 @@
 import { errCodes } from '../controlRouter.js';
 import { hostLog } from '../host.js';
 import { isSessionIdPathSegment } from '../sessionIdSegment.js';
-import { ownDataField } from '../ownKey.js';
+import { engineCapNestedValue } from '../engineCapsCache.js';
 const unavailable = (why) => ({
     kind: 'unavailable',
     why,
@@ -58,13 +58,11 @@ export function registryListingProvenanceOf(listing) {
 export function isEngineAgentRegistryListingSuperseded(listing) {
     return registryListingProvenanceOf(listing)?.superseded === true;
 }
-function listFaceOn(caps) {
-    if (typeof caps !== 'object' || caps === null)
-        return false;
-    const bg = ownDataField(caps, 'background');
-    if (typeof bg !== 'object' || bg === null)
-        return false;
-    return ownDataField(bg, 'listFace') === true;
+function listFaceGate(capsBaseUrl) {
+    const v = engineCapNestedValue(typeof capsBaseUrl === 'string' ? capsBaseUrl : undefined, 'background', 'listFace');
+    if (v.kind === 'unobserved' || v.kind === 'unreadable')
+        return 'capability_unknown';
+    return v.kind === 'value' && v.value === true ? null : 'no_list_face';
 }
 function readRow(v) {
     if (typeof v !== 'object' || v === null || Array.isArray(v))
@@ -85,18 +83,19 @@ function readRow(v) {
         ...(typeof createdAt === 'number' && Number.isFinite(createdAt) ? { createdAt } : {}),
     };
 }
-export async function readEngineAgentRegistry(client, sessionId, caps, opts) {
+export async function readEngineAgentRegistry(client, sessionId, capsBaseUrl, opts) {
     try {
-        return await readOnce(client, sessionId, caps, opts);
+        return await readOnce(client, sessionId, capsBaseUrl, opts);
     }
     catch {
         noteReadFailed('reader threw');
         return unavailable('read_failed');
     }
 }
-async function readOnce(client, sessionId, caps, opts) {
-    if (!listFaceOn(caps))
-        return unavailable('no_list_face');
+async function readOnce(client, sessionId, capsBaseUrl, opts) {
+    const gate = listFaceGate(capsBaseUrl);
+    if (gate !== null)
+        return unavailable(gate);
     if (!isSessionIdPathSegment(sessionId)) {
         noteReadFailed('bad session id');
         return unavailable('read_failed');

package/dist/agentsWireCaps.d.ts

@@ -1,14 +1,11 @@
 import { type EngineProbeOpts, type WireAuthTokenSource } from './engineWireSdk.js';
 import type { ReasoningEffort } from './effortWire.js';
 import type { ToolRosterView } from './toolRoster.js';
+import { type AssemblyRefusal } from './wireFailureShape.js';
 export declare const MAX_TASK_AGENTS = 32;
-export declare const MAX_AGENT_NAME_CHARS = 64;
 export declare const MAX_AGENT_TEXT_CHARS = 4096;
 export declare const MAX_AGENT_SYSTEM_PROMPT_CHARS = 65536;
-export declare const MAX_AGENT_TOOLS = 64;
-export declare const MAX_AGENT_TOOL_NAME_CHARS = 128;
 export declare const MAX_AGENT_SKILL_CONTENT_CHARS = 1048576;
-export declare const MAX_AGENT_MAX_TURNS = 1000;
 export declare const TASK_AGENT_WIRE_FIELDS: readonly ["name", "whenToUse", "whenToUseLean", "allowTools", "denyTools", "skills", "background", "isolation", "model", "thinking", "systemPrompt", "maxTurns", "memory", "observer", "observerMessage"];
 export type WireThinkingLevel = ReasoningEffort;
 export type TaskAgentWireSkill = {
@@ -60,7 +57,6 @@ export type ProjectAgentsDeps = {
     effortToThinking: (effort: unknown) => WireThinkingLevel | undefined;
     skillSpecs?: TaskAgentWireSkill[];
     toolRoster?: ToolRosterView | null;
-    withholdRefusedDenyLists?: boolean;
     agentSourceLabel?: (agentName: string) => string | undefined;
 };
 export type ProjectAgentsResult = {
@@ -76,6 +72,7 @@ export interface AgentToolListFlaw {
     readonly kind: AgentToolListFlawKind;
     readonly currentName?: string;
     readonly toolName?: string;
+    readonly rewritten?: true;
 }
 export declare function agentToolListFlaws(agents: readonly TaskAgentWireItem[] | undefined, roster?: ToolRosterView | null): AgentToolListFlaw[];
 export declare function projectAgentsForWire(defs: readonly AgentDefLike[], deps: ProjectAgentsDeps): ProjectAgentsResult;
@@ -88,7 +85,12 @@ export type WireConfig = {
 export type ProjectorFn = () => Promise<ProjectAgentsResult>;
 export declare function prepareTaskAgentsWireWith(cfg: WireConfig, projector: ProjectorFn): Promise<void>;
 export declare function invalidateTaskAgentsWire(): Promise<void>;
-export declare function awaitTaskAgentsWire(timeoutMs?: number): Promise<void>;
+export declare function awaitTaskAgentsWire(timeoutMs?: number): Promise<{
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly refusal: AssemblyRefusal;
+}>;
 export declare function taskAgentsField(): {
     agents?: TaskAgentWireItem[];
 };