@sema-agent/client-core 0.98.0 → 0.99.0

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -5,8 +5,8 @@ import { ccToolDenialKindForToolEnd, gateOutcomeOf } from '../../gateOutcome.js'
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
 import { projectHandsSection } from '../../handsSeam.js';
 import { readMcpLiveness } from '../../mcpLiveness.js';
-import { contextUsageReadingOf, markMcpSectionDroppedNamedRows, readFrameTrueMark } from '../../ownKey.js';
-import { SEGMENT_END_IDENTITY_KEYS, stripToolUseSideChannels } from '../types.js';
+import { contextUsageReadingOf, humanInputAttachmentsOf, markMcpSectionDroppedNamedRows, readFrameTrueMark } from '../../ownKey.js';
+import { SEGMENT_END_IDENTITY_KEYS, eventSeq, stripToolUseSideChannels } from '../types.js';
 import { frozenSet } from '../../frozenSet.js';
 import { isCoreWorkflowRunTerminal } from '../../terminalStatuses.js';
 import { envelopeUuidOf, mintEngineRowRef, readBoundRun, wireEventIdOf } from '../../engineRowRef.js';
@@ -27,6 +27,7 @@ export const INTERNAL_SDK_ARM_TYPES = frozenSet([
     'terminal_fact',
     'retry_status',
     'task_progress',
+    'task_started',
     'task_notification',
     'diagnostics',
     'steering_injected',
@@ -86,7 +87,7 @@ function withEngineIdentity(p, ev, ctx) {
 function projectEvent(ev, ctx) {
     switch (ev.type) {
         case 'task_started':
-            return dropped('unsupported_arm', 'task_started');
+            return taskStartedProjection(ev, ctx);
         case 'text_end':
             return textEndProjection(ev, ctx);
         case 'reasoning_end':
@@ -671,6 +672,48 @@ function contextUsageProjection(ev, ctx) {
         ...identity,
     }))));
 }
+function taskStartedProjection(frame, ctx) {
+    const ev = frame;
+    const { identity, bad } = identityOrMalformed(ev, 'task_started');
+    if (bad !== null)
+        return bad;
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+    const taskId = str(ev.taskId);
+    if (taskId === undefined)
+        return dropped('malformed', 'task_started');
+    const sessionId = str(ev.sessionId);
+    const model = str(ev.model);
+    const taskType = str(ev.taskType);
+    const seq = num(ev.seq);
+    const workflowRunId = str(ev.workflowRunId);
+    const workflowAgentLabel = str(ev.workflowAgentLabel);
+    const parentTaskId = str(ev.parentTaskId);
+    const parentSessionId = str(ev.parentSessionId);
+    const rootSessionId = str(ev.rootSessionId);
+    const name = str(ev.name);
+    const spawnName = str(ev.spawnName);
+    const agentType = str(ev.agentType);
+    const startedAt = num(ev.startedAt);
+    return projected(internalArmExit(stamp(ctx, armBody({
+        type: 'task_started',
+        taskId,
+        ...(sessionId !== undefined ? { sessionId } : {}),
+        ...(model !== undefined ? { model } : {}),
+        ...(taskType !== undefined ? { taskType } : {}),
+        ...(seq !== undefined ? { seq } : {}),
+        ...(workflowRunId !== undefined ? { workflowRunId } : {}),
+        ...(workflowAgentLabel !== undefined ? { workflowAgentLabel } : {}),
+        ...(parentTaskId !== undefined ? { parentTaskId } : {}),
+        ...(parentSessionId !== undefined ? { parentSessionId } : {}),
+        ...(rootSessionId !== undefined ? { rootSessionId } : {}),
+        ...(name !== undefined ? { name } : {}),
+        ...(spawnName !== undefined ? { spawnName } : {}),
+        ...(agentType !== undefined ? { agentType } : {}),
+        ...(startedAt !== undefined ? { startedAt } : {}),
+        ...identity,
+    }))));
+}
 function compactionOutcomeProjection(frame, ctx) {
     const ev = frame;
     const { identity, bad } = identityOrMalformed(ev, 'compaction_outcome');
@@ -767,6 +810,7 @@ function engineNoticeProjection(ev, ctx) {
     const detail = typeof rawDetail === 'object' && rawDetail !== null && !Array.isArray(rawDetail)
         ? rawDetail
         : {};
+    const seq = eventSeq(ev);
     return projected(stamp(ctx, armBody({
         type: 'engine_notice',
         code,
@@ -775,7 +819,7 @@ function engineNoticeProjection(ev, ctx) {
         ...(sessionId !== undefined ? { sessionId } : {}),
         ...(ts !== undefined ? { ts } : {}),
         ...(typeof ev.eventId === 'string' && ev.eventId.length > 0 ? { eventId: ev.eventId } : {}),
-        ...(typeof ev.id === 'string' && ev.id.length > 0 ? { eventSeq: ev.id } : {}),
+        ...(seq !== undefined ? { eventSeq: seq } : {}),
     })));
 }
 function approvalFrameBody(ev) {
@@ -813,8 +857,12 @@ function humanInputProjection(ev, ctx) {
         ...(str(ev.entryId) !== undefined ? { entryId: str(ev.entryId) } : {}),
         ...(str(ev.eventId) !== undefined ? { eventId: str(ev.eventId) } : {}),
         ...(str(ev.parentToolCallId) !== undefined ? { parentToolCallId: str(ev.parentToolCallId) } : {}),
+        ...attachmentsKey(humanInputAttachmentsOf(ev)),
     })));
 }
+function attachmentsKey(rows) {
+    return rows !== undefined ? { attachments: rows } : {};
+}
 export function turnEndUsage(ev) {
     const rawValue = ev.usage;
     if (typeof rawValue !== 'object' || rawValue === null || Array.isArray(rawValue))

package/dist/adapter/runStream.js

@@ -3,7 +3,7 @@ import { eventToSdkMessage, turnEndUsage } from './downstream/eventToSdkMessage.
 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 { publishSubagentContentEvent, subagentContentEventOf } from '../subagentContentStore.js';
 import { OUTPUT_INVALID, activeRunBusyCarrierOf, classifyActiveRunBusy, isCorruptSessionCode, isLimitsExceededCode } from '../engineErrorCodes.js';
 import { doneResultView, isReplayedTerminal } from '../replayBody.js';
 import { readFrameStringKey } from '../ownKey.js';
@@ -13,11 +13,25 @@ import { classifyToolHistoryMismatch, noteToolHistoryTerminal, openToolHistoryGe
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
 import { parkHeldCallIdOf } from '../engineRowRef.js';
 import { providerRejectionResend } from '../providerRejection.js';
-import { washCredentials } from '../displayUntrusted.js';
+import { displayUntrusted, washCredentials } from '../displayUntrusted.js';
 import { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD, runBlockedText } from '../promptBlockedCopy.js';
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
 import { resumeReopenContent, resumeReopenFromError, suspendedReopenOf } from '../hitl/suspendedReopen.js';
 import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../gateVocabulary.js';
+const ENGINE_TURN_USAGE_KEYS = Object.freeze(['inputTokens', 'totalInputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'costMicroUsd']);
+const _engineTurnUsageKeysPin = true;
+void _engineTurnUsageKeysPin;
+function closedEngineTurnUsage(raw) {
+    const out = {};
+    let unknownKeys = 0;
+    for (const k of Object.keys(raw)) {
+        if (ENGINE_TURN_USAGE_KEYS.includes(k))
+            out[k] = raw[k];
+        else
+            unknownKeys++;
+    }
+    return { usage: out, unknownKeys };
+}
 const mainLane = () => ({ lane: 'main' });
 function emitChromeFireAndForget(ctx, event) {
     try {
@@ -111,7 +125,23 @@ export function isModelOutputErrorRowText(text) {
     return text.trimStart().startsWith(`${MODEL_OUTPUT_ERROR_PREFIX}:`);
 }
 export const OUTCOME_UNKNOWN_ROW_PREFIX = 'Outcome unknown';
-function syntheticTerminalRow(ctx, identity, replayed, text, historyKey, resend) {
+function apiErrorRowBitsOf(read) {
+    try {
+        const status = read.carrier.status;
+        const providerCondition = read.detail !== undefined && ownDataBit(read.detail, 'kind') === PROVIDER_REJECTED_DETAIL ? nonEmptyStr(ownDataBit(read.detail, 'providerCondition')) : undefined;
+        const errorCode = nonEmptyStr(read.carrier.code);
+        const bits = {
+            ...(typeof status === 'number' && Number.isInteger(status) && status >= 100 && status <= 999 ? { status } : {}),
+            ...(providerCondition !== undefined ? { providerCondition } : {}),
+            ...(errorCode !== undefined ? { errorCode } : {}),
+        };
+        return Object.keys(bits).length > 0 ? bits : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function syntheticTerminalRow(ctx, identity, replayed, text, historyKey, resend, apiError) {
     return stamp(ctx, {
         uuid: identity.runId === undefined ? undefined : terminalUuidOf(identity.runId, identity.label),
         session_id: undefined,
@@ -121,6 +151,9 @@ function syntheticTerminalRow(ctx, identity, replayed, 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 } } : {}),
+        ...(apiError?.status !== undefined ? { _sema_api_error_status: apiError.status } : {}),
+        ...(apiError?.providerCondition !== undefined ? { _sema_provider_condition: apiError.providerCondition } : {}),
+        ...(apiError?.errorCode !== undefined ? { _sema_api_error_code: apiError.errorCode } : {}),
         ...(replayed ? { _sema_replay: true } : {}),
     });
 }
@@ -233,7 +266,7 @@ function ownTerminalSnapshot(result) {
     const ts = ownDataCopy(t, ['kind', 'code', 'message']);
     const detail = plainObjectOf(ownDataBit(t, 'detail'));
     if (detail !== undefined)
-        ts.detail = ownDataCopy(detail, ['kind', 'status', 'code']);
+        ts.detail = ownDataCopy(detail, ['kind', 'status', 'code', 'providerCondition']);
     snap.terminal = ts;
     return snap;
 }
@@ -314,12 +347,10 @@ function apiErrorTerminalOfRowFrame(ev, facts) {
 }
 const reportedDroppedTypes = new Set();
 const DROPPED_TYPE_MEMO_CAP = 64;
-const DROPPED_TYPE_DISPLAY_CAP = 60;
-function sanitizeFrameType(type) {
-    const flattened = type.replace(/[\u0000-\u001f\u007f-\u009f]/g, '\uFFFD');
-    return flattened.length > DROPPED_TYPE_DISPLAY_CAP
-        ? `${flattened.slice(0, DROPPED_TYPE_DISPLAY_CAP)}…`
-        : flattened;
+const DROPPED_TYPE_DISPLAY_MAX = 60;
+function droppedTypeForLog(type) {
+    const full = displayUntrusted(type);
+    return full.length > DROPPED_TYPE_DISPLAY_MAX ? `${displayUntrusted(type, { max: DROPPED_TYPE_DISPLAY_MAX })}…` : full;
 }
 const DROPPED_WHY_SENTENCE = Object.freeze({
     duplicate_seq: 'a frame with this event id was already consumed on this run stream, so it was dropped as a replay (durable idempotency, contract 02 §1.1). ' +
@@ -348,7 +379,7 @@ function reportDroppedFrame(why, type, ctx) {
         return;
     if (reportedDroppedTypes.size < DROPPED_TYPE_MEMO_CAP)
         reportedDroppedTypes.add(type);
-    console.error(`[client-core] dropped an engine frame (${why}): type="${sanitizeFrameType(type)}" — ${droppedWhySentence(why)}`);
+    console.error(`[client-core] dropped an engine frame (${why}): type="${droppedTypeForLog(type)}" — ${droppedWhySentence(why)}`);
 }
 export function _resetDroppedFrameReportForTest() {
     reportedDroppedTypes.clear();
@@ -512,27 +543,9 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 }
             }
         }
-        if ((ev.type === 'text_delta' ||
-            ev.type === 'reasoning_delta' ||
-            ev.type === 'text' ||
-            ev.type === 'reasoning' ||
-            ev.type === 'tool_start' ||
-            ev.type === 'tool_end') &&
-            typeof ev.parentToolCallId === 'string') {
-            const sub = ev;
-            publishSubagentContentEvent({
-                type: sub.type,
-                taskId: sub.taskId ?? sub.parentToolCallId,
-                parentToolCallId: sub.parentToolCallId,
-                delta: sub.delta,
-                text: sub.text,
-                eventId: sub.eventId,
-                toolCallId: sub.toolCallId,
-                toolName: sub.toolName,
-                args: sub.args,
-                output: coerceOutput(sub.output),
-                isError: sub.isError,
-            });
+        const sub = subagentContentEventOf(ev);
+        if (sub !== undefined) {
+            publishSubagentContentEvent(sub);
             if (!(ctx.lane === 'print' && (sub.type === 'tool_start' || sub.type === 'tool_end')))
                 continue;
         }
@@ -546,10 +559,10 @@ async function* runStreamInner(events, ctx, handle = {}) {
             const responseModelRaw = turnEndLoose.responseModel;
             const responseModelWord = typeof responseModelRaw === 'string' && responseModelRaw.length > 0 ? responseModelRaw : undefined;
             const rawUsage = ev.usage;
-            const engineUsage = typeof rawUsage === 'object' && rawUsage !== null && !Array.isArray(rawUsage)
-                ? rawUsage
-                : undefined;
-            const usage = engineUsage !== undefined ? turnUsageToModelUsage(engineUsage) : undefined;
+            const closedUsage = typeof rawUsage === 'object' && rawUsage !== null && !Array.isArray(rawUsage) ? closedEngineTurnUsage(rawUsage) : undefined;
+            const engineUsage = closedUsage?.usage;
+            const usageUnknownKeys = closedUsage !== undefined && closedUsage.unknownKeys > 0 ? { engineUsageUnknownKeys: closedUsage.unknownKeys } : {};
+            const usage = closedUsage !== undefined ? turnUsageToModelUsage(rawUsage) : undefined;
             const measured = turnEndUsage(ev);
             if (engineUsage === undefined || usage === undefined) {
                 usageMissingObserved = true;
@@ -577,6 +590,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             laneProof: mainLane(),
                             usage,
                             engineUsage,
+                            ...usageUnknownKeys,
                             ...(usageMissing ? { usageMissing: true } : {}),
                             ...(stopWord !== undefined ? { stopReason: stopWord } : {}),
                             ...(responseModelWord !== undefined ? { responseModel: responseModelWord } : {}),
@@ -600,6 +614,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             parentToolCallId: parent,
                             usage,
                             engineUsage,
+                            ...usageUnknownKeys,
                             ...(usageMissing ? { usageMissing: true } : {}),
                             ...(stopWord !== undefined ? { stopReason: stopWord } : {}),
                             ...(responseModelWord !== undefined ? { responseModel: responseModelWord } : {}),
@@ -680,7 +695,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, { 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);
+                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, arm === 'apiError' ? apiErrorRowBitsOf(historyTerminal) : undefined);
             }
             else {
                 const echoedSid = ev.type === 'done' ? engineSessionIdOf(engineResultOf(ev.result)) : undefined;

package/dist/adapter/types.js

@@ -1,5 +1,6 @@
 export function eventSeq(ev) {
-    return ev.id;
+    const id = ev.id;
+    return typeof id === 'string' && id.length > 0 ? id : undefined;
 }
 export function uuid() {
     const g = typeof globalThis !== 'undefined' ? globalThis.crypto : undefined;

package/dist/agentSession/engineSessionBackgroundStop.js

@@ -4,7 +4,7 @@ import { clientHasVerbs, engineWireFor, INJECTED_WIRE_SETTLE_MS, noAnswerDetailF
 import { engineWireDebugEnabled } from '../engineWireTarget.js';
 import { hostLog } from '../host.js';
 import { isSessionIdPathSegment } from '../sessionIdSegment.js';
-import { wireFailureTextsOf } from '../wireFailureShape.js';
+import { readThrownSlot, readThrownStatusSlot, THROWN_SLOT_UNREADABLE, wireFailureTextsOf } from '../wireFailureShape.js';
 import { DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 const NOTHING_SENT = ' — nothing sent';
 const DETAIL_BAD_SESSION = `the session id must be a non-empty string that is not a dot segment${NOTHING_SENT}`;
@@ -155,13 +155,16 @@ function refusedWhyOf(rawCode, status) {
     return undefined;
 }
 function diagOf(e) {
-    const o = e;
-    const rawStatus = o.status ?? o.statusCode;
+    const rawStatus = readThrownStatusSlot(e);
+    const rawCode = readThrownSlot(e, 'errorCode', 'data');
+    if (rawStatus === THROWN_SLOT_UNREADABLE || rawCode === THROWN_SLOT_UNREADABLE)
+        return undefined;
     const status = typeof rawStatus === 'number' && Number.isInteger(rawStatus) ? rawStatus : undefined;
-    const errorCode = typeof o.errorCode === 'string' && o.errorCode.length > 0 ? o.errorCode : undefined;
-    const ra = o.retryAfterMs;
+    const errorCode = typeof rawCode === 'string' && rawCode.length > 0 ? rawCode : undefined;
+    const ra = readThrownSlot(e, 'retryAfterMs', 'data');
     const retryAfterMs = typeof ra === 'number' && Number.isFinite(ra) && ra >= 0 ? ra : undefined;
-    const message = typeof o.message === 'string' && o.message.length > 0 ? o.message : undefined;
+    const rawMessage = readThrownSlot(e, 'message');
+    const message = typeof rawMessage === 'string' && rawMessage.length > 0 ? rawMessage : undefined;
     return {
         ...(status !== undefined ? { status } : {}),
         ...(errorCode !== undefined ? { errorCode } : {}),
@@ -169,6 +172,10 @@ function diagOf(e) {
         ...(message !== undefined ? { message } : {}),
     };
 }
+function unreadableFailure() {
+    note('error (the failure could not be read)');
+    return { kind: 'error', detail: 'the stop request failed (the error could not be read)' };
+}
 function classifyFailure(e) {
     try {
         if (typeof e !== 'object' || e === null) {
@@ -176,6 +183,8 @@ function classifyFailure(e) {
             return { kind: 'error', detail: `the stop request failed: ${wireFailureTextsOf(e).reason.slice(0, 200)}` };
         }
         const d = diagOf(e);
+        if (d === undefined)
+            return unreadableFailure();
         if (d.status === undefined && d.errorCode === undefined) {
             const noAnswer = noAnswerDetailFrom(e);
             if (noAnswer !== null) {
@@ -200,8 +209,7 @@ function classifyFailure(e) {
         return { kind: 'error', detail: (d.message ?? 'the stop request failed').slice(0, 300), ...diag };
     }
     catch {
-        note('error (the failure could not be read)');
-        return { kind: 'error', detail: 'the stop request failed (the error could not be read)' };
+        return unreadableFailure();
     }
 }
 export async function stopEngineSessionBackground(sessionId, body, opts) {

package/dist/agentsWireCaps.d.ts

@@ -3,9 +3,6 @@ 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_TEXT_CHARS = 4096;
-export declare const MAX_AGENT_SYSTEM_PROMPT_CHARS = 65536;
-export declare const MAX_AGENT_SKILL_CONTENT_CHARS = 1048576;
 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 = {

package/dist/agentsWireCaps.js

@@ -8,11 +8,8 @@ import { CORE_PROTOCOL_PREFIXES } from './generated/toolNameTables.js';
 import { rosterMountedNames } from './rosterMountedNames.js';
 import { capForDisplay } from './fleetTaskDesc.js';
 import { deniedEntryToolName } from './engineToolDirectory.js';
-import { assemblyRefusal } from './wireFailureShape.js';
+import { assemblyRefusal, withAssemblyRefusal } from './wireFailureShape.js';
 export const MAX_TASK_AGENTS = 32;
-export const MAX_AGENT_TEXT_CHARS = 4_096;
-export const MAX_AGENT_SYSTEM_PROMPT_CHARS = 65_536;
-export const MAX_AGENT_SKILL_CONTENT_CHARS = 1_048_576;
 export const TASK_AGENT_WIRE_FIELDS = [
     'name',
     'whenToUse',
@@ -98,6 +95,24 @@ function toolListFlawPhrase(f) {
         return `${entry} could not be checked here, because the engine's tool-name check is not available in this client`;
     return `${entry} differs from the tool ${JSON.stringify(f.currentName ?? '')} only in letter case`;
 }
+function listShapeWord(v) {
+    try {
+        if (v === null)
+            return 'null';
+        if (typeof v === 'string')
+            return 'a string';
+        if (typeof v === 'object')
+            return 'an object';
+        return `a ${typeof v}`;
+    }
+    catch {
+        return 'unreadable';
+    }
+}
+function toolListShapeRefusal(agent, key, v) {
+    return withAssemblyRefusal(new TypeError(`projectAgentsForWire: agent "${capForDisplay(agent, 80)}" has ${key} written as ${listShapeWord(v)}, but it must be an array of tool-name strings — ` +
+        'refusing to assemble the agents list (a list dropped silently would give the agent every tool, or remove a deny rule). Fix the definition.'), 'input_malformed');
+}
 export function projectAgentsForWire(defs, deps) {
     const warnings = [];
     const customs = defs
@@ -121,25 +136,24 @@ export function projectAgentsForWire(defs, deps) {
             continue;
         seen.add(name);
         const item = { name };
-        if (typeof def.whenToUse === 'string' && def.whenToUse.length > 0) {
-            item.whenToUse =
-                def.whenToUse.length > MAX_AGENT_TEXT_CHARS
-                    ? def.whenToUse.slice(0, MAX_AGENT_TEXT_CHARS)
-                    : def.whenToUse;
-            if (def.whenToUse.length > MAX_AGENT_TEXT_CHARS) {
-                warnings.push(`agents wire: agent "${name}" description truncated to ${MAX_AGENT_TEXT_CHARS} chars`);
-            }
-        }
+        if (typeof def.whenToUse === 'string' && def.whenToUse.length > 0)
+            item.whenToUse = def.whenToUse;
+        const rawTools = def.tools;
+        const rawDeny = def.disallowedTools;
+        if (rawTools !== undefined && !Array.isArray(rawTools))
+            throw toolListShapeRefusal(name, 'tools', rawTools);
+        if (rawDeny !== undefined && !Array.isArray(rawDeny))
+            throw toolListShapeRefusal(name, 'disallowedTools', rawDeny);
         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`);
             return entries;
         };
-        if (Array.isArray(def.tools))
-            item.allowTools = toolEntries(def.tools, 'tools');
-        if (Array.isArray(def.disallowedTools)) {
-            const denyTools = toolEntries(def.disallowedTools, 'disallowedTools');
+        if (Array.isArray(rawTools))
+            item.allowTools = toolEntries(rawTools, 'tools');
+        if (Array.isArray(rawDeny)) {
+            const denyTools = toolEntries(rawDeny, 'disallowedTools');
             if (denyTools.length > 0)
                 item.denyTools = denyTools;
         }
@@ -199,7 +213,7 @@ export function projectAgentsForWire(defs, deps) {
                 if (typeof skillName !== 'string' || skillName.length === 0)
                     continue;
                 const spec = byName.get(skillName.toLowerCase());
-                if (spec && spec.content.length > 0 && spec.content.length <= MAX_AGENT_SKILL_CONTENT_CHARS) {
+                if (spec && spec.content.length > 0) {
                     joined.push(spec);
                 }
                 else {
@@ -236,13 +250,8 @@ export function projectAgentsForWire(defs, deps) {
             catch {
                 prompt = undefined;
             }
-            if (typeof prompt === 'string' && prompt.length > 0) {
-                if (prompt.length > MAX_AGENT_SYSTEM_PROMPT_CHARS) {
-                    warnings.push(`agents wire: agent "${name}" system prompt truncated to ${MAX_AGENT_SYSTEM_PROMPT_CHARS} chars`);
-                    prompt = prompt.slice(0, MAX_AGENT_SYSTEM_PROMPT_CHARS);
-                }
+            if (typeof prompt === 'string' && prompt.length > 0)
                 item.systemPrompt = prompt;
-            }
         }
         if (def.maxTurns !== undefined)
             item.maxTurns = def.maxTurns;

package/dist/cloudConfigWireCaps.d.ts

@@ -4,7 +4,7 @@ import type { EnvLike } from './hostEnv.js';
 export type { McpServerSpec };
 type Rec = Record<string, unknown>;
 export type { EnvLike };
-export type CloudMcpDropReason = 'disabled' | 'missing-field' | 'unknown-transport' | 'capped' | 'principal-and-assertion-header';
+export type CloudMcpDropReason = 'disabled' | 'missing-field' | 'unknown-transport' | 'capped' | 'principal-and-assertion-header' | 'tool-axes-invalid' | 'elicitation-invalid';
 export interface CloudMcpDroppedServer {
     name?: string;
     reason: CloudMcpDropReason;

package/dist/cloudConfigWireCaps.js

@@ -1,5 +1,6 @@
-import { MCP_CAPS, mcpAssertionHeaderNotSentNotice, readMcpHttpIdentityHeaders } from './mcpWireCaps.js';
+import { MCP_CAPS, mcpAssertionHeaderNotSentNotice, mcpElicitationVerdict, mcpToolAxesVerdict, readMcpHttpIdentityHeaders } from './mcpWireCaps.js';
 import { toCappedSpec } from './skillsWireCaps.js';
+import { msg, renderMessage } from './i18n/translate.js';
 import { TIER_ORDER } from './model/tierVocabulary.js';
 import { SETTINGS_NARROW_AT_MENTION } from './generated/settingsSchemaFns.js';
 import { modelsPolicyOf } from './model/modelsPolicy.js';
@@ -92,14 +93,27 @@ export function cloudMcpToSpecs(servers, env) {
             drop(name, 'unknown-transport');
             continue;
         }
+        const axesDeclared = s.toolAxes;
+        const axesVerdict = mcpToolAxesVerdict(axesDeclared);
+        if (axesVerdict.kind === 'bad') {
+            drop(name, 'tool-axes-invalid');
+            continue;
+        }
+        const axesShipped = axesVerdict.kind === 'ok' ? axesVerdict.toolAxes : axesDeclared;
+        const elVerdict = mcpElicitationVerdict(s.elicitation);
+        if (elVerdict.kind === 'bad') {
+            drop(name, 'elicitation-invalid');
+            continue;
+        }
+        const allowToolsWritten = Array.isArray(s.allowTools);
         const allowTools = asArr(s.allowTools).filter((a) => typeof a === 'string');
         specs.push({
             name,
             transport,
-            ...(allowTools.length > 0 ? { allowTools } : {}),
-            ...(s.elicitation === true ? { elicitation: true } : {}),
+            ...(allowToolsWritten ? { allowTools } : {}),
+            ...(elVerdict.elicitation !== undefined ? { elicitation: elVerdict.elicitation } : {}),
             ...(s.toolFaces !== undefined ? { toolFaces: s.toolFaces } : {}),
-            ...(s.toolAxes !== undefined ? { toolAxes: s.toolAxes } : {}),
+            ...(axesShipped !== undefined ? { toolAxes: axesShipped } : {}),
         });
     }
     return { specs, missingEnv: [...new Set(missingEnv)], droppedServers };
@@ -654,6 +668,14 @@ const MCP_DROP_SENTENCES = {
         level: 'warn',
         text: (who) => `cloud config: MCP server entries left out because they set both principalHeader and assertionHeader, which name the same identity header — keep only one of the two: ${who}`,
     },
+    'tool-axes-invalid': {
+        level: 'warn',
+        text: (who) => renderMessage(msg('config.mcp.cloudToolAxesInvalid', { who })),
+    },
+    'elicitation-invalid': {
+        level: 'warn',
+        text: (who) => renderMessage(msg('config.mcp.cloudElicitationInvalid', { who })),
+    },
     capped: {
         level: 'warn',
         text: (who) => `cloud config: MCP server entries left out because more than ${MCP_CAPS.items} were served to you and this client passes at most ${MCP_CAPS.items} to the engine: ${who}`,

package/dist/controlRouter.d.ts

@@ -1,6 +1,7 @@
 import type { TaskRequest, RunReceipt, CancelAck, Scenario, SteerPriority, AssistantTaskStatus } from '@sema-agent/sdk';
 import { type SteerPriorityReading } from './steerPriorityCapability.js';
 import { type PreemptOutcome } from './preemptWire.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 export interface RunsResourceLike {
     create(req: TaskRequest, opts?: {
         idempotencyKey?: string | null;
@@ -75,6 +76,7 @@ export interface ErrCodes {
     status?: number | undefined;
 }
 export declare function errCodes(e: unknown): ErrCodes;
+export type SteerHostQueueFact = 'queued_until_turn_end' | 'dropped' | 'unknown';
 export declare function steeringStatusIs4xx(e: object): boolean;
 export interface SteerRefusalAdvice {
     safety: ControlSafetyCode;
@@ -83,8 +85,8 @@ export interface SteerRefusalAdvice {
     nextStep: string;
 }
 export type SteeringRefusedBeforeEngine = SteerRefusalAdvice;
-export declare function steeringRefusedBeforeEngine(e: object): SteeringRefusedBeforeEngine | undefined;
-export declare function steerRefusalAdviceOf(e: object): SteerRefusalAdvice | undefined;
+export declare function steeringRefusedBeforeEngine(e: object, hostQueue?: SteerHostQueueFact, lang?: UiLanguage): SteeringRefusedBeforeEngine | undefined;
+export declare function steerRefusalAdviceOf(e: object, hostQueue?: SteerHostQueueFact, lang?: UiLanguage): SteerRefusalAdvice | undefined;
 export interface SteerBody {
     readonly text: string;
     readonly mode?: 'all' | 'one-at-a-time';