@sema-agent/client-core 0.82.0 → 0.82.2

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -36,9 +36,10 @@ export const INTERNAL_SDK_ARM_TYPES = new Set([
     'approval_revoke',
     'message_committed',
 ]);
-function assistantArm(ctx, content, eventId) {
+function assistantArm(ctx, content, eventId, parentToolCallId) {
     const id = typeof eventId === 'string' && eventId.length > 0 ? eventId : undefined;
-    const model = typeof ctx.model === 'string' && ctx.model.length > 0 ? ctx.model : undefined;
+    const parent = typeof parentToolCallId === 'string' && parentToolCallId.length > 0 ? parentToolCallId : undefined;
+    const model = parent === undefined && typeof ctx.model === 'string' && ctx.model.length > 0 ? ctx.model : undefined;
     return stamp(ctx, armBody({
         type: 'assistant',
         message: {
@@ -47,7 +48,7 @@ function assistantArm(ctx, content, eventId) {
             ...(id !== undefined ? { id } : {}),
             ...(model !== undefined ? { model } : {}),
         },
-        parent_tool_use_id: null,
+        parent_tool_use_id: parent ?? null,
     }));
 }
 function streamEventArm(ctx, event) {
@@ -136,7 +137,7 @@ export function eventToSdkMessage(ev, ctx) {
                         ? { parentToolCallId: ev.parentToolCallId }
                         : {}),
                 },
-            ], ev.eventId));
+            ], ev.eventId, ev.parentToolCallId));
         case 'compacted': {
             const raw = ev;
             const freedTokens = typeof raw.freedTokens === 'number' && Number.isFinite(raw.freedTokens) && raw.freedTokens >= 0 ? raw.freedTokens : undefined;
@@ -171,6 +172,7 @@ 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';
             return projected(stamp(ctx, armBody({
                 type: 'tool_end_result',
                 toolCallId: ev.toolCallId,
@@ -192,6 +194,7 @@ export function eventToSdkMessage(ev, ctx) {
                     : {}),
                 ...(collateralAbort === true ? { _sema_collateral_abort: true } : {}),
                 ...(denialKind !== undefined ? { _sema_denial_kind: denialKind } : {}),
+                ...(denialUnclassified ? { _sema_denial_unclassified: true } : {}),
                 ...(ev.eventId !== undefined ? { eventId: ev.eventId } : {}),
                 ...(ev.parentToolCallId !== undefined
                     ? { parentToolCallId: ev.parentToolCallId }

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

@@ -20,6 +20,8 @@ export interface TerminalStreamObserved {
     readonly denialKindByCallId?: ReadonlyMap<string, string>;
     readonly successfulToolEndObserved?: boolean;
     readonly streamSawRunOpen?: boolean;
+    readonly deniedToolNameByCallId?: ReadonlyMap<string, string | undefined>;
+    readonly deniedCallsOverflowed?: boolean;
 }
 export declare const TOOL_INPUT_JOIN_MAX_CALLS = 4096;
 export interface SemaPermissionDenial {

package/dist/adapter/downstream/terminalToSdkResult.js

@@ -1,4 +1,4 @@
-import { isCcToolDenialKind, isGateDeniedByWord } from '../../gateVocabulary.js';
+import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../../gateVocabulary.js';
 import { stamp } from '../types.js';
 import { putOwnKey } from '../../ownKey.js';
 import { readEffectiveReasoning, readEffectiveMemoryScopes } from '../../effectiveFacts.js';
@@ -65,11 +65,10 @@ function permissionDenialParts(stats, observed) {
     const gateDeniedByByCallId = observed?.gateDeniedByByCallId;
     const denialKindByCallId = observed?.denialKindByCallId;
     const hr = stats?.humanReview;
-    const gates = hr !== null && typeof hr === 'object' ? hr.gates : undefined;
-    if (!Array.isArray(gates))
-        return { permission_denials: [], _sema_permission_denials_absent: true };
+    const gatesRaw = hr !== null && typeof hr === 'object' ? hr.gates : undefined;
     const denials = [];
-    let complete = true;
+    const gates = Array.isArray(gatesRaw) ? gatesRaw : [];
+    let complete = Array.isArray(gatesRaw);
     for (const g of gates) {
         if (g === null || typeof g !== 'object') {
             complete = false;
@@ -125,6 +124,43 @@ function permissionDenialParts(stats, observed) {
             ...(toolArg !== undefined ? { _sema_tool_arg: toolArg } : {}),
         });
     }
+    const deniedToolNameByCallId = observed?.deniedToolNameByCallId;
+    if (deniedToolNameByCallId !== undefined) {
+        const ledgerDeniedIds = new Set();
+        let ledgerHasIdlessDenial = false;
+        for (const d of denials) {
+            if (d.tool_use_id !== undefined)
+                ledgerDeniedIds.add(d.tool_use_id);
+            else
+                ledgerHasIdlessDenial = true;
+        }
+        for (const [callId, toolNameRaw] of deniedToolNameByCallId) {
+            if (typeof callId !== 'string' || callId.length === 0 || ledgerDeniedIds.has(callId))
+                continue;
+            const mergedKind = denialKindByCallId?.has(callId) === true ? denialKindByCallId.get(callId) : undefined;
+            if (isCcToolDenialKind(mergedKind) && !isCcToolDenialKindADenial(mergedKind))
+                continue;
+            if (ledgerHasIdlessDenial) {
+                complete = false;
+                continue;
+            }
+            const toolName = nonEmptyStr(toolNameRaw);
+            const joinedInput = toolInputByCallId?.has(callId) === true ? joinableToolInput(toolInputByCallId.get(callId)) : undefined;
+            const deniedByRaw = gateDeniedByByCallId?.has(callId) === true ? gateDeniedByByCallId.get(callId) : undefined;
+            const deniedBy = typeof deniedByRaw === 'string' && isGateDeniedByWord(deniedByRaw) ? deniedByRaw : undefined;
+            const toolDenialKind = isCcToolDenialKind(mergedKind) ? mergedKind : undefined;
+            denials.push({
+                ...(toolName !== undefined ? { tool_name: toolName } : {}),
+                tool_use_id: callId,
+                ...(joinedInput !== undefined ? { tool_input: joinedInput, _sema_tool_input_source: 'tool_start' } : {}),
+                ...(deniedBy !== undefined ? { deniedBy, _sema_denied_by_source: 'tool_end' } : {}),
+                ...(toolDenialKind !== undefined ? { toolDenialKind } : {}),
+            });
+            ledgerDeniedIds.add(callId);
+        }
+        if (observed?.deniedCallsOverflowed === true)
+            complete = false;
+    }
     const ccList = denials.filter((d) => d.tool_name !== undefined && d.tool_use_id !== undefined && d.tool_input !== undefined);
     const claimable = complete && ccList.length === denials.length;
     const zeroOutputDenied = denials.length > 0 && observed?.streamSawRunOpen === true && observed.successfulToolEndObserved === false;
@@ -200,15 +236,18 @@ function structuredOutputParts(r) {
 function effectiveFactParts(rec) {
     const reasoning = readEffectiveReasoning(rec.effectiveReasoning);
     const scopes = readEffectiveMemoryScopes(rec.effectiveMemoryScopes);
+    const responseModel = rec.responseModel;
     return {
         ...(reasoning !== undefined ? { _sema_effective_reasoning: reasoning } : {}),
         ...(scopes !== undefined ? { _sema_effective_memory_scopes: scopes } : {}),
+        ...(typeof responseModel === 'string' && responseModel.length > 0 ? { _sema_response_model: responseModel } : {}),
     };
 }
 function reemitEffectiveFacts(f) {
     const out = {
         ...(f?._sema_effective_reasoning !== undefined ? { _sema_effective_reasoning: f._sema_effective_reasoning } : {}),
         ...(f?._sema_effective_memory_scopes !== undefined ? { _sema_effective_memory_scopes: f._sema_effective_memory_scopes } : {}),
+        ...(f?._sema_response_model !== undefined ? { _sema_response_model: f._sema_response_model } : {}),
     };
     const _keySetPin = true;
     void _keySetPin;

package/dist/adapter/runStream.js

@@ -6,7 +6,7 @@ import { coerceOutput, publishSubagentContentEvent } from '../subagentContentSto
 import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isLimitsExceededCode } from '../engineErrorCodes.js';
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
 import { ccToolDenialKindForToolEnd, gateDeniedBy, gateOutcomeOf } from '../gateOutcome.js';
-import { isCcToolDenialKind, isGateDeniedByWord } from '../gateVocabulary.js';
+import { isCcToolDenialKind, isCcToolDenialKindADenial, isGateDeniedByWord } from '../gateVocabulary.js';
 const mainLane = () => ({ lane: 'main' });
 function emitChromeFireAndForget(ctx, event) {
     try {
@@ -185,6 +185,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
     const denialKindSourceByCallId = new Map();
     const denialAmbiguous = new Set();
     let denialJoinOverflowed = false;
+    const deniedToolNameByCallId = new Map();
+    let deniedCallsOverflowed = false;
     let successfulToolEndObserved = false;
     let streamSawRunOpen = false;
     const sameArgs = (a, b) => {
@@ -229,7 +231,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
         if (ev.type === 'tool_end') {
             const endCallId = ev.toolCallId;
             if (typeof endCallId === 'string' && endCallId.length > 0) {
-                const deniedByRaw = gateDeniedBy(gateOutcomeOf(ev));
+                const endGate = gateOutcomeOf(ev);
+                const deniedByRaw = gateDeniedBy(endGate);
                 const deniedBy = isGateDeniedByWord(deniedByRaw) ? deniedByRaw : undefined;
                 const kind = ccToolDenialKindForToolEnd(ev);
                 const kindSource = kind === undefined
@@ -237,6 +240,23 @@ async function* runStreamInner(events, ctx, handle = {}) {
                     : isCcToolDenialKind(ev._sema_denial_kind)
                         ? 'local'
                         : 'wire';
+                const deniedCall = endGate !== undefined
+                    ? endGate.disposition.kind === 'denied' && (kind === undefined || isCcToolDenialKindADenial(kind))
+                    : kind !== undefined && isCcToolDenialKindADenial(kind);
+                if (deniedCall) {
+                    const endToolNameRaw = ev.toolName;
+                    const endToolName = typeof endToolNameRaw === 'string' && endToolNameRaw.length > 0 ? endToolNameRaw : undefined;
+                    if (deniedToolNameByCallId.has(endCallId)) {
+                        if (deniedToolNameByCallId.get(endCallId) !== endToolName)
+                            deniedToolNameByCallId.set(endCallId, undefined);
+                    }
+                    else if (deniedToolNameByCallId.size >= TOOL_INPUT_JOIN_MAX_CALLS) {
+                        deniedCallsOverflowed = true;
+                    }
+                    else if (!deniedCallsOverflowed) {
+                        deniedToolNameByCallId.set(endCallId, endToolName);
+                    }
+                }
                 if (deniedBy !== undefined || kind !== undefined) {
                     const isNew = (deniedBy !== undefined && !gateDeniedByByCallId.has(endCallId)) ||
                         (kind !== undefined && !denialKindByCallId.has(endCallId));
@@ -298,14 +318,18 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 output: coerceOutput(sub.output),
                 isError: sub.isError,
             });
-            continue;
+            if (!(ctx.lane === 'print' && (sub.type === 'tool_start' || sub.type === 'tool_end')))
+                continue;
         }
         if (ev.type === 'turn_end') {
             const usageMissing = ev.usageMissing === true;
             if (usageMissing)
                 usageMissingObserved = true;
-            const stopReasonRaw = ev.stopReason;
+            const turnEndLoose = ev;
+            const stopReasonRaw = turnEndLoose.stopReason;
             const stopWord = typeof stopReasonRaw === 'string' && stopReasonRaw.length > 0 ? stopReasonRaw : undefined;
+            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
@@ -340,6 +364,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             engineUsage,
                             ...(usageMissing ? { usageMissing: true } : {}),
                             ...(stopWord !== undefined ? { stopReason: stopWord } : {}),
+                            ...(responseModelWord !== undefined ? { responseModel: responseModelWord } : {}),
                         });
                     }
                 }
@@ -362,6 +387,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             engineUsage,
                             ...(usageMissing ? { usageMissing: true } : {}),
                             ...(stopWord !== undefined ? { stopReason: stopWord } : {}),
+                            ...(responseModelWord !== undefined ? { responseModel: responseModelWord } : {}),
                         });
                     }
                     const rowKey = sourceTaskId !== undefined ? `s:${sourceTaskId}` : `p:${taskId}`;
@@ -389,6 +415,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                         ? { outputTokens }
                         : {}),
                     ...(stopWord !== undefined ? { _sema_stop_reason: stopWord } : {}),
+                    ...(responseModelWord !== undefined ? { _sema_response_model: responseModelWord } : {}),
                 };
             }
             continue;
@@ -453,6 +480,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 denialKindByCallId,
                 successfulToolEndObserved,
                 streamSawRunOpen,
+                deniedToolNameByCallId,
+                deniedCallsOverflowed,
             });
             const outcome = resultFrame.
                 _sema_outcome;

package/dist/adapter/types.d.ts

@@ -1,6 +1,7 @@
 import type { AgentEvent } 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';
 export type { ModelUsage, SDKMessage };
 export type StampedAgentEvent = AgentEvent & {
     id?: string;
@@ -16,6 +17,7 @@ export interface EmitContext {
     sessionId: string;
     startedAtMs?: number;
     model?: string;
+    lane?: RequestLane;
     emitChrome?(event: ChromeEvent): void | Promise<void>;
     onDroppedFrame?(info: DroppedFrameInfo): void;
 }

package/dist/agentsWireCaps.d.ts

@@ -69,6 +69,7 @@ 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 taskAgentsField(): {
     agents?: TaskAgentWireItem[];

package/dist/agentsWireCaps.js

@@ -194,6 +194,7 @@ let preparedKey = null;
 let preparedPromise = null;
 let payload;
 let capsVerdict;
+let settleGeneration = null;
 const emittedWarnings = new Set();
 function warnOnce(msg) {
     if (emittedWarnings.has(msg))
@@ -201,30 +202,57 @@ function warnOnce(msg) {
     emittedWarnings.add(msg);
     console.error(`[sema] ${msg}`);
 }
-async function runPrepare(cfg, projector) {
-    try {
-        const [caps, projected] = await Promise.all([
-            engineSupportsTaskAgents(cfg.baseUrl, {
-                authToken: cfg.authToken,
-                principal: cfg.principal,
-            }),
-            projector(),
-        ]);
-        capsVerdict = caps;
-        if (projected.agents && caps === false) {
-            warnOnce(`agents wire: this engine does not support per-task custom agents (capabilities.taskAgents absent/false — server <1.205 or multi-tenant) — ${projected.agents.length} custom agent definition(s) will NOT be sent`);
-            payload = undefined;
-            return;
-        }
+function applyProjectionIfCurrent(generation, projected) {
+    if (generation === null || preparedPromise !== generation)
+        return false;
+    const accepted = capsVerdict !== false;
+    if (accepted) {
         for (const w of projected.warnings)
             warnOnce(w);
         payload = projected.agents;
+    }
+    settleGeneration?.();
+    return accepted;
+}
+function startCapsProbe(cfg) {
+    const land = (verdict) => {
+        if (capsVerdict !== probe)
+            return verdict;
+        capsVerdict = verdict;
+        if (verdict === false) {
+            payload = undefined;
+            settleGeneration?.();
+        }
+        return verdict;
+    };
+    const probe = engineSupportsTaskAgents(cfg.baseUrl, {
+        authToken: cfg.authToken,
+        principal: cfg.principal,
+    }).then(land, () => land(undefined));
+    capsVerdict = probe;
+    return probe;
+}
+function capsSettled() {
+    return capsVerdict instanceof Promise ? capsVerdict : Promise.resolve();
+}
+async function runPrepare(cfg, projector, probe, generation) {
+    try {
+        const [caps, projected] = await Promise.all([probe, projector()]);
+        if (caps === false) {
+            if (projected.agents && preparedKey === cfg.baseUrl) {
+                warnOnce(`agents wire: this engine does not support per-task custom agents (capabilities.taskAgents absent/false — server <1.205 or multi-tenant) — ${projected.agents.length} custom agent definition(s) will NOT be sent`);
+            }
+            return;
+        }
+        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(', ')})`);
         }
     }
     catch (e) {
-        payload = undefined;
+        if (preparedPromise === generation)
+            payload = undefined;
         if (hostEnv().SEMA_DEBUG) {
             console.error('[sema] agents wire prepare soft-failed (no agents stamped):', e);
         }
@@ -235,21 +263,66 @@ export function prepareTaskAgentsWireWith(cfg, projector) {
     if (preparedPromise && preparedKey === key)
         return preparedPromise;
     preparedKey = key;
-    preparedPromise = runPrepare(cfg, projector);
     activeProjector = projector;
-    return preparedPromise;
+    const probe = startCapsProbe(cfg);
+    return startGeneration(generation => runPrepare(cfg, projector, probe, generation));
+}
+function startGeneration(run) {
+    let settle;
+    const generation = new Promise(resolve => {
+        settle = resolve;
+    });
+    const superseded = settleGeneration;
+    preparedPromise = generation;
+    settleGeneration = settle;
+    superseded?.();
+    void run(generation).then(settle, settle);
+    return generation;
+}
+export function invalidateTaskAgentsWire() {
+    const projector = activeProjector;
+    if (!preparedPromise || !projector)
+        return Promise.resolve();
+    payload = undefined;
+    return startGeneration(generation => runReproject(projector, generation));
+}
+async function runReproject(projector, generation) {
+    try {
+        let projected;
+        try {
+            projected = await projector();
+        }
+        catch (e) {
+            if (hostEnv().SEMA_DEBUG) {
+                console.error('[sema] agents wire re-project soft-failed (no agents stamped until the next successful projection):', e);
+            }
+            return;
+        }
+        await capsSettled();
+        applyProjectionIfCurrent(generation, projected);
+    }
+    catch {
+    }
 }
 export async function awaitTaskAgentsWire(timeoutMs = 4000) {
     if (!preparedPromise)
         return;
+    if (capsVerdict === false)
+        return;
     let timeoutHandle;
+    let timedOut = false;
+    const deadline = new Promise(resolve => {
+        timeoutHandle = setTimeout(() => {
+            timedOut = true;
+            resolve();
+        }, timeoutMs);
+    });
     try {
-        await Promise.race([
-            preparedPromise.catch(() => { }),
-            new Promise(resolve => {
-                timeoutHandle = setTimeout(resolve, timeoutMs);
-            }),
-        ]);
+        let waited = null;
+        while (!timedOut && preparedPromise !== null && preparedPromise !== waited) {
+            waited = preparedPromise;
+            await Promise.race([waited.catch(() => { }), deadline]);
+        }
     }
     finally {
         if (timeoutHandle !== undefined)
@@ -259,11 +332,18 @@ export async function awaitTaskAgentsWire(timeoutMs = 4000) {
 export function taskAgentsField() {
     const current = payload;
     if (preparedPromise && capsVerdict !== false && activeProjector) {
-        void activeProjector()
-            .then(p => {
-            for (const w of p.warnings)
-                warnOnce(w);
-            payload = p.agents;
+        const generation = preparedPromise;
+        let refreshing;
+        try {
+            refreshing = activeProjector();
+        }
+        catch {
+            return current ? { agents: current } : {};
+        }
+        void refreshing
+            .then(async (p) => {
+            await capsSettled();
+            applyProjectionIfCurrent(generation, p);
         })
             .catch(() => { });
     }
@@ -273,6 +353,7 @@ export function _resetAgentsWireForTest() {
     activeProjector = null;
     preparedKey = null;
     preparedPromise = null;
+    settleGeneration = null;
     payload = undefined;
     capsVerdict = undefined;
     emittedWarnings.clear();

package/dist/cloudConfigWireCaps.d.ts

@@ -16,7 +16,17 @@ export interface CloudMcpProjection {
 }
 export declare function cloudMcpToSpecs(servers: unknown, env: EnvLike): CloudMcpProjection;
 export declare function cloudSkillsToSpecs(manifestSkills: unknown, resolveBody: (contentHash: string) => string | null): SkillSpec[];
-export declare function cloudModelsToDoc(models: unknown): Rec | null;
+export interface CloudModelRefIssue {
+    readonly key: 'models' | 'default' | 'roles' | 'atModelAllowlist' | 'tierGroups' | 'activeTierGroup';
+    readonly at?: string;
+    readonly target?: string;
+    readonly reason: 'dangling' | 'rejected' | 'unreadable' | 'unsupported' | 'duplicate';
+    readonly outcome: 'dropped' | 'kept';
+}
+export interface CloudModelsDocOptions {
+    readonly entryAccepted?: (entry: object) => boolean;
+}
+export declare function cloudModelsToDoc(models: unknown, opts?: CloudModelsDocOptions): Rec | null;
 export interface CloudDroppedModel {
     id?: string;
     name?: string;
@@ -35,6 +45,62 @@ export interface CloudExecutionProjection {
 }
 export declare function cloudExecutionToPolicy(execution: unknown): CloudExecutionProjection;
 export declare function cloudRosterNames(rostersValue: unknown): string[];
+export interface CloudEffectiveWarning {
+    readonly kind: string;
+    readonly domain?: string;
+    readonly droppedNames?: readonly string[];
+    readonly keys?: readonly string[];
+    readonly path?: string;
+    readonly file?: string;
+    readonly why?: string;
+    readonly truncatedFrom?: number;
+}
+export type CloudEffectiveWarningsReading = {
+    readonly kind: 'reported';
+    readonly warnings: readonly CloudEffectiveWarning[];
+    readonly unreadable: number;
+} | {
+    readonly kind: 'unknown';
+};
+export interface CloudBudgetModelLimits {
+    readonly maxBudgetUsd?: number;
+    readonly tpmLimit?: number;
+    readonly rpmLimit?: number;
+}
+export interface CloudBudgetLimits {
+    readonly mode?: string;
+    readonly maxBudgetUsd?: number;
+    readonly budgetDuration?: string;
+    readonly tpmLimit?: number;
+    readonly rpmLimit?: number;
+    readonly maxParallelRequests?: number;
+    readonly perModel?: Readonly<Record<string, CloudBudgetModelLimits>>;
+    readonly maxRunCostUsd?: number;
+    readonly maxIterations?: number;
+    readonly enforcement?: string;
+}
+export type CloudBudgetReading = {
+    readonly kind: 'configured';
+    readonly limits: CloudBudgetLimits;
+    readonly uninterpretedKeys: readonly string[];
+} | {
+    readonly kind: 'not-configured';
+} | {
+    readonly kind: 'redacted';
+} | {
+    readonly kind: 'unknown';
+};
+export type CloudRuntimeCapsReading = {
+    readonly kind: 'configured';
+    readonly caps: Readonly<Record<string, boolean>>;
+    readonly uninterpretedKeys: readonly string[];
+} | {
+    readonly kind: 'not-configured';
+} | {
+    readonly kind: 'redacted';
+} | {
+    readonly kind: 'unknown';
+};
 export interface CloudProjection {
     mcp: McpServerSpec[];
     skills: SkillSpec[];
@@ -47,5 +113,14 @@ export interface CloudProjection {
     droppedMcpServers: CloudMcpDroppedServer[];
     droppedModels: CloudDroppedModel[];
     execution: CloudExecutionProjection;
+    effectiveWarnings: CloudEffectiveWarningsReading;
+    budget: CloudBudgetReading;
+    runtimeCaps: CloudRuntimeCapsReading;
+    modelRefIssues: CloudModelRefIssue[];
+}
+export declare function projectEffectiveBody(body: unknown, skillBodies: Record<string, string>, env: EnvLike, rostersValue?: unknown, opts?: CloudModelsDocOptions): CloudProjection;
+export interface CloudEffectiveNotice {
+    readonly level: 'warn' | 'info';
+    readonly text: string;
 }
-export declare function projectEffectiveBody(body: unknown, skillBodies: Record<string, string>, env: EnvLike, rostersValue?: unknown): CloudProjection;
+export declare function cloudEffectiveNotices(p: Pick<CloudProjection, 'effectiveWarnings' | 'budget' | 'runtimeCaps' | 'modelRefIssues'>): CloudEffectiveNotice[];