@sema-agent/client-core 0.98.0 → 0.100.0

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, owner) {
     return stamp(ctx, {
         uuid: identity.runId === undefined ? undefined : terminalUuidOf(identity.runId, identity.label),
         session_id: undefined,
@@ -121,9 +151,38 @@ 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 } : {}),
+        ...(owner !== undefined ? { _sema_terminal_owner: owner } : {}),
     });
 }
+function withTerminalOwner(frame, owner) {
+    return owner === undefined ? frame : { ...frame, _sema_terminal_owner: owner };
+}
+function terminalOwnerOfStream(ctx, busy, busyHandle, runId) {
+    const hostString = (k) => {
+        try {
+            const d = Object.getOwnPropertyDescriptor(ctx, k);
+            return d !== undefined && 'value' in d && typeof d.value === 'string' && d.value.length > 0 ? d.value : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const followed = hostString('followedRun');
+    if (followed !== undefined)
+        return { kind: 'followed-run', taskId: followed, ...(runId !== undefined ? { runId } : {}) };
+    if (!busy)
+        return undefined;
+    const requestId = hostString('requestId');
+    return {
+        kind: 'request-not-sent',
+        ...(requestId !== undefined ? { requestId } : {}),
+        ...(typeof busyHandle === 'string' && busyHandle.length > 0 ? { heldBy: busyHandle } : {}),
+    };
+}
 function engineResultOf(result) {
     const v = doneResultView(result);
     return v.replay ? (v.engine ?? result) : result;
@@ -233,7 +292,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 +373,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 +405,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 +569,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 +585,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 +616,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 +640,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             parentToolCallId: parent,
                             usage,
                             engineUsage,
+                            ...usageUnknownKeys,
                             ...(usageMissing ? { usageMissing: true } : {}),
                             ...(stopWord !== undefined ? { stopReason: stopWord } : {}),
                             ...(responseModelWord !== undefined ? { responseModel: responseModelWord } : {}),
@@ -640,6 +681,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
             const doneTerminal = rowFacts.doneTerminal;
             const terminalRunId = terminalRunIdOf(ev);
             const replayed = isReplayedTerminal(ev);
+            const owner = terminalOwnerOfStream(ctx, rowFacts.busy.busy, rowFacts.busy.handle, terminalRunId);
             const errText = rowFacts.errText;
             if (errText) {
                 const busy = rowFacts.busy;
@@ -680,7 +722,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, owner);
             }
             else {
                 const echoedSid = ev.type === 'done' ? engineSessionIdOf(engineResultOf(ev.result)) : undefined;
@@ -706,7 +748,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     emitChromeFireAndForget(ctx, { kind: 'run_cost_reconciled', laneProof: mainLane(), ...costFacts.reconcile });
                 }
             }
-            const resultFrame = terminalToSdkResult(ev, ctx, {
+            const resultFrame = withTerminalOwner(terminalToSdkResult(ev, ctx, {
                 usageMissingObserved,
                 nestedUsageByTask,
                 toolInputByCallId,
@@ -716,13 +758,13 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 streamSawRunOpen,
                 deniedToolNameByCallId,
                 deniedCallsOverflowed,
-            });
+            }), owner);
             const outcome = resultFrame.
                 _sema_outcome;
             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, { runId: terminalRunId, label: 'outcome-unknown' }, replayed, `${OUTCOME_UNKNOWN_ROW_PREFIX}: ${sentence}`);
+                yield syntheticTerminalRow(ctx, { runId: terminalRunId, label: 'outcome-unknown' }, replayed, `${OUTCOME_UNKNOWN_ROW_PREFIX}: ${sentence}`, undefined, undefined, undefined, owner);
             }
             yield terminalFactOf(ev, doneTerminal);
             yield resultFrame;

package/dist/adapter/types.d.ts

@@ -23,6 +23,8 @@ export interface EmitContext {
     emitChrome?(event: ChromeEvent): void | Promise<void>;
     onDroppedFrame?(info: DroppedFrameInfo): void;
     boundRun?(frame: AgentEvent): EngineBoundRun | undefined;
+    requestId?: string;
+    followedRun?: string;
 }
 export declare function stamp<T extends {
     uuid?: string | 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 = {
@@ -49,6 +46,12 @@ export type AgentDefLike = {
     source: string;
     getSystemPrompt?: (arg?: unknown) => string;
 };
+export declare const REFUSED_PROJECT_SERVER_CAUSES: readonly ["rejected", "not_approved", "disabled", "policy_blocked", "plugin_only", "malformed_config"];
+export type RefusedProjectServerCause = (typeof REFUSED_PROJECT_SERVER_CAUSES)[number];
+export interface RefusedProjectServer {
+    readonly name: string;
+    readonly cause: RefusedProjectServerCause;
+}
 export type ProjectAgentsDeps = {
     resolveModel: (frontmatterModel: string | undefined) => {
         model: string;
@@ -58,6 +61,7 @@ export type ProjectAgentsDeps = {
     skillSpecs?: TaskAgentWireSkill[];
     toolRoster?: ToolRosterView | null;
     agentSourceLabel?: (agentName: string) => string | undefined;
+    refusedProjectServers?: readonly RefusedProjectServer[];
 };
 export type ProjectAgentsResult = {
     agents: TaskAgentWireItem[] | undefined;

package/dist/agentsWireCaps.js

@@ -8,11 +8,10 @@ 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 { hasCoreValuePort, mcpNamespace, mintNamespacePrefix } from './coreValuePorts.js';
+import { msg, renderMessage } from './i18n/translate.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',
@@ -31,6 +30,7 @@ export const TASK_AGENT_WIRE_FIELDS = [
     'observerMessage',
 ];
 export const AGENT_MEMORY_WORDS = frozenSet(['user', 'project', 'local']);
+export const REFUSED_PROJECT_SERVER_CAUSES = Object.freeze(['rejected', 'not_approved', 'disabled', 'policy_blocked', 'plugin_only', 'malformed_config']);
 const SOURCE_RANK = {
     policySettings: 0,
     flagSettings: 1,
@@ -98,8 +98,76 @@ 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');
+}
+const REFUSED_SERVER_PHRASE_KEYS = Object.freeze({
+    rejected: ['config.agentsWire.refusedServer.cause.rejected', 'config.agentsWire.refusedServer.way.rejected'],
+    not_approved: ['config.agentsWire.refusedServer.cause.notApproved', 'config.agentsWire.refusedServer.way.notApproved'],
+    disabled: ['config.agentsWire.refusedServer.cause.disabled', 'config.agentsWire.refusedServer.way.disabled'],
+    policy_blocked: ['config.agentsWire.refusedServer.cause.policyBlocked', 'config.agentsWire.refusedServer.way.policyBlocked'],
+    plugin_only: ['config.agentsWire.refusedServer.cause.pluginOnly', 'config.agentsWire.refusedServer.way.pluginOnly'],
+    malformed_config: ['config.agentsWire.refusedServer.cause.malformedConfig', 'config.agentsWire.refusedServer.way.malformedConfig'],
+});
+const REFUSED_SERVER_UNKNOWN_PHRASE = ['config.agentsWire.refusedServer.cause.unknown', 'config.agentsWire.refusedServer.way.unknown'];
+const REFUSED_SERVER_NAME_MAX = 80;
+function refusedServerIndexOf(list) {
+    try {
+        if (!Array.isArray(list) || list.length === 0)
+            return [];
+        if (!hasCoreValuePort('protocolOf') || !hasCoreValuePort('mintNamespacePrefix'))
+            return [];
+        const ns = mcpNamespace();
+        if (ns === undefined)
+            return [];
+        const out = [];
+        const seen = new Set();
+        for (const row of list) {
+            try {
+                if (row === null || typeof row !== 'object')
+                    continue;
+                const name = row.name;
+                const cause = row.cause;
+                if (typeof name !== 'string' || name === '' || seen.has(name))
+                    continue;
+                const prefix = mintNamespacePrefix(ns, name);
+                if (typeof prefix !== 'string' || prefix.length === 0)
+                    continue;
+                seen.add(name);
+                const known = typeof cause === 'string' && Object.hasOwn(REFUSED_SERVER_PHRASE_KEYS, cause) ? REFUSED_SERVER_PHRASE_KEYS[cause] : undefined;
+                out.push({ name, prefix, phrase: known ?? REFUSED_SERVER_UNKNOWN_PHRASE });
+            }
+            catch {
+                continue;
+            }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function entryNamesServer(entry, prefix) {
+    return entry.startsWith(prefix) || entry === prefix.slice(0, -2);
+}
 export function projectAgentsForWire(defs, deps) {
     const warnings = [];
+    const refusedServers = refusedServerIndexOf(deps.refusedProjectServers);
     const customs = defs
         .filter(d => d.source !== 'built-in')
         .slice()
@@ -121,25 +189,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;
         }
@@ -177,7 +244,30 @@ export function projectAgentsForWire(defs, deps) {
             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.`);
+                warnings.push(renderMessage(msg('config.agentsWire.toolEntry.sentence', { who, phrase: toolListFlawPhrase(f) })));
+            }
+        }
+        if (refusedServers.length > 0 && item.allowTools !== undefined) {
+            const told = new Set();
+            const mounted = rosterMountedNames(deps.toolRoster);
+            const mountedNames = typeof mounted === 'object' ? mounted : undefined;
+            for (const entry of item.allowTools) {
+                if (mountedNames?.has(entry) === true)
+                    continue;
+                const hit = refusedServers.find((r) => entryNamesServer(entry, r.prefix));
+                if (hit === undefined)
+                    continue;
+                const sentence = renderMessage(msg('config.agentsWire.refusedServer.sentence', {
+                    who: whoOf(),
+                    entry: JSON.stringify(entry),
+                    server: JSON.stringify(capForDisplay(hit.name, REFUSED_SERVER_NAME_MAX)),
+                    cause: msg(hit.phrase[0]),
+                    way: msg(hit.phrase[1]),
+                }));
+                if (told.has(sentence))
+                    continue;
+                told.add(sentence);
+                warnings.push(sentence);
             }
         }
         if (def.memory !== undefined) {
@@ -199,7 +289,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 +326,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;
@@ -291,6 +376,12 @@ let preparedKey = null;
 let preparedCapsGen = null;
 let preparedPromise = null;
 let payload;
+function setPayload(agents, warnings) {
+    payload = { agents, warnings: Object.freeze([...warnings]) };
+}
+function clearPayload() {
+    payload = undefined;
+}
 let currentGeneration = null;
 function concludeGeneration(generation, outcome) {
     if (generation !== null && preparedPromise === generation && currentGeneration !== null)
@@ -326,7 +417,7 @@ function watchCapsVerdict(baseUrl) {
     void engineCapsSettled(baseUrl).then(() => {
         if (preparedKey !== baseUrl || capsVerdictAt(baseUrl) !== false)
             return;
-        payload = undefined;
+        clearPayload();
         concludeGeneration(preparedPromise, 'ok');
         currentGeneration?.settle();
     });
@@ -336,12 +427,10 @@ function applyProjectionIfCurrent(generation, projected) {
         return false;
     const accepted = capsVerdictAt(preparedKey) !== false;
     if (accepted) {
-        for (const w of projected.warnings)
-            warnOnce(w);
-        payload = projected.agents;
+        setPayload(projected.agents, projected.warnings);
     }
     else {
-        payload = undefined;
+        clearPayload();
     }
     concludeGeneration(generation, 'ok');
     currentGeneration?.settle();
@@ -352,7 +441,7 @@ async function runPrepare(cfg, projector, generation) {
         const [, projected] = await Promise.all([capsSettledAt(cfg.baseUrl), projector()]);
         if (capsVerdictAt(cfg.baseUrl) === false) {
             if (preparedKey === cfg.baseUrl) {
-                payload = undefined;
+                clearPayload();
                 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`);
@@ -362,13 +451,14 @@ async function runPrepare(cfg, projector, generation) {
         }
         if (!applyProjectionIfCurrent(generation, projected))
             return;
-        if (payload && hostEnv().SEMA_DEBUG) {
-            console.error(`[sema] agents wire: ${payload.length} custom agent(s) → TaskRequest.agents (${payload.map(a => a.name).join(', ')})`);
+        const sent = payload?.agents;
+        if (sent && hostEnv().SEMA_DEBUG) {
+            console.error(`[sema] agents wire: ${sent.length} custom agent(s) → TaskRequest.agents (${sent.map(a => a.name).join(', ')})`);
         }
     }
     catch (e) {
         if (preparedPromise === generation)
-            payload = undefined;
+            clearPayload();
         concludeGeneration(generation, 'failed');
         if (hostEnv().SEMA_DEBUG) {
             console.error('[sema] agents wire prepare failed (the readiness gate refuses this turn):', e);
@@ -403,7 +493,7 @@ export function invalidateTaskAgentsWire() {
     const projector = activeProjector;
     if (!preparedPromise || !projector)
         return Promise.resolve();
-    payload = undefined;
+    clearPayload();
     return startGeneration(generation => runReproject(projector, generation));
 }
 async function runReproject(projector, generation) {
@@ -434,7 +524,7 @@ export async function awaitTaskAgentsWire(timeoutMs = 4000) {
         return taskAgentsReady();
     const projector = activeProjector;
     if (currentGeneration?.outcome === 'failed' && projector !== null) {
-        payload = undefined;
+        clearPayload();
         void startGeneration(generation => runReproject(projector, generation));
     }
     let timeoutHandle;
@@ -493,10 +583,14 @@ function kickTaskAgentsRefresh() {
 export function taskAgentsField() {
     const base = preparedKey;
     if (capsVerdictAt(base) === false) {
-        payload = undefined;
+        clearPayload();
         return {};
     }
-    const current = payload;
+    const held = payload;
+    const current = held?.agents;
+    if (held !== undefined)
+        for (const w of held.warnings)
+            warnOnce(w);
     kickTaskAgentsRefresh();
     return current ? { agents: current } : {};
 }
@@ -506,6 +600,6 @@ export function _resetAgentsWireForTest() {
     preparedCapsGen = null;
     preparedPromise = null;
     currentGeneration = null;
-    payload = undefined;
+    clearPayload();
     emittedWarnings.clear();
 }