@theoremjs/agents 0.3.4-next.484.g20d8b9d → 0.3.4-next.508.geda6db0

package/esm/src/kernel/engine/runner/steps.js

@@ -7,6 +7,7 @@ import { resolveGuardrailPolicy } from '../../../guardrails/policy.js';
 import { replyIsJudged } from '../../../guardrails/progressive-yield.js';
 import { recordTaint } from '../../../guardrails/tool-result.js';
 import { waitDefault } from '../../../providers/shared/retry.js';
+import { ANSWER_TOOL, answersByTool, withAnswerTool } from '../../answer-tool.js';
 import { stepReplyMessages } from '../../interaction-parts.js';
 import { profileTurnOutputs } from '../../registry/profile-outputs.js';
 import { providerCompleteRequest } from '../../registry/provider-request.js';
@@ -60,14 +61,14 @@ function holdModelCall(calls, tool) {
     return true;
 }
 /** The step's request, with what it gives the model noted on `state`, and its call's usage and trace. */
-function startProviderCall(generation, system, state, answerOnly) {
+function startProviderCall(generation, system, state, answerOnly, labels) {
     const usage = startCallUsage(system.text, {
         history: state.currentHistory,
         input: generation.input,
     });
     state.lastCall = usage;
     const genForStep = generationForProviderStep(generation, state, answerOnly);
-    const request = providerCompleteRequest(state.tools, genForStep, system.text);
+    const request = withAnswerTool(providerCompleteRequest(state.tools, genForStep, system.text), generation, labels);
     addRequestUrls(state.givenUrls, request);
     addRequestDestinations(state.destinations, request, state.givenUrls.own);
     if (generation.canary && !state.canaryGiven) {
@@ -118,6 +119,42 @@ function tallyCallEvent(event, tally, call) {
         tally.replied = true;
     return false;
 }
+/**
+ * The structured output the call gave through the answer tool, shown as the step's, with the answer
+ * tool's calls taken out of the step's calls. An answer ends the turn, so the step's other calls do
+ * not run, and the call that gave it completed.
+ */
+async function* showAnswer(shown, tally, step) {
+    if (!answersByTool(step.generation))
+        return;
+    const answer = tally.calls.find((call) => call.name === ANSWER_TOOL && !call.failure);
+    tally.calls = answer ? [] : tally.calls.filter((call) => call.name !== ANSWER_TOOL);
+    if (!answer)
+        return;
+    if (tally.stop?.kind === 'tool') {
+        tally.stop = { kind: 'completed' };
+        step.state.lastStop = tally.stop;
+    }
+    const event = { type: 'structured', structured: answer.arguments };
+    if (tallyCallEvent(event, tally, step.call))
+        return;
+    if (releasesNow(event, step.control, step.state, step.buffer))
+        yield* shown.show(event);
+}
+/**
+ * A tool call's preview. The answer tool's streams as the structured reply's draft.
+ *
+ * why: A preview of the call that follows, which owns the arguments: not the turn's record. It streams
+ * as the reply's text does, through its own gate, and like that text is held only when delivery is buffered.
+ */
+async function* showToolDraft(event, shown, generation, buffer) {
+    if (buffer.holdVisible)
+        return;
+    if (event.name === ANSWER_TOOL && answersByTool(generation))
+        yield* shown.draft(event.text);
+    else
+        yield event;
+}
 /** What sets one model call's text apart from the reply text before it: a blank line. */
 const CALL_BREAK = '\n\n';
 /**
@@ -130,7 +167,8 @@ function withCallBreak(event, tally, state, generation) {
     if (tally.text)
         return event;
     const before = state.replyText;
-    const breaks = before && generation.structured === null && !/\s$/.test(before) && !/^\s/.test(event.text);
+    const prose = generation.structured === null || answersByTool(generation);
+    const breaks = before && prose && !/\s$/.test(before) && !/^\s/.test(event.text);
     tally.replyAt = before.length + (breaks ? CALL_BREAK.length : 0);
     return breaks ? { ...event, text: `${CALL_BREAK}${event.text}` } : event;
 }
@@ -194,7 +232,7 @@ async function* executeAutonomousStep(args, state, buffer = {
     holdVisible: false,
 }) {
     const { profile, generation, system, provider, signal } = args;
-    const { usage, genForStep, request, call } = startProviderCall(generation, system, state, isAnswerOnlyStep(profile, generation, state.stepCount));
+    const { usage, genForStep, request, call } = startProviderCall(generation, system, state, isAnswerOnlyStep(profile, generation, state.stepCount), profile.labels);
     const tally = { calls: [], reasoning: [], text: '', failures: [], replied: false };
     const control = {
         withholdVisible: false,
@@ -209,7 +247,7 @@ async function* executeAutonomousStep(args, state, buffer = {
         canaryGiven: state.canaryGiven,
         ...(state.ownTools ? { ownTools: state.ownTools } : {}),
     };
-    const shown = new StructuredDrafts(seen);
+    const shown = new StructuredDrafts({ ...seen, generation });
     try {
         for await (const event of yieldProviderEvents({
             ...seen,
@@ -219,6 +257,7 @@ async function* executeAutonomousStep(args, state, buffer = {
             signal,
             control,
             tools: state.tools,
+            answerTool: answersByTool(generation),
         })) {
             if (observeCallEvent(usage, event))
                 continue;
@@ -234,14 +273,11 @@ async function* executeAutonomousStep(args, state, buffer = {
                 continue;
             }
             if (event.type === 'tool_draft') {
-                // why: A preview of the call that follows, which owns the arguments: not the turn's record. It streams
-                // as the reply's text does, through its own gate, and like that text is held only when delivery is buffered.
-                if (!buffer.holdVisible)
-                    yield event;
+                yield* showToolDraft(event, shown, generation, buffer);
                 continue;
             }
             // why: The model's history keeps what it wrote; only the reply the host gets is set apart.
-            const next = event.type === 'text' ? withCallBreak(event, tally, state, genForStep) : event;
+            const next = event.type === 'text' ? withCallBreak(event, tally, state, generation) : event;
             if (tallyCallEvent(event, tally, call))
                 continue;
             if (!releasesNow(next, control, state, buffer))
@@ -254,6 +290,7 @@ async function* executeAutonomousStep(args, state, buffer = {
         throw err;
     }
     yield* shown.end();
+    yield* showAnswer(shown, tally, { generation, state, control, buffer, call });
     keepStreamCarry(state, control);
     const resume = resumeOf(args.mayResume, profile, tally);
     if (!resume) {

package/esm/src/kernel/engine/runner/stream.d.ts

@@ -24,18 +24,20 @@ interface OutboundStreamControl {
 declare function shouldSkipStreamEvent(event: ModelEvent, profile: Profile): boolean;
 /** Host-visible output a mid-stream block withholds. A thought is never withheld, only omitted from. */
 declare function isWithheldOnBlock(event: ModelEvent): boolean;
+export type ShownGeneration = Pick<ResolvedGeneration, 'structured' | 'stream' | 'tools'>;
 /**
- * An event as the host gets it, or nothing. The text of a call that asked for structured output is
- * that output's JSON: under `sse` it goes out as `structured_draft`, and under `buffered` not at all,
- * since the `structured` event is the reply whole. The turn keeps it as text, which its checks,
- * repairs and history read.
+ * An event as the host gets it, or nothing. On a turn that answers through a response format, the
+ * text is that output's JSON: under `sse` it goes out as `structured_draft`, and under `buffered`
+ * not at all, since the `structured` event is the reply whole. The turn keeps it as text, which its
+ * checks, repairs and history read. On a turn that answers by tool, the text is progress.
  */
-declare function shownToHost(event: TurnEvent, generation: Pick<ResolvedGeneration, 'structured' | 'stream'>): TurnEvent | undefined;
+declare function shownToHost(event: TurnEvent, generation: ShownGeneration): TurnEvent | undefined;
 /**
  * A step's events as the host gets them (`shownToHost`), with a structured reply's drafts read
- * first at `reply_structured`, where the whole is read. The reply's text has already passed the
- * `reply` gate; a match at `reply_structured` stops the drafts, and the `structured` event still
- * arrives as that check leaves it. The held tail is read and released when the step's stream ends.
+ * first at `reply_structured`, where the whole is read. The drafts are the reply's text, or the
+ * answer tool's arguments as the model writes them. Text has already passed the `reply` gate; a
+ * match at `reply_structured` stops the drafts, and the `structured` event still arrives as that
+ * check leaves it. The held tail is read and released when the step's stream ends.
  */
 declare class StructuredDrafts {
     private readonly drafts;
@@ -43,6 +45,8 @@ declare class StructuredDrafts {
     /** Reads the stream's own checks off what the step knows of the turn. */
     constructor(seen: Pick<StreamArgs, 'profile' | 'generation' | 'privateSystem' | 'givenUrls' | 'canaryGiven' | 'ownTools'>);
     show(event: TurnEvent): AsyncGenerator<TurnEvent>;
+    /** Part of the structured output's JSON, as the model writes it. */
+    draft(json: string): AsyncGenerator<TurnEvent>;
     /** The drafts' tail the gate still holds, once the step's stream has ended. */
     end(): Generator<TurnEvent>;
 }
@@ -65,6 +69,8 @@ interface StreamArgs {
     ownTools?: OwnTools;
     /** The turn's tools: a draft is read at the boundary its tool's calls are. */
     tools: ToolRegistry;
+    /** True when the turn answers through the answer tool (`answersByTool`). */
+    answerTool?: boolean;
 }
 declare function yieldProviderEvents(args: StreamArgs): AsyncGenerator<StreamEvent>;
 export type { OutboundStreamControl, StreamArgs };

package/esm/src/kernel/engine/runner/stream.js

@@ -7,6 +7,7 @@ import { resolveGuardrailPolicy } from '../../../guardrails/policy.js';
 import { createDraftGate, createOutboundProgressiveGate, DraftReader, } from '../../../guardrails/progressive-yield.js';
 import { EGRESS_RULES } from '../../../guardrails/rules.js';
 import { thoughtGuardFor, } from '../../../guardrails/thought-guard.js';
+import { ANSWER_TOOL, answersByTool } from '../../answer-tool.js';
 import { profileTurnOutputs } from '../../registry/profile-outputs.js';
 import { toolArgumentsBoundary } from '../../tools/execute.js';
 function shouldSkipStreamEvent(event, profile) {
@@ -69,21 +70,22 @@ function isWithheldOnBlock(event) {
     return event.type === 'text' || event.type === 'media';
 }
 /**
- * An event as the host gets it, or nothing. The text of a call that asked for structured output is
- * that output's JSON: under `sse` it goes out as `structured_draft`, and under `buffered` not at all,
- * since the `structured` event is the reply whole. The turn keeps it as text, which its checks,
- * repairs and history read.
+ * An event as the host gets it, or nothing. On a turn that answers through a response format, the
+ * text is that output's JSON: under `sse` it goes out as `structured_draft`, and under `buffered`
+ * not at all, since the `structured` event is the reply whole. The turn keeps it as text, which its
+ * checks, repairs and history read. On a turn that answers by tool, the text is progress.
  */
 function shownToHost(event, generation) {
-    if (!generation.structured || event.type !== 'text')
+    if (!generation.structured || answersByTool(generation) || event.type !== 'text')
         return event;
     return generation.stream === false ? undefined : { type: 'structured_draft', text: event.text };
 }
 /**
  * A step's events as the host gets them (`shownToHost`), with a structured reply's drafts read
- * first at `reply_structured`, where the whole is read. The reply's text has already passed the
- * `reply` gate; a match at `reply_structured` stops the drafts, and the `structured` event still
- * arrives as that check leaves it. The held tail is read and released when the step's stream ends.
+ * first at `reply_structured`, where the whole is read. The drafts are the reply's text, or the
+ * answer tool's arguments as the model writes them. Text has already passed the `reply` gate; a
+ * match at `reply_structured` stops the drafts, and the `structured` event still arrives as that
+ * check leaves it. The held tail is read and released when the step's stream ends.
  */
 class StructuredDrafts {
     drafts;
@@ -102,9 +104,15 @@ class StructuredDrafts {
                 yield shown;
             return;
         }
-        const text = await this.drafts.read(shown.text);
+        yield* this.draft(shown.text);
+    }
+    /** Part of the structured output's JSON, as the model writes it. */
+    async *draft(json) {
+        if (this.generation.stream === false)
+            return;
+        const text = await this.drafts.read(json);
         if (text)
-            yield { ...shown, text };
+            yield { type: 'structured_draft', text };
     }
     /** The drafts' tail the gate still holds, once the step's stream has ended. */
     *end() {
@@ -131,11 +139,13 @@ class ToolDrafts {
     policy;
     context;
     tools;
+    answerTool;
     drafts = new Map();
-    constructor(policy, context, tools) {
+    constructor(policy, context, tools, answerTool) {
         this.policy = policy;
         this.context = context;
         this.tools = tools;
+        this.answerTool = answerTool;
     }
     /**
      * Shows `event` when it is a draft and says whether it was; any other event closes its call's
@@ -178,7 +188,9 @@ class ToolDrafts {
             this.drafts.delete(event.tool.callId);
     }
     async open(event) {
-        const boundary = toolArgumentsBoundary(this.tools, event.name);
+        // why: The answer's drafts are the structured output's, read at `reply_structured` by `StructuredDrafts`.
+        const answer = this.answerTool && event.name === ANSWER_TOOL;
+        const boundary = answer ? undefined : toolArgumentsBoundary(this.tools, event.name);
         const gate = boundary ? await createDraftGate(this.policy, this.context, boundary) : null;
         const draft = { name: event.name, gate };
         this.drafts.set(event.callId, draft);
@@ -216,7 +228,7 @@ async function* yieldProviderEvents(args) {
     const { canaryCarry, thoughtCarry } = control ?? {};
     const gate = await createOutboundProgressiveGate(policy, context, 'reply', canaryCarry);
     const thoughts = await thoughtGuardFor(policy, context, thoughtCarry);
-    const drafts = new ToolDrafts(policy, context, args.tools);
+    const drafts = new ToolDrafts(policy, context, args.tools, args.answerTool === true);
     /** The streamed event whose reply sits in the gate's lookback; released tails keep its shape. */
     let pendingStream = null;
     let withholdVisible = false;

package/esm/src/kernel/mod.d.ts

@@ -29,7 +29,7 @@ export { outOfScopeFields, profileTypesForField } from './profile-scope.js';
 export type { DecisionModelBinding, ModelBinding, RuntimeAbilities } from './protocols/binding.js';
 export { checkBinding, commonModelSettingsSchema, decisionModelBindingSchema, keySlotSchema, keySlotsOf, modelBindingSchema, } from './protocols/binding.js';
 export type { ProviderLimits } from './protocols/limits.js';
-export { providerLimitsSchema, resolveProviderLimits } from './protocols/limits.js';
+export { providerLimitsSchema } from './protocols/limits.js';
 export type { EstimatedCost, ModelPrice, PriceTable, Rates } from './protocols/prices.js';
 export { costFromPrices } from './protocols/prices.js';
 export type { Continuation, DecisionCall, EmbeddingCall, EmbeddingMediaKind, EmbeddingModelLimits, ExtensionBodyAt, ExtensionReader, LiveToolResult, ModelProfileType, Protocol, ProtocolContentEvent, ProtocolContext, ProtocolDefinition, ProtocolEvent, ProtocolExtension, ProtocolOperations, ProtocolRequest, ProtocolSession, ProtocolSocket, SendInit, UpstreamFailure, } from './protocols/protocol.js';

package/esm/src/kernel/mod.js

@@ -18,7 +18,7 @@ export { PROFILE_GRAPH, profileGraphFacet, spineFacetsForProfileType, } from './
 export { unsetValue } from './profile-presence.js';
 export { outOfScopeFields, profileTypesForField } from './profile-scope.js';
 export { checkBinding, commonModelSettingsSchema, decisionModelBindingSchema, keySlotSchema, keySlotsOf, modelBindingSchema, } from './protocols/binding.js';
-export { providerLimitsSchema, resolveProviderLimits } from './protocols/limits.js';
+export { providerLimitsSchema } from './protocols/limits.js';
 export { costFromPrices } from './protocols/prices.js';
 export { carriesTo, defineProtocol, extendProtocol, modelOptions } from './protocols/protocol.js';
 export { bearer, createProviderRegistry, defineProvider, endpointUrlSchema, header, query, } from './protocols/provider.js';

package/esm/src/kernel/profile-presence.js

@@ -40,6 +40,18 @@ export const PROFILE_FIELD_PRESENCE = {
     },
     'models.*.allowEffortSelect': { unset: 'Off', value: false },
     'models.*.timeoutMs': { unset: 'No timeout' },
+    'models.*.limits': { unset: 'No limits' },
+    ...Object.fromEntries([
+        'operationTimeoutMs',
+        'connectTimeoutMs',
+        'liveStepTimeoutMs',
+        'maxWireRecordBytes',
+        'maxWireResponseBytes',
+        'maxEventBytes',
+        'maxStepBytes',
+        'maxStepEvents',
+        'maxPendingToolCalls',
+    ].map((field) => [`models.*.limits.${field}`, { unset: 'No limit' }])),
     'models.*.compaction': { unset: 'Off' },
     'models.*.compaction.maxTokens': { required: true },
     'models.*.compaction.compactAt': { required: true },

package/esm/src/kernel/profile-scope.js

@@ -25,10 +25,10 @@ const MODEL_PROFILE_TYPES = [
 const TURN_TYPES = ['text', 'image', 'speech', 'live'];
 /** Types whose `inputs` are turn inputs (text, files, slots) rather than decision state. */
 const TURN_INPUT_TYPES = ['text', 'image'];
-const TURN_INPUT_REASON = 'a decision takes JSON state, not turn text, files, or slots';
+const TURN_INPUT_REASON = 'a decision takes JSON state, and live takes its input through live.ingress';
 /** Types that take slots and context: the turn types, and a call. */
 const SLOT_TYPES = ['text', 'image', 'live'];
-const SLOT_REASON = 'a decision takes JSON state, and speech reads its transcript only';
+const SLOT_REASON = 'a decision takes JSON state, and an embedding call embeds its input alone';
 /** Guardrails a host profile may set keep `host`; the rest guard a model turn. */
 function turnGuardrailTypes(key) {
     return HOST_GUARDRAIL_FIELDS.includes(key)
@@ -79,11 +79,11 @@ export const PROFILE_FIELD_SCOPE = {
     },
     'identity.system': {
         profileTypes: ['text', 'image', 'live'],
-        reason: 'speech has no system channel (the input text is the transcript) and a decision is asked only through its questions',
+        reason: 'speech has no system channel (the input text is the transcript), a decision is asked only through its questions, and an embedding call embeds its input alone',
     },
     'identity.systemByRole': {
         profileTypes: ['text', 'image', 'live'],
-        reason: 'speech has no system channel (the input text is the transcript) and a decision is asked only through its questions',
+        reason: 'speech has no system channel (the input text is the transcript), a decision is asked only through its questions, and an embedding call embeds its input alone',
     },
     models: { profileTypes: MODEL_PROFILE_TYPES, reason: 'a host profile runs no model' },
     'models.*.protocol': {
@@ -96,7 +96,7 @@ export const PROFILE_FIELD_SCOPE = {
     },
     'models.*.compaction': {
         profileTypes: ['text', 'image', 'speech'],
-        reason: 'live compacts with live.contextCompression',
+        reason: 'live compacts with live.contextCompression, and decision and embedding calls keep no conversation to compact',
     },
     'profile.defaultModel': {
         profileTypes: [...TURN_TYPES, 'embedding'],
@@ -116,7 +116,7 @@ export const PROFILE_FIELD_SCOPE = {
     live: { profileTypes: ['live'], reason: 'only live profiles open a realtime session' },
     tools: {
         profileTypes: ['text', 'image', 'live', 'host'],
-        reason: 'speech and decision profiles call no tools',
+        reason: 'speech, decision, and embedding profiles call no tools',
     },
     'tools.t1Policy': {
         profileTypes: ['text', 'image'],
@@ -132,7 +132,7 @@ export const PROFILE_FIELD_SCOPE = {
     },
     'inputs.voice': {
         profileTypes: ['text'],
-        reason: 'no image model reads audio, and a decision takes JSON state',
+        reason: 'no image model reads audio, live takes audio through live.ingress, a decision takes JSON state, and an embedding call takes text and files',
     },
     'inputs.text': {
         profileTypes: [...TURN_INPUT_TYPES, 'embedding'],
@@ -176,7 +176,7 @@ export const PROFILE_FIELD_SCOPE = {
     },
     outputs: {
         profileTypes: ['text', 'image', 'speech'],
-        reason: 'live output is the realtime session, and decision and host profiles produce no turn output',
+        reason: 'live output is the realtime session, and decision, embedding, and host profiles produce no turn output',
     },
     'outputs.structured': {
         profileTypes: ['text'],
@@ -205,27 +205,27 @@ export const PROFILE_FIELD_SCOPE = {
     },
     'guardrails.quota': {
         profileTypes: turnGuardrailTypes('quota'),
-        reason: 'quota counts model turns',
+        reason: 'quota counts model turns, and decision, embedding, and host profiles run none',
     },
     'guardrails.detect': {
         profileTypes: turnGuardrailTypes('detect'),
-        reason: 'the decision path runs none of the turn guardrails',
+        reason: 'decision and embedding calls run none of the turn guardrails',
     },
     'guardrails.blockedReply': {
         profileTypes: ['text', 'image', 'live'],
-        reason: 'only a reply can be blocked, and speech, decision, and host profiles write none',
+        reason: 'only a reply can be blocked, and speech, decision, embedding, and host profiles write none',
     },
     'guardrails.network': {
         profileTypes: ['text', 'image', 'live', 'host'],
-        reason: 'speech and decision profiles call no tools',
+        reason: 'speech, decision, and embedding profiles call no tools',
     },
     'guardrails.taint': {
         profileTypes: ['text', 'image', 'live'],
-        reason: 'speech and decision profiles call no tools, and a host profile runs no turn to taint',
+        reason: 'speech, decision, and embedding profiles call no tools, and a host profile runs no turn to taint',
     },
     'guardrails.disclosure': {
         profileTypes: ['decision'],
-        reason: 'disclosure gates state leaving a decision profile for its model',
+        reason: 'only a decision profile sends state to its model, and disclosure gates that state',
     },
 };
 /**

package/esm/src/kernel/protocols/binding.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { type JsonObject } from '../json.js';
 import { type KeySlot } from '../schema.js';
+import { type ProviderLimits } from './limits.js';
 import { type ModelProfileType, type Protocol } from './protocol.js';
 import type { RegisteredProvider } from './provider.js';
 /** A vault slot name. */
@@ -31,9 +32,10 @@ export interface ModelBinding extends z.infer<typeof commonModelSettingsSchema>
     keySlot?: string;
     fallbackKeySlot?: string;
     options?: JsonObject;
+    limits?: ProviderLimits;
 }
 /** A decision profile's model: no generation settings, and a time limit. */
-export interface DecisionModelBinding extends Pick<ModelBinding, 'protocol' | 'provider' | 'apiId' | 'keySlot' | 'fallbackKeySlot' | 'options'> {
+export interface DecisionModelBinding extends Pick<ModelBinding, 'protocol' | 'provider' | 'apiId' | 'keySlot' | 'fallbackKeySlot' | 'options' | 'limits'> {
     timeoutMs?: number;
 }
 export declare const modelBindingSchema: z.ZodType<ModelBinding>;

package/esm/src/kernel/protocols/binding.js

@@ -3,6 +3,7 @@ import { TheoremError } from '../../guardrails/error.js';
 import { labelText } from '../../guardrails/labels.js';
 import { jsonObjectSchema } from '../json.js';
 import { KEY_SLOT_NAME } from '../schema.js';
+import { providerLimitsSchema } from './limits.js';
 import { modelOptions } from './protocol.js';
 /** A vault slot name. */
 export const keySlotSchema = z.string().regex(KEY_SLOT_NAME);
@@ -61,6 +62,10 @@ const modelBinding = z.strictObject({
         .optional()
         // labels-exempt: builder field description, read by the studio and docs
         .describe("What this model's protocol takes beyond the shared settings."),
+    limits: providerLimitsSchema
+        .optional()
+        // labels-exempt: builder field description, read by the studio and docs
+        .describe("Theorem's cut-offs for this model's calls; each one left out is no limit."),
 });
 true;
 export const modelBindingSchema = modelBinding;
@@ -72,6 +77,7 @@ const decisionModelBinding = modelBinding
     keySlot: true,
     fallbackKeySlot: true,
     options: true,
+    limits: true,
 })
     .extend({
     timeoutMs: z

package/esm/src/kernel/protocols/limits.d.ts

@@ -1,15 +1,14 @@
 import { z } from 'zod';
-/** The budgets every provider call runs under; a host may tighten or loosen each. */
+/** The budgets a provider call runs under. Each one left out is no limit: the provider's own applies. */
 export interface ProviderLimits {
-    operationTimeoutMs: number;
-    connectTimeoutMs: number;
-    liveStepTimeoutMs: number;
-    maxWireRecordBytes: number;
-    maxWireResponseBytes: number;
-    maxEventBytes: number;
-    maxStepBytes: number;
-    maxStepEvents: number;
-    maxPendingToolCalls: number;
+    operationTimeoutMs?: number;
+    connectTimeoutMs?: number;
+    liveStepTimeoutMs?: number;
+    maxWireRecordBytes?: number;
+    maxWireResponseBytes?: number;
+    maxEventBytes?: number;
+    maxStepBytes?: number;
+    maxStepEvents?: number;
+    maxPendingToolCalls?: number;
 }
 export declare const providerLimitsSchema: z.ZodType<ProviderLimits>;
-export declare function resolveProviderLimits(overrides?: Partial<ProviderLimits>): ProviderLimits;

package/esm/src/kernel/protocols/limits.js

@@ -2,27 +2,13 @@ import { z } from 'zod';
 const positiveBudget = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
 const timerBudget = positiveBudget.max(2147483647);
 export const providerLimitsSchema = z.strictObject({
-    operationTimeoutMs: timerBudget,
-    connectTimeoutMs: timerBudget,
-    liveStepTimeoutMs: timerBudget,
-    maxWireRecordBytes: positiveBudget,
-    maxWireResponseBytes: positiveBudget,
-    maxEventBytes: positiveBudget,
-    maxStepBytes: positiveBudget,
-    maxStepEvents: positiveBudget,
-    maxPendingToolCalls: positiveBudget,
+    operationTimeoutMs: timerBudget.optional(),
+    connectTimeoutMs: timerBudget.optional(),
+    liveStepTimeoutMs: timerBudget.optional(),
+    maxWireRecordBytes: positiveBudget.optional(),
+    maxWireResponseBytes: positiveBudget.optional(),
+    maxEventBytes: positiveBudget.optional(),
+    maxStepBytes: positiveBudget.optional(),
+    maxStepEvents: positiveBudget.optional(),
+    maxPendingToolCalls: positiveBudget.optional(),
 });
-export function resolveProviderLimits(overrides = {}) {
-    return Object.freeze(providerLimitsSchema.parse({
-        operationTimeoutMs: 120000,
-        connectTimeoutMs: 30000,
-        liveStepTimeoutMs: 120000,
-        maxWireRecordBytes: 16 * 1024 * 1024,
-        maxWireResponseBytes: 64 * 1024 * 1024,
-        maxEventBytes: 16 * 1024 * 1024,
-        maxStepBytes: 64 * 1024 * 1024,
-        maxStepEvents: 100000,
-        maxPendingToolCalls: 32,
-        ...overrides,
-    }));
-}

package/esm/src/kernel/protocols/runtime.d.ts

@@ -3,7 +3,7 @@ import { type JsonObject } from '../json.js';
 import type { KeyVault } from '../registry/vault.js';
 import type { DecisionResult, KeySlot } from '../types.js';
 import { type DecisionModelBinding, type ModelBinding } from './binding.js';
-import { type ProviderLimits } from './limits.js';
+import type { ProviderLimits } from './limits.js';
 import type { DecisionCall, EmbeddingCall, EmbeddingResult, ModelProfileType, ProtocolOperations } from './protocol.js';
 import type { RegisteredProvider } from './provider.js';
 /** Opens a WebSocket with the headers and subprotocols a sign-in put on it. */
@@ -18,7 +18,8 @@ export type OpenWebSocket = (url: string, init: {
 export declare function plainWebSocket(provider: string): OpenWebSocket;
 /** What a host lends every provider call: its keys, its network, its clock, and its budgets. */
 export interface ProviderHostOptions {
-    limits?: Partial<ProviderLimits>;
+    /** Overrides the model's own `limits`, one field at a time. */
+    limits?: ProviderLimits;
     vault?: KeyVault;
     fetch?: typeof fetch;
     wait?: Wait;

package/esm/src/kernel/protocols/runtime.js

@@ -7,7 +7,6 @@ import { KEY_FALLBACK_ROW } from '../../providers/types.js';
 import { jsonValueSchema } from '../json.js';
 import { bytesToBase64 } from '../util/base64.js';
 import { bindingServe, keySlotsOf, } from './binding.js';
-import { resolveProviderLimits } from './limits.js';
 import { costFromPrices } from './prices.js';
 /**
  * The runtime's own WebSocket. It takes no headers, so a sign-in that needs them is refused; a host
@@ -249,7 +248,7 @@ function protocolContext(setup, slot, raw, wire = { sent: false }, asked = []) {
         apiId,
         options: setup.binding.options ?? {},
         builtInTools,
-        limits: setup.limits ?? resolveProviderLimits(),
+        limits: setup.limits ?? setup.binding.limits ?? {},
         ...(setup.signal ? { signal: setup.signal } : {}),
         tapUpstream: tap,
         async *send(body, init) {

package/esm/src/kernel/provider-budget.d.ts

@@ -11,9 +11,9 @@ export declare class ProviderBudget {
     private stepBytes;
     private stepEvents;
     private calls;
-    private deadline;
+    private deadline?;
     private releaseSignal;
-    constructor(limits: ProviderLimits, caller?: AbortSignal, timeoutMs?: number);
+    constructor(limits: ProviderLimits, caller?: AbortSignal, timeoutMs?: number | undefined);
     resumeOperation(): void;
     /** Milliseconds before the running timer ends the call. */
     timeLeft(): number;