@sema-agent/client-core 0.99.0 → 0.101.0

package/dist/adapter/runStream.js

@@ -1,20 +1,23 @@
-import { eventSeq, stamp, } from './types.js';
+import { eventSeq, isSubFlowSegmentEnd, SEGMENT_END_IDENTITY_KEYS, snapshotIsSubFlow, 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 { terminalPartsOfObserved, readRunCostFacts, terminalToSdkResult, TOOL_INPUT_JOIN_MAX_CALLS } from './downstream/terminalToSdkResult.js';
 import { terminalRunIdOf, terminalUuidOf } from '../engineRowRef.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';
+import { carriesAnswerText, guardedRead, readFrameStringKey } from '../ownKey.js';
+import { ccErrorOfProviderStatus } from '../providerRejection.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 { classifyToolHistoryMismatch, noteToolHistoryTerminalFacts, SEMA_TOOL_HISTORY_ACCEPTED_KEY, openToolHistoryGeneration, TOOL_HISTORY_REWIND_SENTENCE, toolHistoryMismatchRowKey, toolHistoryRepeatSentence, toolHistoryRewindOffered, } from '../toolHistoryMismatch.js';
+import { isReviewPark, readRunTerminal, runTerminalCode, runTerminalCodedDetail } from '../runTerminal.js';
 import { parkHeldCallIdOf } from '../engineRowRef.js';
 import { providerRejectionResend } from '../providerRejection.js';
 import { displayUntrusted, washCredentials } from '../displayUntrusted.js';
-import { PROMPT_BLOCKED_BY_HOOK_ROW_LEAD, runBlockedText } from '../promptBlockedCopy.js';
+import { runBlockedText } from '../promptBlockedCopy.js';
+import { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESSAGE_PREFIX, RUN_STOPPED_MESSAGE_PREFIX, SESSION_BUSY_ROW_LEAD, legacyRowKindOfText, } from '../rowKind.js';
+export { MODEL_OUTPUT_ERROR_PREFIX, OUTCOME_UNKNOWN_ROW_PREFIX, RUN_BLOCKED_MESSAGE_PREFIX, RUN_STOPPED_MESSAGE_PREFIX };
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
 import { resumeReopenContent, resumeReopenFromError, suspendedReopenOf } from '../hitl/suspendedReopen.js';
 import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../gateVocabulary.js';
@@ -109,22 +112,17 @@ function busyReadOfFrame(ev, doneTerminal, preReadActiveTaskId) {
     const cls = classifyActiveRunBusy({ errorCode: (isDone ? runTerminalCode(terminal) : undefined) ?? flatCode, activeTaskId });
     return { carrier, cls };
 }
-export const RUN_STOPPED_MESSAGE_PREFIX = 'Run stopped';
-export const RUN_BLOCKED_MESSAGE_PREFIX = 'Run blocked';
 export function isGovernanceStopRowText(text) {
-    const t = text.trimStart();
-    return t.startsWith(`${RUN_STOPPED_MESSAGE_PREFIX}:`) || t.startsWith(`${RUN_BLOCKED_MESSAGE_PREFIX}`) || t.startsWith(PROMPT_BLOCKED_BY_HOOK_ROW_LEAD);
+    return legacyRowKindOfText(text) === 'governance_stop';
 }
-export const MODEL_OUTPUT_ERROR_PREFIX = 'Model output error';
 export function isModelOutputErrorText(text) {
     const anchors = ['tool call argument(s) not valid JSON', 'tool call(s) arrived with no tool name and cannot be executed'];
     const t = text.trimStart();
     return anchors.some((a) => t.startsWith(a));
 }
 export function isModelOutputErrorRowText(text) {
-    return text.trimStart().startsWith(`${MODEL_OUTPUT_ERROR_PREFIX}:`);
+    return legacyRowKindOfText(text) === 'model_output_error';
 }
-export const OUTCOME_UNKNOWN_ROW_PREFIX = 'Outcome unknown';
 function apiErrorRowBitsOf(read) {
     try {
         const status = read.carrier.status;
@@ -134,6 +132,7 @@ function apiErrorRowBitsOf(read) {
             ...(typeof status === 'number' && Number.isInteger(status) && status >= 100 && status <= 999 ? { status } : {}),
             ...(providerCondition !== undefined ? { providerCondition } : {}),
             ...(errorCode !== undefined ? { errorCode } : {}),
+            ...(read.coded !== undefined ? { codedDetail: read.coded } : {}),
         };
         return Object.keys(bits).length > 0 ? bits : undefined;
     }
@@ -141,7 +140,23 @@ function apiErrorRowBitsOf(read) {
         return undefined;
     }
 }
-function syntheticTerminalRow(ctx, identity, replayed, text, historyKey, resend, apiError) {
+function wayOutFactsOfApiError(read) {
+    try {
+        const bits = apiErrorRowBitsOf(read);
+        const route = read.detail !== undefined && ownDataBit(read.detail, 'kind') === PROVIDER_REJECTED_DETAIL ? plainObjectOf(ownDataBit(read.detail, 'route')) : undefined;
+        const credentialSource = route === undefined ? undefined : nonEmptyStr(ownDataBit(route, 'credentialSource'));
+        return {
+            ...(bits?.status !== undefined ? { status: bits.status } : {}),
+            ...(bits?.providerCondition !== undefined ? { providerCondition: bits.providerCondition } : {}),
+            ...(credentialSource !== undefined ? { credentialSource } : {}),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+function syntheticTerminalRow(ctx, identity, replayed, kind, text, historyKey, resend, apiError, owner) {
+    const ccError = kind === 'api_error' && apiError?.status !== undefined ? ccErrorOfProviderStatus(apiError.status) : undefined;
     return stamp(ctx, {
         uuid: identity.runId === undefined ? undefined : terminalUuidOf(identity.runId, identity.label),
         session_id: undefined,
@@ -154,9 +169,41 @@ function syntheticTerminalRow(ctx, identity, replayed, text, historyKey, resend,
         ...(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 } : {}),
+        ...(apiError?.codedDetail !== undefined ? { _sema_coded_detail: apiError.codedDetail } : {}),
+        _sema_row_kind: kind,
+        ...(ccError !== undefined ? { error: ccError } : {}),
         ...(replayed ? { _sema_replay: true } : {}),
+        ...(owner !== undefined ? { _sema_terminal_owner: owner } : {}),
     });
 }
+function withTerminalOwner(frame, owner) {
+    return owner === undefined ? frame : { ...frame, _sema_terminal_owner: owner };
+}
+function withHistoryAccepted(frame, accepted) {
+    return accepted === undefined ? frame : { ...frame, [SEMA_TOOL_HISTORY_ACCEPTED_KEY]: true };
+}
+function terminalOwnerOfStream(ctx, busy, busyHandle, runId) {
+    const hostString = (k) => {
+        try {
+            const d = Object.getOwnPropertyDescriptor(ctx, k);
+            return d !== undefined && Object.hasOwn(d, 'value') && 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;
@@ -166,7 +213,7 @@ function engineSessionIdOf(result) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
 export function isOutcomeUnknownRowText(text) {
-    return text.trimStart().startsWith(`${OUTCOME_UNKNOWN_ROW_PREFIX}:`);
+    return legacyRowKindOfText(text) === 'outcome_unknown';
 }
 export function isGovernanceTerminal(input) {
     if (input.status === 'blocked')
@@ -265,8 +312,18 @@ 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', 'providerCondition']);
+    if (detail !== undefined) {
+        const detailCopy = ownDataCopy(detail, ['kind', 'status', 'code', 'providerCondition']);
+        const route = plainObjectOf(ownDataBit(detail, 'route'));
+        if (route !== undefined)
+            detailCopy.route = ownDataCopy(route, ['credentialSource', 'root']);
+        if (detailCopy.kind === 'coded') {
+            const body = ownDataBit(detail, 'detail');
+            if (body !== undefined)
+                detailCopy.detail = body;
+        }
+        ts.detail = detailCopy;
+    }
     snap.terminal = ts;
     return snap;
 }
@@ -330,6 +387,7 @@ function apiErrorTerminalFromFacts(x, facts) {
         return {
             carrier: mintToolHistoryCarrier(nonEmptyStr(ownDataBit(read, 'code')), status, nonEmptyStr(ownDataBit(read, 'message'))),
             detail: detail,
+            coded: runTerminalCodedDetail(read),
         };
     }
     catch {
@@ -387,6 +445,15 @@ export function _resetDroppedFrameReportForTest() {
 export function _droppedFrameMemoSizeForTest() {
     return reportedDroppedTypes.size;
 }
+function wireFrameIsSubFlow(ev) {
+    const snap = guardedRead(() => {
+        const s = {};
+        for (const k of SEGMENT_END_IDENTITY_KEYS)
+            s[k] = ev[k];
+        return s;
+    });
+    return snap === undefined || snapshotIsSubFlow(snap);
+}
 function withStringFailureFields(ev) {
     if (ev.type !== 'failed')
         return ev;
@@ -434,6 +501,73 @@ async function* runStreamInner(events, ctx, handle = {}) {
     let deniedCallsOverflowed = false;
     let successfulToolEndObserved = false;
     let streamSawRunOpen = false;
+    const observedSnapshot = () => ({
+        usageMissingObserved,
+        nestedUsageByTask,
+        toolInputByCallId,
+        gateDeniedByByCallId,
+        denialKindByCallId,
+        successfulToolEndObserved,
+        streamSawRunOpen,
+        deniedToolNameByCallId,
+        deniedCallsOverflowed,
+    });
+    handle.observedTerminalParts = () => terminalPartsOfObserved(observedSnapshot());
+    let lastTranscriptRow = null;
+    let liveTailDone = '';
+    let liveTailOpen = '';
+    let liveTailPrev = '';
+    let lateEndDone = '';
+    let lateEndOpen = '';
+    const closeLiveMessage = () => {
+        const t = liveTailDone + liveTailOpen;
+        if (carriesAnswerText(t)) {
+            liveTailPrev = t;
+            lateEndDone = liveTailDone;
+            lateEndOpen = liveTailOpen;
+        }
+        liveTailDone = '';
+        liveTailOpen = '';
+    };
+    const noteRow = (m, wireSubFlow) => {
+        const r = m;
+        if (r.parent_tool_use_id !== null && r.parent_tool_use_id !== undefined)
+            return m;
+        if (isSubFlowSegmentEnd(m))
+            return m;
+        if (wireSubFlow === true)
+            return m;
+        if (r.type === 'assistant' || r.type === 'user') {
+            lastTranscriptRow = m;
+            liveTailDone = '';
+            liveTailOpen = '';
+            liveTailPrev = '';
+            lateEndDone = '';
+            lateEndOpen = '';
+        }
+        else if (r.type === 'stream_event' && r.event?.type === 'text_delta' && typeof r.event.delta === 'string') {
+            liveTailOpen += r.event.delta;
+            if (r.event.delta.length > 0)
+                lateEndOpen = '';
+        }
+        else if (r.type === 'text_end' && typeof r.content === 'string') {
+            if (liveTailDone === '' && liveTailOpen === '' && lateEndOpen !== '') {
+                lateEndDone += r.content;
+                lateEndOpen = '';
+                liveTailPrev = lateEndDone;
+            }
+            else {
+                liveTailDone += r.content;
+                liveTailOpen = '';
+            }
+        }
+        return m;
+    };
+    const lastRowForResult = () => {
+        const open = liveTailDone + liveTailOpen;
+        const tail = carriesAnswerText(open) ? open : liveTailPrev;
+        return carriesAnswerText(tail) ? { type: 'assistant', message: { content: [{ type: 'text', text: tail }] } } : lastTranscriptRow;
+    };
     const sameArgs = (a, b) => {
         if (a === b)
             return true;
@@ -446,6 +580,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
     };
     for await (const rawEv of events) {
         const ev = withStringFailureFields(rawEv);
+        const wireSubFlow = wireFrameIsSubFlow(ev);
         if (ev.type === 'tool_end' && ev.isError !== true)
             successfulToolEndObserved = true;
         const seq = eventSeq(ev);
@@ -570,10 +705,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 reportDroppedFrame('turn_end_usage_absent', ev.type, ctx);
                 continue;
             }
-            const identityEnvelope = ev;
-            const isSubFlow = identityEnvelope.parentToolCallId !== undefined ||
-                identityEnvelope.sourceTaskId !== undefined ||
-                identityEnvelope.bgAgentId !== undefined;
+            const isSubFlow = wireSubFlow;
             {
                 if (measured !== undefined) {
                     handle.latestUsage = usage;
@@ -638,6 +770,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
             }
             const outputTokens = engineUsage.outputTokens;
             if (!isSubFlow) {
+                closeLiveMessage();
                 yield {
                     type: 'turn_usage',
                     ...(usageMissing ? { _sema_usage_missing: true } : { _sema_last_assistant_usage: usage }),
@@ -655,7 +788,11 @@ 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);
+            let wayOutFacts;
+            let codedDetailJudged;
             const errText = rowFacts.errText;
+            let historyAcceptedSinceMismatch;
             if (errText) {
                 const busy = rowFacts.busy;
                 const maxTokHint = /max_tokens/i.test(errText)
@@ -664,9 +801,11 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 const busyHandle = busy.handle;
                 const arm = terminalRowArmOf(rowFacts);
                 const rowText = arm === 'busy'
-                    ? `This session is locked by an earlier run${busyHandle ? ` (run ${busyHandle})` : ''} that ` +
+                    ? `${SESSION_BUSY_ROW_LEAD}${busyHandle ? ` (run ${busyHandle})` : ''} that ` +
                         `has not been released, so this message was NOT sent. Nothing releases it on its own — ` +
-                        `cancel that run (POST /v1/runs/${busyHandle ?? '<id>'}/cancel), or start a new session.`
+                        (ctx.lane === 'print' || ctx.lane === 'utility'
+                            ? `cancel that run (POST /v1/runs/${busyHandle ?? '<id>'}/cancel), or start a new session.`
+                            : `end ${busyHandle ? `run ${busyHandle}` : 'that run'} on the engine, or start a new session.`)
                     : arm === 'governance'
                         ?
                             `${isGovernanceStopRowText(errText) ? errText : `${RUN_STOPPED_MESSAGE_PREFIX}: ${errText}`}${maxTokHint}`
@@ -679,34 +818,40 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     : doneTerminal?.kind === 'failed' && isCorruptSessionCode(doneTerminal.code);
                 const abortNote = abortCauseNoteOf(ev);
                 const historyTerminal = apiErrorTerminalOfRowFrame(ev, rowFacts);
+                if (arm === 'apiError') {
+                    wayOutFacts = wayOutFactsOfApiError(historyTerminal);
+                    codedDetailJudged = { value: historyTerminal.coded };
+                }
                 const historyMismatch = classifyToolHistoryMismatch(historyTerminal.carrier);
                 const historyEchoedSid = ev.type === 'done' ? engineSessionIdOf(engineResultOf(ev.result)) : undefined;
-                const historyRepeat = noteToolHistoryTerminal({
+                const historyRepeat = noteToolHistoryTerminalFacts({
                     sessionId: historyEchoedSid ?? ctx.sessionId,
                     sessionEchoed: historyEchoedSid !== undefined,
                     generation: historyGeneration,
                     runId: terminalRunId,
                     replay: replayed,
                     mismatch: historyMismatch,
-                });
+                    accepted: false,
+                }).consecutive;
                 const rewindOffered = historyMismatch !== null && ctx.lane !== 'print' && ctx.lane !== 'utility' && toolHistoryRewindOffered(ctx.offersRewind);
                 const rewindLine = rewindOffered
                     ? `\n${TOOL_HISTORY_REWIND_SENTENCE}${historyRepeat !== undefined && historyRepeat >= 2 ? ` ${toolHistoryRepeatSentence(historyRepeat)}` : ''}`
                     : '';
                 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, arm === 'apiError' ? apiErrorRowBitsOf(historyTerminal) : undefined);
+                yield noteRow(syntheticTerminalRow(ctx, { runId: terminalRunId, label: 'terminal-row' }, replayed, arm === 'busy' ? 'session_busy' : arm === 'governance' ? 'governance_stop' : arm === 'modelOutput' ? 'model_output_error' : 'api_error', `${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;
-                noteToolHistoryTerminal({
+                historyAcceptedSinceMismatch = noteToolHistoryTerminalFacts({
                     sessionId: echoedSid ?? ctx.sessionId,
                     sessionEchoed: echoedSid !== undefined,
                     generation: historyGeneration,
                     runId: terminalRunId,
                     replay: replayed,
                     mismatch: null,
-                });
+                    accepted: ev.type === 'done' && (doneTerminal?.kind === 'completed' || doneTerminal?.kind === 'paused'),
+                }).acceptedSinceMismatch;
             }
             if (ev.type === 'done' && isReviewPark(doneTerminal) && ctx.emitChrome) {
                 try {
@@ -721,23 +866,20 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     emitChromeFireAndForget(ctx, { kind: 'run_cost_reconciled', laneProof: mainLane(), ...costFacts.reconcile });
                 }
             }
-            const resultFrame = terminalToSdkResult(ev, ctx, {
-                usageMissingObserved,
-                nestedUsageByTask,
-                toolInputByCallId,
-                gateDeniedByByCallId,
-                denialKindByCallId,
-                successfulToolEndObserved,
-                streamSawRunOpen,
-                deniedToolNameByCallId,
-                deniedCallsOverflowed,
-            });
+            const mintResultFrame = (lastRow) => withHistoryAccepted(withTerminalOwner(terminalToSdkResult(ev, ctx, {
+                ...observedSnapshot(),
+                wayOutFacts,
+                ...(codedDetailJudged !== undefined ? { codedDetail: codedDetailJudged.value } : {}),
+                lastRow: lastRow,
+            }), owner), historyAcceptedSinceMismatch);
+            let resultFrame = mintResultFrame(lastRowForResult());
             const outcome = resultFrame.
                 _sema_outcome;
             if (outcome === 'unknown') {
-                const errs = resultFrame.errors;
+                const errs = (resultFrame.errors ?? mintResultFrame(null).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 noteRow(syntheticTerminalRow(ctx, { runId: terminalRunId, label: 'outcome-unknown' }, replayed, 'outcome_unknown', `${OUTCOME_UNKNOWN_ROW_PREFIX}: ${sentence}`, undefined, undefined, undefined, owner));
+                resultFrame = mintResultFrame(lastRowForResult());
             }
             yield terminalFactOf(ev, doneTerminal);
             yield resultFrame;
@@ -750,7 +892,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
         }
         const projection = eventToSdkMessage(ev, ctx);
         if (projection.kind === 'message') {
-            yield projection.message;
+            yield noteRow(projection.message, wireSubFlow);
             continue;
         }
         if (projection.kind === 'dropped')

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/agentsWireCaps.d.ts

@@ -1,17 +1,12 @@
 import { type EngineProbeOpts, type WireAuthTokenSource } from './engineWireSdk.js';
 import type { ReasoningEffort } from './effortWire.js';
+import type { SkillSpec } from '@sema-agent/sdk';
 import type { ToolRosterView } from './toolRoster.js';
 import { type AssemblyRefusal } from './wireFailureShape.js';
 export declare const MAX_TASK_AGENTS = 32;
 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 = {
-    name: string;
-    description: string;
-    content: string;
-    allowedTools?: string[];
-    disallowedTools?: string[];
-};
+export type TaskAgentWireSkill = SkillSpec;
 export declare const AGENT_MEMORY_WORDS: ReadonlySet<string>;
 export type TaskAgentWireMemory = {
     scopes: string[];
@@ -46,6 +41,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;
@@ -55,6 +56,7 @@ export type ProjectAgentsDeps = {
     skillSpecs?: TaskAgentWireSkill[];
     toolRoster?: ToolRosterView | null;
     agentSourceLabel?: (agentName: string) => string | undefined;
+    refusedProjectServers?: readonly RefusedProjectServer[];
 };
 export type ProjectAgentsResult = {
     agents: TaskAgentWireItem[] | undefined;