@cognipeer/agent-sdk 0.19.0 → 0.22.0

package/dist/index.d.cts

@@ -1,7 +1,7 @@
 import { ZodError, ZodSchema, z, ZodTypeAny } from 'zod';
 import { JSONSchema7 } from 'json-schema';
-import { P as ProviderType, M as ModelRuleLearnedEvent, E as EmbeddingRequest, a as EmbeddingResponse, C as ChatCompletionRequest, b as ChatCompletionResponse, c as ChatCompletionChunk, J as JevProviderConfig, O as OpenAICompatibleProviderConfig, d as OpenAIProviderConfig, R as RulePatch, U as UnifiedMessage, T as ToolDefinition, e as TokenUsage, A as AnthropicProviderConfig, f as AzureProviderConfig, B as BedrockProviderConfig, V as VertexProviderConfig, g as ReasoningRequestConfig, h as ProviderConfig, i as ProviderError } from './model-rules--welxWDw.cjs';
-export { a4 as AudioContent, I as EffortMapping, a0 as EmbeddingInputType, $ as EmbeddingUsage, a3 as FileContent, Z as FinishReason, a2 as ImageContent, v as MAX_ADJUSTMENTS, k as MODEL_RULES, W as MaxTokensParam, D as ModelRule, F as ModelRules, Q as OffMechanism, Y as ParsedModelError, _ as ProviderResponseFields, a5 as ProviderToolCall, a6 as ProviderTransportConfig, H as ReasoningEffort, N as ReasoningStyle, G as ResolvedModelRule, K as RuleFamily, L as RuleSource, X as SamplingField, S as TemperatureRule, a1 as TextContent, n as allowsSampling, o as applyDropParams, u as asModelRequestError, z as clearLearnedModelRules, p as effortBudget, j as emptyUsage, x as getLearnedModelRulePatch, w as listLearnedModelRules, m as mapReasoningEffort, q as mergeRulePatch, l as modelIdCandidates, s as parseModelError, y as rememberModelRulePatch, r as resolveModelRule, t as runWithModelAdjustments } from './model-rules--welxWDw.cjs';
+import { P as ProviderType, M as ModelRuleLearnedEvent, E as EmbeddingRequest, a as EmbeddingResponse, C as ChatCompletionRequest, b as ChatCompletionResponse, c as ChatCompletionChunk, J as JevProviderConfig, O as OpenAICompatibleProviderConfig, d as OpenAIProviderConfig, R as RulePatch, U as UnifiedMessage, e as ReasoningBlock, T as ToolDefinition, f as TokenUsage, A as AnthropicProviderConfig, g as AzureProviderConfig, B as BedrockProviderConfig, h as PromptCachingConfig, V as VertexProviderConfig, i as ReasoningRequestConfig, j as ProviderConfig, k as ProviderError } from './model-rules-D6teB4rU.cjs';
+export { a6 as AudioContent, L as EffortMapping, a2 as EmbeddingInputType, a1 as EmbeddingUsage, a5 as FileContent, $ as FinishReason, a4 as ImageContent, x as MAX_ADJUSTMENTS, m as MODEL_RULES, Y as MaxTokensParam, G as ModelRule, H as ModelRules, W as OffMechanism, _ as ParsedModelError, a0 as ProviderResponseFields, a7 as ProviderToolCall, a8 as ProviderTransportConfig, K as ReasoningEffort, S as ReasoningStyle, I as ResolvedModelRule, N as RuleFamily, Q as RuleSource, Z as SamplingField, X as TemperatureRule, a3 as TextContent, p as allowsSampling, q as applyDropParams, w as asModelRequestError, F as clearLearnedModelRules, s as effortBudget, l as emptyUsage, z as getLearnedModelRulePatch, y as listLearnedModelRules, n as mapReasoningEffort, t as mergeRulePatch, o as modelIdCandidates, u as parseModelError, D as rememberModelRulePatch, r as resolveModelRule, v as runWithModelAdjustments } from './model-rules-D6teB4rU.cjs';
 
 /** Describes what a model/provider natively supports. */
 type ModelCapabilities = {
@@ -274,6 +274,9 @@ declare function mapTextParts(content: string | ContentPart[] | unknown, fn: (te
  * and the rest are dropped — media parts keep their positions either way. A
  * plugin that needs exact multi-part fidelity should return `content` instead,
  * which is why that field exists.
+ *
+ * A prompt-cache breakpoint is not lost with a merged-away part: when the first
+ * text part carries none, it takes the last one the dropped parts carried.
  */
 declare function replaceTextContent(content: string | ContentPart[] | unknown, text: string): string | ContentPart[] | unknown;
 /** Every non-text part of a message, normalized for policy code. */
@@ -933,11 +936,19 @@ type ContextBuilder = {
         defaultMessages: Message[];
     }, ctx: HookContext): MaybePromise<Message[]>;
 };
+/**
+ * USD cost of one model call. `inputTokens` is INCLUSIVE: uncached + cache read +
+ * cache write. `cachedInputTokens` (cache read) and `cacheWriteTokens` (cache
+ * write) are subsets of it, `reasoningTokens` is a subset of `outputTokens`, so
+ * a price table bills `(input - cached - cacheWrite) * in + cached * read +
+ * cacheWrite * write + output * out`.
+ */
 type CostEstimator = (args: {
     modelName?: string;
     inputTokens: number;
     outputTokens: number;
     cachedInputTokens?: number;
+    cacheWriteTokens?: number;
     reasoningTokens?: number;
 }) => number;
 /**
@@ -1431,6 +1442,10 @@ type ImageURL = {
 type ContentPart = {
     type: 'text';
     text: string;
+    cacheControl?: {
+        type: 'ephemeral';
+        ttl?: '5m' | '1h';
+    };
 } | {
     type: 'image_url';
     image_url: ImageURL;
@@ -1677,12 +1692,15 @@ type AgentOptions = {
      * Pluggable cost estimator: returns USD cost for a single model call's
      * usage. Used by the `maxCostUsd` budget limit. When omitted the SDK has
      * no built-in pricing table and the cost limit is a no-op.
+     * `inputTokens` is inclusive (uncached + cache read + cache write);
+     * `cachedInputTokens` and `cacheWriteTokens` are subsets of it.
      */
     costEstimator?: (args: {
         modelName?: string;
         inputTokens: number;
         outputTokens: number;
         cachedInputTokens?: number;
+        cacheWriteTokens?: number;
         reasoningTokens?: number;
     }) => number;
     /**
@@ -1920,6 +1938,19 @@ type SmartAgentSummarizationConfig = {
      * rendered to every later turn as "still in force — follow them".
      */
     groundDirectives?: boolean;
+    /**
+     * Output-token cap of the summarizer call (default 8192; `0` sends no cap). The
+     * summary is a bounded JSON document; a cap far below it cuts the reply off and
+     * the pass is skipped (see `status: "fallback"`), while no cap leaves the provider
+     * default, which on some providers is a few hundred tokens.
+     */
+    outputMaxTokens?: number;
+    /**
+     * Reasoning effort of the summarizer call (default `"none"`). Summarizing is
+     * compression, not problem solving, and reasoning tokens spend the same output
+     * budget as the summary itself. Set a level to let a reasoning model think first.
+     */
+    reasoningEffort?: NonNullable<NativeReasoningConfig["effort"]>;
 };
 type SmartAgentBudgetConfig = {
     systemReserveTokens?: number;
@@ -2025,7 +2056,7 @@ type SmartAgentCustomProfileConfig = {
 };
 type ProfileConfig = {
     limits: Required<AgentLimits>;
-    summarization: Required<SmartAgentSummarizationConfig>;
+    summarization: Required<Omit<SmartAgentSummarizationConfig, "outputMaxTokens" | "reasoningEffort">> & Pick<SmartAgentSummarizationConfig, "outputMaxTokens" | "reasoningEffort">;
     context: Required<SmartAgentContextConfig> & {
         budget: Required<SmartAgentBudgetConfig>;
     };
@@ -2687,6 +2718,7 @@ type AgentState = {
             timestamp: string;
             turn: number;
             cachedInput?: number;
+            cacheWrite?: number;
             /** Present when a sub-agent made this call; it was merged in from the child's run. */
             subagent?: {
                 name: string;
@@ -2699,6 +2731,7 @@ type AgentState = {
             output: number;
             total: number;
             cachedInput: number;
+            cacheWriteInput?: number;
         }>;
     };
     guardrailResult?: GuardrailOutcome;
@@ -2784,9 +2817,60 @@ type PlanEvent = {
     todoList?: PlanStepRecord[];
     version?: number;
     adherenceScore?: number;
+    /** Number of steps in the snapshot. */
+    count?: number;
+    /**
+     * The model tool call that produced this snapshot, so a consumer can place the
+     * plan in the transcript next to the call. Per call, not per tool object: two
+     * plan calls in one turn each carry their own id.
+     */
+    toolCallId?: string;
 };
 type SummarizationEvent = {
     type: "summarization";
+    /**
+     * The identity of the pass: its synthetic `summarize_context` tool-call id
+     * (`call_summary_<ts>_<suffix>`, unique to the pass), the same id the
+     * transcript marker message carries. Shared by the `start` and the terminal
+     * event of one pass, so a consumer pairs events by `id` (not by `pass`).
+     */
+    id?: string;
+    /**
+     * `start` is emitted just before the summarizer model call, `done` when the pass
+     * replaced context, `skipped` when a pass that started ended without replacing
+     * anything (or failed, see `status`). Absent means `done` (events from before
+     * this field existed). A consumer that counts passes must count only
+     * `done`/absent.
+     */
+    phase?: "start" | "done" | "skipped";
+    /**
+     * Summaries so far + 1 (1-based). A pass that ends `skipped` makes no summary,
+     * so the next pass has the same number: `pass` is for display, `id` is the
+     * identity.
+     */
+    pass?: number;
+    /** Where in the run loop the pass was triggered. */
+    trigger?: "pre_leg" | "mid_leg" | "post_tools";
+    /**
+     * `ok`; `fallback` when the summarizer failed and a deterministic fallback
+     * summary was used, or, on a `skipped` pass, when its reply was unusable (cut off
+     * at its output limit, empty, JSON with no summary in it): nothing was replaced and
+     * the previous summary stays the latest; `error` when the pass itself failed
+     * unexpectedly (not the model call) and ended `skipped` just before the failure was
+     * rethrown.
+     */
+    status?: "ok" | "fallback" | "error";
+    /**
+     * The failure's message when `status` is `fallback` or `error`, clipped to 300
+     * characters. It is provider text for operators and logs, not for end users;
+     * the trace keeps the whole message.
+     */
+    error?: string;
+    /** The tool results THIS pass replaced (not those of earlier passes). */
+    compactedTools?: Array<{
+        toolCallId: string;
+        toolName: string;
+    }>;
     summary: string;
     /** Number of messages that were compressed/summarized */
     messagesCompressed?: number;
@@ -3346,6 +3430,12 @@ declare function createToolLimitFinalizeNode(_opts: SmartAgentOptions): (state:
 
 /** ctx key: the last pass's model call, read (and removed) by the smart driver for `postCompact`. */
 declare const LAST_SUMMARIZATION_CALL_KEY = "__lastSummarizationCall";
+/**
+ * ctx key the smart driver sets, on the state it hands the node, to say where in
+ * the run loop the pass was triggered. It is input only: the driver removes it
+ * from the ctx the node returns, so it never reaches persisted state.
+ */
+declare const SUMMARIZATION_TRIGGER_KEY = "__summarizationTrigger";
 /**
  * Creates the summarization node.
  *
@@ -3882,6 +3972,20 @@ type CreateGuardrailOptions = {
 };
 declare function createGuardrail(options: CreateGuardrailOptions): ConversationGuardrail;
 
+/**
+ * How a set of usage counters counts tokens. `usageBasisOf` answers it for a
+ * provider's native `TokenUsage`; on a wire message it describes the numbers
+ * the message carries. `fromNativeProvider` converts to the inclusive shape, so
+ * the messages it makes declare no basis (an empty `{}` is "no claim"); a
+ * hand-built or LangChain message can still declare one.
+ */
+type WireUsageBasis = {
+    /** `inputTokens` leaves out the cache read / write tokens (Anthropic, Bedrock). */
+    inputExcludesCache?: true;
+    /** `outputTokens` leaves out the reasoning tokens (Vertex). */
+    outputExcludesReasoning?: true;
+};
+
 type ProviderRetryPolicy = {
     /** Maximum number of retries on 429/5xx responses. Default: 3. */
     maxRetries?: number;
@@ -3897,6 +4001,16 @@ type ProviderRetryPolicy = {
 };
 declare abstract class BaseProvider {
     abstract readonly providerName: ProviderType;
+    /**
+     * How this provider's `TokenUsage` counts tokens. Unset = derive it from
+     * `providerName` (`usageBasisOf`: Anthropic / Bedrock `inputTokens` leave out the
+     * cache read + write, Vertex `outputTokens` leaves out the reasoning). An
+     * explicit `{}` = already inclusive: a gateway or wrapper that normalised the
+     * usage itself. `fromNativeProvider` converts to the inclusive `MessageUsage`
+     * with this basis, so a provider that reports inclusive counts under a
+     * provider name that is exclusive by default must declare `{}`.
+     */
+    readonly usageBasis?: WireUsageBasis;
     protected retryPolicy: ProviderRetryPolicy;
     /** Injected `fetch` (config.fetch); falls back to the global one at call time. */
     protected fetchImpl?: typeof fetch;
@@ -6231,6 +6345,42 @@ declare const GENAI_SEMCONV_COMMIT = "547934a";
 /** True when the model's rule uses `thinking:{type:"adaptive"}` + `output_config.effort` (Claude 4.6+ / 5.x). */
 declare function supportsAdaptiveThinking(model: unknown): boolean;
 
+/** A Responses `reasoning` output item, as far as this file reads it. */
+type ResponsesReasoningItem = {
+    type?: string;
+    id?: string;
+    summary?: Array<{
+        type?: string;
+        text?: string;
+    }>;
+    content?: unknown[] | null;
+    encrypted_content?: string | null;
+    [key: string]: unknown;
+};
+/**
+ * A Responses reasoning item kept on `reasoning.blocks` so the next call of the
+ * same tool loop can hand it back (see `captureReasoningBlocks`). It is typed
+ * `thinking` with no `signature`, which Anthropic / Bedrock replay skips, and
+ * carries the item under `openaiResponses`:
+ *  - `item`    the output item as the API returned it (`encrypted_content` is what makes it replayable)
+ *  - `origin`  provider | endpoint | model that produced it; the blob only decrypts for that account
+ *  - `next`    what followed it in the output (`"message"`, or `call:<call_id>`): it must go back right before that item
+ *  - `nextId`  the `id` of that function call item (`fc_…`), for an endpoint that wants the pair back with its ids (Azure)
+ */
+type ResponsesReasoningBlock = ReasoningBlock & {
+    openaiResponses: {
+        item: ResponsesReasoningItem;
+        origin: string;
+        next: string;
+        nextId?: string;
+    };
+};
+/** What `toResponsesInput` hands `expandResponsesInput` for a replayed reasoning item (`nextId`: see `ResponsesReasoningBlock`). */
+type ReplayedReasoning = {
+    next: string;
+    item: Record<string, any>;
+    nextId?: string;
+};
 declare class OpenAIProvider extends BaseProvider {
     readonly providerName: ProviderType;
     protected readonly apiKey: string;
@@ -6245,6 +6395,8 @@ declare class OpenAIProvider extends BaseProvider {
     /** `api: "responses"` was passed (the legacy `responsesApi: "always"` keeps its old single-call behaviour). */
     private readonly apiResponsesNative;
     protected readonly maxTokensParam: "auto" | "max_tokens" | "max_completion_tokens";
+    /** Origins (see `responsesOrigin`) whose endpoint refused a replayed reasoning item: not replayed again by this instance. */
+    private readonly reasoningReplayRefused;
     constructor(config: OpenAIProviderConfig);
     /** True when the caller listed this request's model in `responsesApiModels`. */
     private isResponsesApiModel;
@@ -6268,7 +6420,12 @@ declare class OpenAIProvider extends BaseProvider {
     protected embeddingsFetch(body: Record<string, any>, signal?: AbortSignal): Promise<Response>;
     /** Chat Completions call that corrects itself from the provider's own 400s (see models/adjust.ts). */
     private fetchChat;
-    /** Same for the Responses API. */
+    /**
+     * Same for the Responses API. Replaying reasoning items is an optimisation and
+     * must never break a call: when the endpoint answers a request that carries
+     * them with a 400 no model adjustment explains, the request goes out once more
+     * without them, and when that one succeeds they are not replayed to that origin again.
+     */
     private fetchResponses;
     protected buildRequestBody(request: ChatCompletionRequest, stream: boolean, overlay?: RulePatch): Record<string, any>;
     protected completeResponses(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
@@ -6276,13 +6433,56 @@ declare class OpenAIProvider extends BaseProvider {
      * `responsesApiModels` with `responsesStreaming` on. Emits the same chunk
      * shapes as the Chat Completions stream: text deltas as they arrive, a tool
      * call's id + name when it opens and its argument fragments under that id,
-     * then one final chunk with usage, finish reason and any reasoning summary
-     * (taken from the completed response, exactly as the non-streaming parse
-     * reads it). */
+     * then one final chunk with usage, finish reason, any reasoning summary and
+     * the reasoning blocks to replay (taken from the completed response, exactly
+     * as the non-streaming parse reads them). A stream that ends without
+     * `response.completed` is an error, not a clean stop. */
     private streamResponses;
-    protected buildResponsesBody(request: ChatCompletionRequest, overlay?: RulePatch): Record<string, any>;
-    /** Maps a unified message to a Responses API `input` item. */
-    protected toResponsesInput(m: UnifiedMessage): Record<string, any>;
+    protected buildResponsesBody(request: ChatCompletionRequest, overlay?: RulePatch, opts?: {
+        replayReasoning?: boolean;
+    }): Record<string, any>;
+    /** Whether the Responses endpoint takes `include: ["reasoning.encrypted_content"]`. Azure's older dated api-versions do not. */
+    protected acceptsEncryptedReasoningInclude(): boolean;
+    /**
+     * Who a reasoning item was produced for. `encrypted_content` only decrypts for
+     * the account that minted it, so an item goes back only to the same provider,
+     * endpoint and model. Azure overrides the endpoint part.
+     */
+    protected responsesOrigin(model: string): string;
+    /**
+     * The reasoning items of an assistant turn that are safe to hand back: those
+     * this origin produced and that carry `encrypted_content` (the opaque payload
+     * is the whole point; an item without it is only a reference to stored state
+     * that may be gone). Blocks from another provider are skipped.
+     */
+    protected replayableReasoning(m: UnifiedMessage, origin: string): ReplayedReasoning[];
+    /**
+     * Whether a replayed reasoning item, and the function call it preceded, go back with the ids
+     * the API gave them. No by default: the id is a pointer into the server's storage, a stored
+     * item must then be followed by the exact item that followed it ("Item 'rs_…' of type
+     * 'reasoning' was provided without its required following item") and can have expired,
+     * while `encrypted_content` is self-contained. AzureProvider says yes: its docs replay the
+     * items with their ids, and it is reported to answer one without its `id` with 400 `invalid_payload`.
+     */
+    protected replaysItemIds(): boolean;
+    /**
+     * A captured reasoning item as it goes back in `input`: type, summary and
+     * `encrypted_content` (plus the reasoning text when the server gave it), never the
+     * `status`; the `id` only when `replaysItemIds()`. Undefined when the item cannot
+     * go back in that shape (an id is required and the item has none).
+     */
+    protected reasoningInputItem(item: ResponsesReasoningItem): Record<string, any> | undefined;
+    /**
+     * The reasoning items of a Responses output worth keeping on `reasoning.blocks`
+     * for the next call of the same tool loop. Only a turn that calls functions
+     * continues (a final answer has nothing to hand back), and only an item with
+     * `encrypted_content` followed by a message or a function call can go back as
+     * it came, right before that item.
+     */
+    protected captureReasoningBlocks(output: unknown, model: string): ResponsesReasoningBlock[];
+    /** Maps a unified message to a Responses API `input` item. `replayOrigin` is set for the
+     * assistant turns of the tool loop in progress: their reasoning items go back in. */
+    protected toResponsesInput(m: UnifiedMessage, replayOrigin?: string): Record<string, any>;
     protected responsesFetch(body: Record<string, any>, signal?: AbortSignal): Promise<Response>;
     protected parseResponsesResponse(json: any, modelId: string): ChatCompletionResponse;
     protected toOpenAIMessage(m: UnifiedMessage): Record<string, any>;
@@ -6299,13 +6499,40 @@ declare class AnthropicProvider extends BaseProvider {
     private readonly defaultModel;
     private readonly defaultHeaders;
     private readonly anthropicVersion;
+    /** Provider name the model rules are looked up under (the Messages wire shape). */
+    protected readonly rulesProvider: string;
+    /** Keeps what a 400 taught apart from the direct API's (same model id, other backend). */
+    protected readonly rulesScope?: string;
+    /** Names the API in error messages: "<apiName> API error 400: ...". */
+    protected readonly apiName: string;
     private readonly promptCachingEnabled;
+    private readonly promptCaching;
     private readonly thinkingMode;
     constructor(config: AnthropicProviderConfig);
     complete(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
     completeStream(request: ChatCompletionRequest): AsyncGenerator<ChatCompletionChunk, void, unknown>;
     private buildRequestBody;
-    private splitSystemMessages;
+    /**
+     * Settles the cache breakpoints of a finished body so a request never carries
+     * more than the 4 the API accepts (a 5th is a 400). In order:
+     *  1. The caller's own come first: the `cacheControl` of text parts and any
+     *     `cache_control` in `extra`. Over the limit, the earliest ones made from parts
+     *     are dropped (a later breakpoint covers a longer prefix); a raw `extra` one
+     *     is never touched.
+     *  2. The SDK's own, only while a slot is free and only on blocks it built: the
+     *     end of the static system prompt, the last tool, then top-level automatic
+     *     caching (it takes one slot, on the last cacheable block). A breakpoint the
+     *     caller already put on that block counts as the SDK's. Automatic caching is
+     *     left out when the request's last block carries a breakpoint of another
+     *     lifetime: it would land on that block, a 400 (the caller asked for 1h on the
+     *     tail, the provider default is 5m). At the same lifetime it is a no-op, and sent.
+     *  3. A longer lifetime may not come after a shorter one (the API answers 400): a
+     *     1h breakpoint after a 5m one, in the order tools, system, messages, is sent as
+     *     5m. Only the ones the SDK made (from parts, or its own) are changed.
+     */
+    private settleCacheBreakpoints;
+    /** `ttl` is sent only for 1h; the 5-minute default is the API's own. */
+    private cacheControl;
     /**
      * Converts unified messages to Anthropic format, coalescing consecutive
      * tool-result messages into a single `user` turn.
@@ -6323,6 +6550,18 @@ declare class AnthropicProvider extends BaseProvider {
     /** Builds and sends the request; retries once with the other thinking form
      * when the upstream rejects the one we picked. */
     private send;
+    /** The URL a request for `model` is posted to. */
+    protected requestUrl(_model: string, _stream: boolean): string;
+    /** Auth and version headers, plus the configured `defaultHeaders`. Called once per request, before any retry. */
+    protected requestHeaders(): Promise<Record<string, string>>;
+    /**
+     * The JSON that goes on the wire for a built request body (the body itself is left as
+     * it is). A backend that can never take part of the body throws a non-retryable
+     * `ProviderError` here, before anything is sent.
+     */
+    protected wireBody(body: Record<string, any>): Record<string, any>;
+    /** Puts the usage counters on the basis this provider reports. The default keeps the Messages API's own. */
+    protected normalizeUsage(usage: TokenUsage): TokenUsage;
     private doFetch;
     private parseResponse;
 }
@@ -6334,19 +6573,48 @@ declare class AzureProvider extends OpenAIProvider {
     private readonly deploymentName?;
     private readonly azureApiKey;
     constructor(config: AzureProviderConfig);
+    /** `apiVersion: "v1"` selects Azure's versionless v1 route, which this provider uses for the Responses API only. */
+    private get usesV1Route();
+    /** The `api-version` of the deployment routes (chat, embeddings): the v1 route has none, so under `"v1"` a dated one stands in. */
+    private get datedApiVersion();
+    /** Reasoning items only decrypt for the resource that minted them: the Azure endpoint, not the dummy OpenAI base URL, is the scope. */
+    protected responsesOrigin(model: string): string;
+    /** Azure's docs replay the output items as they came, so the reasoning item and the function call it preceded go
+     * back with their ids; a reasoning item without its `id` is reported to be refused (400 `invalid_payload`). */
+    protected replaysItemIds(): boolean;
     protected doFetch(body: Record<string, any>, signal?: AbortSignal): Promise<Response>;
     /** Azure embeddings: the deployment named by the request's model (falling back
      * to the configured deployment) in the path, api-key auth. */
     protected embeddingsFetch(body: Record<string, any>, signal?: AbortSignal): Promise<Response>;
+    /**
+     * Encrypted reasoning items are new in api-version 2025-04-01-preview (2025-03-01-preview
+     * is the first Responses version), so a dated version before that gets no `include`
+     * for them. The v1 route, `preview` and `latest` have them; a version that cannot be read is left out.
+     */
+    protected acceptsEncryptedReasoningInclude(): boolean;
     /** Azure exposes the Responses API at /openai/responses with api-key auth.
      * Reasoning summaries require a preview api-version; callers can override via
-     * the `apiVersion` config. */
+     * the `apiVersion` config. `apiVersion: "v1"` uses the versionless v1 route
+     * (`/openai/v1/responses`, no `api-version` query); chat and embeddings keep
+     * their dated deployment routes, so under "v1" v1 is Responses-only. */
     protected responsesFetch(body: Record<string, any>, signal?: AbortSignal): Promise<Response>;
 }
 
 declare class OpenAICompatibleProvider extends OpenAIProvider {
     readonly providerName: ProviderType;
+    private readonly promptCachingEnabled;
+    private readonly promptCaching;
+    private readonly replayReasoningContent;
     constructor(config: OpenAICompatibleProviderConfig);
+    /** Adds this provider's cache markers (when `prompt_caching` is on) before the body is built. */
+    protected buildRequestBody(request: ChatCompletionRequest, stream: boolean, overlay?: RulePatch): Record<string, any>;
+    /**
+     * Chat Completions message with what only a compatible server takes:
+     * `cache_control` on text parts the caller (or `prompt_caching`) marked, and,
+     * with `replayReasoningContent`, the assistant's reasoning text as
+     * `reasoning_content`. OpenAI and Azure never get either field.
+     */
+    protected toOpenAIMessage(m: UnifiedMessage): Record<string, any>;
 }
 
 declare class BedrockProvider extends BaseProvider {
@@ -6356,6 +6624,7 @@ declare class BedrockProvider extends BaseProvider {
     private readonly defaultModel;
     private readonly defaultHeaders;
     private readonly promptCachingEnabled;
+    private readonly promptCaching;
     private readonly thinkingMode;
     constructor(config: BedrockProviderConfig);
     complete(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
@@ -6379,7 +6648,31 @@ declare class BedrockProvider extends BaseProvider {
     embed(request: EmbeddingRequest): Promise<EmbeddingResponse>;
     private invokeModel;
     private buildConverseBody;
-    private splitSystemMessages;
+    /**
+     * The `system` blocks of a group of system messages: one text block per message
+     * (blank text has no block: Converse rejects it), cut after each text part the
+     * caller marked for caching, which gets a checkpoint right after it.
+     */
+    private toBedrockSystem;
+    /**
+     * Settles the cache checkpoints of a finished body so a request never carries more
+     * than the 4 Converse accepts. In order:
+     *  1. The caller's own come first: the `cacheControl` of text parts and any
+     *     `cachePoint` in `extra`. Over the limit, the earliest ones made from parts are
+     *     dropped (a later checkpoint covers a longer prefix); a raw `extra` one is
+     *     never touched. They are sent whether or not `prompt_caching` is enabled: that
+     *     switch is for the SDK's own, and a marker is an explicit request.
+     *  2. The SDK's own, only while a slot is free (`prompt_caching.enabled`) and only on
+     *     blocks it built: after the static system prompt, after the tools (not on Nova,
+     *     which takes none there) and, with strategy `auto`, at the end of the last user
+     *     message: a rolling breakpoint, each request writes at the new tail and reads
+     *     the previous prefix (Bedrock looks back ~20 content blocks). A checkpoint the
+     *     caller already put at that spot counts as the SDK's.
+     *  3. A longer lifetime may not come after a shorter one: in the order Bedrock reads
+     *     them (tools, system, messages) a 1h checkpoint after a 5m one is sent as 5m.
+     *     Only the ones the SDK made (from parts, or its own) are changed.
+     */
+    private settleCheckpoints;
     /**
      * Converts unified messages to Bedrock Converse format, coalescing
      * consecutive tool-result messages into a single `user` turn.
@@ -6392,6 +6685,12 @@ declare class BedrockProvider extends BaseProvider {
      * blocks at messages.N.content for the following Ids: ...".
      */
     private toBedrockMessages;
+    /**
+     * One tool result: the `toolResult` block (`status` "error" when the host flagged the
+     * result as one, which Converse documents for Nova and Claude), then a checkpoint
+     * when a text part of the result carried the caller's `cacheControl`: a toolResult
+     * has no cachePoint member of its own, so it goes after the whole block.
+     */
     private toBedrockToolResult;
     private toBedrockMessage;
     private toBedrockTool;
@@ -6402,18 +6701,62 @@ declare class BedrockProvider extends BaseProvider {
     private parseResponse;
 }
 
+/**
+ * Options of the Claude path, accepted next to the usual Vertex config.
+ * They have no effect on Gemini models.
+ */
+type VertexClaudeOptions = {
+    /**
+     * Prompt caching for Claude models: same shape and meaning as on
+     * `AnthropicProviderConfig.prompt_caching` (explicit breakpoints on the system
+     * prompt and the last tool, plus top-level automatic caching with the default
+     * `strategy: "auto"`). Off unless `enabled: true`.
+     */
+    prompt_caching?: PromptCachingConfig;
+    /** Thinking request shape for Claude models, as on `AnthropicProviderConfig.thinkingMode`. */
+    thinkingMode?: "auto" | "adaptive" | "budget";
+};
+
+/** How Google credentials are obtained, accepted next to the usual Vertex config. */
+type VertexAuthOptions = {
+    /**
+     * How long the `gcloud auth print-access-token` fallback (no `accessToken` and no
+     * `serviceAccountJson`) may run before it is killed. Default 30000. A slow
+     * first call (cold CLI, credential refresh) is not a failure.
+     */
+    gcloudTimeoutMs?: number;
+};
 declare class VertexProvider extends BaseProvider {
     readonly providerName: ProviderType;
     private readonly projectId;
     private readonly location;
+    /** Where Claude models are called: the configured `location`, or `global` when none was set. */
+    private readonly claudeLocation;
     private readonly defaultModel;
     private readonly defaultHeaders;
+    /** An explicit `accessToken`, or the token the gcloud fallback produced. Service-account tokens live in a module-level cache instead. */
     private accessToken?;
     private serviceAccountJson?;
     private tokenExpiry;
-    constructor(config: VertexProviderConfig);
+    private gcloudRefresh?;
+    private readonly gcloudTimeoutMs;
+    private readonly claudeConfig;
+    private claude?;
+    /**
+     * A model id that starts with `claude` (or `publishers/anthropic/models/claude...`)
+     * is served by the Claude publisher: same project, location and credentials,
+     * `:rawPredict` / `:streamRawPredict`. `prompt_caching` and `thinkingMode` apply to those.
+     *
+     * `location` defaults to `us-central1` for Gemini. That region does not serve the
+     * newer Claude models (they need `global` or the `us` / `eu` multi-regions), so a
+     * Claude call made with no explicit `location` goes to `global`; an explicit
+     * `location` is always used as given.
+     */
+    constructor(config: VertexProviderConfig & VertexClaudeOptions & VertexAuthOptions);
     complete(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
     completeStream(request: ChatCompletionRequest): AsyncGenerator<ChatCompletionChunk, void, unknown>;
+    /** The Claude-on-Vertex path, made on first use and sharing this provider's token handling. */
+    private claudeProvider;
     /**
      * Vertex `:predict` embeddings (text-embedding-00x, text-multilingual-embedding,
      * gemini-embedding-001). `inputType` maps to the task type; `dimensions` to
@@ -6428,6 +6771,13 @@ declare class VertexProvider extends BaseProvider {
     private toGeminiContent;
     private toGeminiTool;
     private getAccessToken;
+    /**
+     * Cached per (service account, scope, key) at module level, so a provider built
+     * per call does not sign a JWT and hit the token endpoint every time. Callers
+     * arriving while a refresh runs await the same request; a failed refresh is
+     * not cached.
+     */
+    private getServiceAccountToken;
     private getTokenFromServiceAccount;
     private doFetch;
     private parseResponse;
@@ -6472,9 +6822,14 @@ type NativeModelOptions = {
  *   completion_tokens_details: { reasoning_tokens },
  * }
  * ```
- * `completion_tokens` INCLUDES `reasoning_tokens`; `prompt_tokens` INCLUDES
- * `cached_tokens`. `response_metadata.token_usage` additionally keeps the flat
- * legacy `cached_tokens` / `cache_write_tokens` keys.
+ * The shape is INCLUSIVE, and the adapter enforces it: `prompt_tokens` INCLUDES
+ * `cached_tokens` and `cache_write_tokens`, `completion_tokens` INCLUDES
+ * `reasoning_tokens`, and `total_tokens = prompt_tokens + completion_tokens`
+ * (cached tokens are never added on top). The providers' own `TokenUsage` keeps
+ * its native basis (Anthropic / Bedrock `inputTokens` exclude the cache, Vertex
+ * `outputTokens` excludes the reasoning); `fromNativeProvider` converts it.
+ * `response_metadata.token_usage` additionally keeps the flat legacy
+ * `cached_tokens` / `cache_write_tokens` keys.
  */
 type MessageUsage = {
     prompt_tokens: number;
@@ -6488,7 +6843,16 @@ type MessageUsage = {
         reasoning_tokens: number;
     };
 };
-declare function toMessageUsage(u: TokenUsage): MessageUsage;
+/**
+ * Converts a provider `TokenUsage` to the inclusive `MessageUsage`. `basis` says
+ * how `u` counts tokens: `inputExcludesCache` adds the cache read + write to
+ * the prompt, `outputExcludesReasoning` adds the reasoning to the completion.
+ * Omitted (or `{}`) = `u` is already inclusive and is copied as it is. When a
+ * basis adjusts anything the total is recomputed as prompt + completion (the
+ * provider's own total is not trusted to include the same parts); otherwise the
+ * provider's total is kept.
+ */
+declare function toMessageUsage(u: TokenUsage, basis?: WireUsageBasis): MessageUsage;
 /**
  * Creates a BaseChatModel from a native provider.
  *
@@ -6525,13 +6889,15 @@ declare function fromNativeProvider(provider: BaseProvider, options?: NativeMode
  */
 declare function createProvider(config: ProviderConfig): BaseProvider;
 
-type ModelRequestErrorCode = "unsupported_parameter" | "unsupported_value" | "model_request_invalid";
+type ModelRequestErrorCode = "unsupported_parameter" | "unsupported_value" | "max_tokens_too_large" | "model_request_invalid";
 type ModelRequestErrorInit = {
     status?: number;
     code: ModelRequestErrorCode;
     param?: string;
     value?: unknown;
     supportedValues?: string[];
+    /** `max_tokens_too_large` only: the most completion tokens the server says it accepts, when its message states one. */
+    maxAllowed?: number;
     provider: string;
     model: string;
     message: string;
@@ -6543,8 +6909,10 @@ declare class ModelRequestError extends ProviderError {
     readonly param?: string;
     readonly value?: unknown;
     readonly supportedValues?: string[];
+    /** `code: "max_tokens_too_large"` only: the largest completion size the server states it takes (a retry with it is the caller's call). */
+    readonly maxAllowed?: number;
     readonly model: string;
     constructor(init: ModelRequestErrorInit);
 }
 
-export { type AIMessage, ASK_USER_TOOL_NAME, type AgentInstance, type AgentInvokeResult, type AgentLimits, type AgentOptions, type AgentPlugin, type AgentRuleOptions, type AgentRuntimeConfig, type AgentSnapshot, type AgentSnapshotMetadata, type AgentState, AnthropicProvider, AnthropicProviderConfig, type ApprovalTransport, type AuditEntry, type AuditLogConfig, type AzureContentSafetyConfig, AzureProvider, AzureProviderConfig, type BaseChatMessage, type BaseChatMessagePart, type BaseChatModel, type BaseMessage, BaseProvider, type BedrockGuardrailConfig, BedrockProvider, BedrockProviderConfig, type BudgetGuardConfig, type BuildChildConfig, type BuiltInRuntimeProfile, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, type CancellationTokenLike, type CancelledEvent, type CapabilityStatus, ChatCompletionChunk, ChatCompletionRequest, ChatCompletionResponse, type CheckpointPluginConfig, type CheckpointStore, type ChildContextPolicy, type CodeDetectionRuleOptions, type CodeGuardrailOptions, type CognipeerGuardrailConfig, type CompressToolOutputParams, type ContextBuilder, type ContextPilotCCRConfig, type ContextPilotCacheAlignmentConfig, type ContextPilotCompressionConfig, type ContextPilotCompressionStats, type ContextPilotCompressorKind, type ContextPilotConfig, type ContextPilotDedupConfig, type ContextPilotDiffCompressionConfig, type ContextPilotJsonCompressionConfig, type ContextPilotLogCompressionConfig, type ContextPilotResult, type ContextPilotRuntime, type ContextPilotSearchCompressionConfig, type ContextPilotTextCompressionConfig, type ContextPolicy, type ContextToolsStateRef, type ConversationGuardrail, type ConversationPluginConfig, type ConversationStore, type CostEstimator, type CustomRuleCallback, type CustomRuleOptions, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, type DeferredTraceEvent, type DelegationEventStamp, type DelegationMode, type DroppedDirective, EmbeddingRequest, EmbeddingResponse, type EvalCase, type EvalCaseResult, type EvalFamily, type EvalHarnessMetrics, type EvalHarnessParams, type EvalHarnessResult, type EvalProfileDescriptor, type EvalProfileTarget, type FinalAnswerEvent, GENAI_SEMCONV_COMMIT, type GateResult, type GuardrailCallContext, type GuardrailContext, type GuardrailDisposition, type GuardrailEvent, type GuardrailIncident, type GuardrailJudgeEngine, type GuardrailOutcome, GuardrailPhase, type GuardrailPhaseName, type GuardrailPluginOptions, type GuardrailRequest, type GuardrailRule, type GuardrailRuleResult, type GuardrailTransport, type GuardrailVerdict, type GuardrailViolation, HOOK_CONTRACT_VERSION, HOOK_NAMES, type HandoffDescriptor, type HandoffEvent, type HookContext, type HookDecision, type HookHandler, type HookMap, type HookName, type HookRegistrations, HookTimeoutError, type HttpGuardrailOptions, type HumanInTheLoopAskUserConfig, type HumanInTheLoopOptions, type HumanInTheLoopRuntimeConfig, InMemoryMemoryStore, type InjectionScan, type InvokeConfig, type JevClientLike, type JevEngineOptions, type JevNoulAnswer, JevProvider, JevProviderConfig, type JevQuestion, type JevSystemOneRequest, type JevSystemOneResult, type JsonGuardrailOptions, type JsonSchemaRuleOptions, LAST_SUMMARIZATION_CALL_KEY, type LangfuseBuildContext, type LangfuseEvent, type LangfuseEventKind, type LangfuseTracingConfig, type LanguageGuardConfig, type LoadSkillsOptions, type MaybePromise, type McpConfig, type McpConnection, type MediaAttachment, type MediaKind$1 as MediaKind, type MediaPolicyConfig, type MemoryFact, type MemoryProviderKind, type MemoryReadPolicy, type MemoryScope, type MemoryStore, type MemoryWritePolicy, type Message, type MessageUsage, type MetadataEvent, type ModelCapabilities, ModelRequestError, type ModelRequestErrorCode, type ModelRequestErrorInit, ModelRuleLearnedEvent, NativeJsonSchemaStrategy, type NativeModelOptions, type NativeReasoningConfig, OpenAICompatibleProvider, OpenAICompatibleProviderConfig, type OpenAIModerationConfig, OpenAIProvider, OpenAIProviderConfig, type OtelTracingConfig, type OtlpContentField, type OtlpContentOptions, type OtlpContentRedactInfo, type OtlpExportOptions, type OtlpExportResult, type OtlpExportTraceServiceRequest, type OtlpExporter, type OtlpProtocol, type OtlpRetryOptions, type OtlpSemconv, type OutputGuardConfig, PREOPEN_TOOL_CALL_PREFIX, type PendingToolApproval, type PendingUserQuestion, type PiiDetector, type PiiEntity, type PiiRedactionConfig, type PlanEvent, type PlanStepRecord, type PlanningMode, type PluginContributions, type PluginEvent, type PluginFailureMode, type PluginHost, type PluginHostOptions, type PluginLogger, type PluginProvides, type PluginRunHost, type PluginSetupContext, type PortkeyGatewayConfig, type PortkeyGuardrailConfig, type PreopenSkillsResult, type ProfileConfig, type ProgressEvent, type ProgressUpdate, type PromptHooks, type PromptInjectionFamily, type PromptInjectionGuardConfig, type PromptSource, ProviderConfig, ProviderError, ToolDefinition as ProviderToolDefinition, ProviderType, type RateLimitConfig, type ReasoningConfig, type ReasoningLevel, type RedactionResult, type ReflectionCadence, type ReflectionConfig, type ReflectionEvent, type ReflectionHookContext, type ReflectionRecord, type RegexGuardrailConfig, type RegexGuardrailOptions, type RegexRuleOptions, type ReplanPolicy, type ResolvedContextPilotConfig, type ResolvedSmartAgentConfig, type ResolvedTraceConfig, type ResolvedTraceSink, type ResponseCacheConfig, type RestoreSnapshotOptions, RulePatch, type RuntimeProfile, SMALL_TIER_SKILL_POLICY, type SdkCapabilities, type SerializableSmartState, type SessionMetrics, type SessionMetricsConfig, type Skill, type SkillDisclosure, type SkillExecutionContext, type SkillFrontmatter, type SkillFs, type SkillModelTier, type SkillPolicy, type SkillRegistryRef, type SkillSource, type SkillToolDeps, type SkillToolHeader, type SlotName, type SmartAgentBudgetConfig, type SmartAgentContextConfig, type SmartAgentCustomProfileConfig, type SmartAgentDelegationConfig, type SmartAgentEvent, type SmartAgentInstance, type SmartAgentLimits, type SmartAgentMemoryConfig, type SmartAgentOptions, type SmartAgentPlanningConfig, type SmartAgentSummarizationConfig, type SmartAgentToolResponseConfig, type SmartAgentTracingConfig, type SmartModel, type SmartState, type SmartToolFn, type SnapshotOptions, type SnapshotRuntimeHint, type StreamChunk, type StreamEvent, type StrictRestorers, type StrictTransform, type StructuredOutputError, type StructuredOutputFieldError, StructuredOutputManager, type StructuredOutputManagerConfig, type StructuredOutputResult, type StructuredOutputStrategy, type StructuredSummary, type SubagentDef, type SubagentEvent, type SubagentMode, type SubagentPendingRecord, type SubagentPolicy, type SubagentRegistryRef, type SubagentResult, type SubagentStatus, type SubagentToolDeps, type SubagentToolNames, type SubagentUsage, type SummarizationEvent, type SummarizationMode, type SummarizerInput, type SummarizerResult, type SummarizerStrategy, type SummaryFactItem, type SummaryIntegrityCheck, TOOL_INPUT_DIGEST_KEY, type TokenCounter, TokenUsage, type ToolApprovalEvent, type ToolApprovalResolution, type ToolApprovalStatus, ToolBasedStrategy, type ToolCachePolicy, type ToolCallContext, type ToolCallEvent, type ToolInputDigestOptions, type ToolInputDigestResult, type ToolInputRetentionPolicy, type ToolInterface, type ToolPolicyConfig, type ToolResponseClassification, type ToolResponseRetentionPolicy, type ToolRetentionDeclarations, type ToolRetentionSpec, type ToolRetryPolicy, type ToolRule, type TraceContinuation, type TraceDataSection, type TraceErrorRecord, type TraceEventRecord, type TraceMessagePart, type TraceMessageSection, type TraceMetadataSection, type TraceParent, type TraceParentInput, type TraceSessionConfigSnapshot, type TraceSessionFile, type TraceSessionStatus, type TraceSessionSummary, type TraceSinkCognipeerConfig, type TraceSinkConfig, type TraceSinkCustomConfig, type TraceSinkFileConfig, type TraceSinkHttpConfig, type TraceSinkOtlpConfig, type TraceSinkSnapshot, type TraceSummarySection, type TraceToolCallSection, type TraceToolDefinition, type TraceToolDefinitionsSection, type TraceToolDetails, type TraceToolResponseSection, type TraceToolResultSection, type TracingConfig, type TracingMode, UnifiedMessage, type UserQuestionAnswer, type UserQuestionAnswerSet, type UserQuestionEvent, type UserQuestionItem, type UserQuestionOption, type UserQuestionResolution, type UserQuestionStatus, VertexProvider, VertexProviderConfig, type VolatileContentFinding, type VolatileContentPattern, type WebhookApprovalConfig, agentVerdictRule, appendBoundTools, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, closeTraceContinuation, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentPartToText, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createOtlpExporter, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, describeContentPart, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, evaluateGuardrails, extractLatestUserQuery, extractMessageText, fileCheckpointStore, fileSink, findSubagent, foldSupersededSpans, formatTraceparent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasMediaPart, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isOpenAIHostedEndpoint, isSmartModel, isTraceSessionOpen, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, loadSkillsFromDisk, mapConsoleHookVerdict, mapTextParts, mcp, mediaKindOf, mediaPolicy, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseSkillFrontmatter, parseTraceparent, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, prepareStrictToolMenu, promptInjectionGuard, rateLimit, readMemoryFacts, readTraceContinuation, recordOrDeferTraceEvent, redactText, regexGuardrail, regexRule, replaceTextContent, replayDeferredTraceEvents, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, restoreToolCalls, runSmartAgentEvalHarness, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, supportsAdaptiveThinking, textFromContent, toMessageUsage, toModelResult, toStrictCompatible, toStrictToolSchema, tokenize, toolPolicy, traceContinuationOf, traceSectionsFromMessages, traceSessionToOtlp, traceparentOf, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };
+export { type AIMessage, ASK_USER_TOOL_NAME, type AgentInstance, type AgentInvokeResult, type AgentLimits, type AgentOptions, type AgentPlugin, type AgentRuleOptions, type AgentRuntimeConfig, type AgentSnapshot, type AgentSnapshotMetadata, type AgentState, AnthropicProvider, AnthropicProviderConfig, type ApprovalTransport, type AuditEntry, type AuditLogConfig, type AzureContentSafetyConfig, AzureProvider, AzureProviderConfig, type BaseChatMessage, type BaseChatMessagePart, type BaseChatModel, type BaseMessage, BaseProvider, type BedrockGuardrailConfig, BedrockProvider, BedrockProviderConfig, type BudgetGuardConfig, type BuildChildConfig, type BuiltInRuntimeProfile, CCRStore, CONSOLE_HOOK_MAP, CONTEXT_PILOT_JSON_MARKER_KEY, CONTROL_PLANE_TOOL_NAMES, type CancellationTokenLike, type CancelledEvent, type CapabilityStatus, ChatCompletionChunk, ChatCompletionRequest, ChatCompletionResponse, type CheckpointPluginConfig, type CheckpointStore, type ChildContextPolicy, type CodeDetectionRuleOptions, type CodeGuardrailOptions, type CognipeerGuardrailConfig, type CompressToolOutputParams, type ContextBuilder, type ContextPilotCCRConfig, type ContextPilotCacheAlignmentConfig, type ContextPilotCompressionConfig, type ContextPilotCompressionStats, type ContextPilotCompressorKind, type ContextPilotConfig, type ContextPilotDedupConfig, type ContextPilotDiffCompressionConfig, type ContextPilotJsonCompressionConfig, type ContextPilotLogCompressionConfig, type ContextPilotResult, type ContextPilotRuntime, type ContextPilotSearchCompressionConfig, type ContextPilotTextCompressionConfig, type ContextPolicy, type ContextToolsStateRef, type ConversationGuardrail, type ConversationPluginConfig, type ConversationStore, type CostEstimator, type CustomRuleCallback, type CustomRuleOptions, DEFAULT_MAX_TOOL_INPUT_FIELD_CHARS, DEFAULT_PROFILE_CONFIGS, DEFAULT_SKILL_POLICY, DEFAULT_SUBAGENT_POLICY, DEFAULT_SUBAGENT_TOOL_NAMES, DEFAULT_TOOL_INPUT_DIGEST_HEAD_CHARS, DELEGATION_TOOL_NAMES, DedupTracker, type DeferredTraceEvent, type DelegationEventStamp, type DelegationMode, type DroppedDirective, EmbeddingRequest, EmbeddingResponse, type EvalCase, type EvalCaseResult, type EvalFamily, type EvalHarnessMetrics, type EvalHarnessParams, type EvalHarnessResult, type EvalProfileDescriptor, type EvalProfileTarget, type FinalAnswerEvent, GENAI_SEMCONV_COMMIT, type GateResult, type GuardrailCallContext, type GuardrailContext, type GuardrailDisposition, type GuardrailEvent, type GuardrailIncident, type GuardrailJudgeEngine, type GuardrailOutcome, GuardrailPhase, type GuardrailPhaseName, type GuardrailPluginOptions, type GuardrailRequest, type GuardrailRule, type GuardrailRuleResult, type GuardrailTransport, type GuardrailVerdict, type GuardrailViolation, HOOK_CONTRACT_VERSION, HOOK_NAMES, type HandoffDescriptor, type HandoffEvent, type HookContext, type HookDecision, type HookHandler, type HookMap, type HookName, type HookRegistrations, HookTimeoutError, type HttpGuardrailOptions, type HumanInTheLoopAskUserConfig, type HumanInTheLoopOptions, type HumanInTheLoopRuntimeConfig, InMemoryMemoryStore, type InjectionScan, type InvokeConfig, type JevClientLike, type JevEngineOptions, type JevNoulAnswer, JevProvider, JevProviderConfig, type JevQuestion, type JevSystemOneRequest, type JevSystemOneResult, type JsonGuardrailOptions, type JsonSchemaRuleOptions, LAST_SUMMARIZATION_CALL_KEY, type LangfuseBuildContext, type LangfuseEvent, type LangfuseEventKind, type LangfuseTracingConfig, type LanguageGuardConfig, type LoadSkillsOptions, type MaybePromise, type McpConfig, type McpConnection, type MediaAttachment, type MediaKind$1 as MediaKind, type MediaPolicyConfig, type MemoryFact, type MemoryProviderKind, type MemoryReadPolicy, type MemoryScope, type MemoryStore, type MemoryWritePolicy, type Message, type MessageUsage, type MetadataEvent, type ModelCapabilities, ModelRequestError, type ModelRequestErrorCode, type ModelRequestErrorInit, ModelRuleLearnedEvent, NativeJsonSchemaStrategy, type NativeModelOptions, type NativeReasoningConfig, OpenAICompatibleProvider, OpenAICompatibleProviderConfig, type OpenAIModerationConfig, OpenAIProvider, OpenAIProviderConfig, type OtelTracingConfig, type OtlpContentField, type OtlpContentOptions, type OtlpContentRedactInfo, type OtlpExportOptions, type OtlpExportResult, type OtlpExportTraceServiceRequest, type OtlpExporter, type OtlpProtocol, type OtlpRetryOptions, type OtlpSemconv, type OutputGuardConfig, PREOPEN_TOOL_CALL_PREFIX, type PendingToolApproval, type PendingUserQuestion, type PiiDetector, type PiiEntity, type PiiRedactionConfig, type PlanEvent, type PlanStepRecord, type PlanningMode, type PluginContributions, type PluginEvent, type PluginFailureMode, type PluginHost, type PluginHostOptions, type PluginLogger, type PluginProvides, type PluginRunHost, type PluginSetupContext, type PortkeyGatewayConfig, type PortkeyGuardrailConfig, type PreopenSkillsResult, type ProfileConfig, type ProgressEvent, type ProgressUpdate, PromptCachingConfig, type PromptHooks, type PromptInjectionFamily, type PromptInjectionGuardConfig, type PromptSource, ProviderConfig, ProviderError, ToolDefinition as ProviderToolDefinition, ProviderType, type RateLimitConfig, type ReasoningConfig, type ReasoningLevel, type RedactionResult, type ReflectionCadence, type ReflectionConfig, type ReflectionEvent, type ReflectionHookContext, type ReflectionRecord, type RegexGuardrailConfig, type RegexGuardrailOptions, type RegexRuleOptions, type ReplanPolicy, type ResolvedContextPilotConfig, type ResolvedSmartAgentConfig, type ResolvedTraceConfig, type ResolvedTraceSink, type ResponseCacheConfig, type RestoreSnapshotOptions, RulePatch, type RuntimeProfile, SMALL_TIER_SKILL_POLICY, SUMMARIZATION_TRIGGER_KEY, type SdkCapabilities, type SerializableSmartState, type SessionMetrics, type SessionMetricsConfig, type Skill, type SkillDisclosure, type SkillExecutionContext, type SkillFrontmatter, type SkillFs, type SkillModelTier, type SkillPolicy, type SkillRegistryRef, type SkillSource, type SkillToolDeps, type SkillToolHeader, type SlotName, type SmartAgentBudgetConfig, type SmartAgentContextConfig, type SmartAgentCustomProfileConfig, type SmartAgentDelegationConfig, type SmartAgentEvent, type SmartAgentInstance, type SmartAgentLimits, type SmartAgentMemoryConfig, type SmartAgentOptions, type SmartAgentPlanningConfig, type SmartAgentSummarizationConfig, type SmartAgentToolResponseConfig, type SmartAgentTracingConfig, type SmartModel, type SmartState, type SmartToolFn, type SnapshotOptions, type SnapshotRuntimeHint, type StreamChunk, type StreamEvent, type StrictRestorers, type StrictTransform, type StructuredOutputError, type StructuredOutputFieldError, StructuredOutputManager, type StructuredOutputManagerConfig, type StructuredOutputResult, type StructuredOutputStrategy, type StructuredSummary, type SubagentDef, type SubagentEvent, type SubagentMode, type SubagentPendingRecord, type SubagentPolicy, type SubagentRegistryRef, type SubagentResult, type SubagentStatus, type SubagentToolDeps, type SubagentToolNames, type SubagentUsage, type SummarizationEvent, type SummarizationMode, type SummarizerInput, type SummarizerResult, type SummarizerStrategy, type SummaryFactItem, type SummaryIntegrityCheck, TOOL_INPUT_DIGEST_KEY, type TokenCounter, TokenUsage, type ToolApprovalEvent, type ToolApprovalResolution, type ToolApprovalStatus, ToolBasedStrategy, type ToolCachePolicy, type ToolCallContext, type ToolCallEvent, type ToolInputDigestOptions, type ToolInputDigestResult, type ToolInputRetentionPolicy, type ToolInterface, type ToolPolicyConfig, type ToolResponseClassification, type ToolResponseRetentionPolicy, type ToolRetentionDeclarations, type ToolRetentionSpec, type ToolRetryPolicy, type ToolRule, type TraceContinuation, type TraceDataSection, type TraceErrorRecord, type TraceEventRecord, type TraceMessagePart, type TraceMessageSection, type TraceMetadataSection, type TraceParent, type TraceParentInput, type TraceSessionConfigSnapshot, type TraceSessionFile, type TraceSessionStatus, type TraceSessionSummary, type TraceSinkCognipeerConfig, type TraceSinkConfig, type TraceSinkCustomConfig, type TraceSinkFileConfig, type TraceSinkHttpConfig, type TraceSinkOtlpConfig, type TraceSinkSnapshot, type TraceSummarySection, type TraceToolCallSection, type TraceToolDefinition, type TraceToolDefinitionsSection, type TraceToolDetails, type TraceToolResponseSection, type TraceToolResultSection, type TracingConfig, type TracingMode, UnifiedMessage, type UserQuestionAnswer, type UserQuestionAnswerSet, type UserQuestionEvent, type UserQuestionItem, type UserQuestionOption, type UserQuestionResolution, type UserQuestionStatus, VertexProvider, VertexProviderConfig, type VolatileContentFinding, type VolatileContentPattern, type WebhookApprovalConfig, agentVerdictRule, appendBoundTools, auditLog, azureContentSafety, bedrockGuardrail, budgetGuard, buildHandoffTools, buildResponseFormatSection, buildSkillHeaderBlock, buildSubagentCatalogBlock, buildSystemPrompt, buildToolDefinitionsSection, canOpenSkill, canSpawn, captureSnapshot, checkpointing, closeTraceContinuation, codePresenceRule, coerceToolArgs, cognipeerGuardrail, cognipeerSink, collectAttachments, collectToolRetentionDeclarations, composeToolSets, compressDiffOutput, compressJsonOutput, compressLogOutput, compressSearchOutput, compressTextOutput, compressToolOutput, contentPartToText, contentToString, conversationHistory, countApproxTokens, countMessagesTokens, createAgent, createAgentNode, createAskUserQuestionTool, createBindSkillToolsTool, createCodeGuardrail, createContextPilotRuntime, createContextSummarizeNode, createContextTools, createDelegateTool, createGetToolResponseTool, createGuardrail, createGuardrailPlugin, createJsonGuardrail, createManageTodoListAliasTool, createManageTodoTool, createOpenSkillTool, createOtlpExporter, createParallelTool, createPluginHost, createProvider, createRegexGuardrail, createResolverNode, createSearchSkillsTool, createSkillRegistryRef, createSkillTools, createSmartAgent, createSpawnTool, createSubagentRegistryRef, createSubagentTools, createTool, createToolLimitFinalizeNode, createToolsNode, customCallbackRule, customGuardrail, customSink, dedupeToolsByName, defaultTokenCounter, defineHook, definePlugin, describeContentPart, detectLanguage, detectTextFormat, detectVolatileContent, digestToolInputArguments, digestToolInputValue, evaluateGuardrails, extractLatestUserQuery, extractMessageText, fileCheckpointStore, fileSink, findSubagent, foldSupersededSpans, formatTraceparent, formatZodError, fromLangchainModel, fromLangchainTools, fromNativeProvider, generateSpanId, generateTraceId, getModelCapabilities, getNestedValue, getResolvedSmartConfig, getTokenCounter, hasMediaPart, hasToolResponseRecoveryReference, httpGuardrail, httpSink, inMemoryCheckpointStore, inMemoryConversationStore, isHookImplemented, isOpenAIHostedEndpoint, isSmartModel, isTraceSessionOpen, isValidIban, isValidLuhn, isValidTckn, jsonSchemaRule, defaultBuildPayload as langfuseDefaultPayload, langfuseTracing, languageGuard, loadSkillsFromDisk, mapConsoleHookVerdict, mapTextParts, mcp, mediaKindOf, mediaPolicy, normalizeSmartAgentOptions, normalizeVerdicts, openAIModeration, otelTracing, otlpSink, outputGuard, parseApprovalDecision, parseSkillFrontmatter, parseTraceparent, pathSandbox, piiRedaction, pluginCapabilities, portkeyGateway, portkeyGuardrail, preopenSkills, preopenToolCallId, prepareStrictToolMenu, promptInjectionGuard, rateLimit, readMemoryFacts, readTraceContinuation, recordOrDeferTraceEvent, redactText, regexGuardrail, regexRule, replaceTextContent, replayDeferredTraceEvents, resolveAvailableSkills, resolveAvailableSubagents, resolveInputRetention, resolveMemoryStore, resolveReasoning, resolveStrategy, resolveSubagentTools, resolveSummarizationRetention, resolveToolApprovalState, resolveUserQuestionState, responseCache, restoreSnapshot, restoreToolCalls, runSmartAgentEvalHarness, scoreItemsByRelevance, searchSkills, seedChildMessages, selectTopIndicesInOrder, sessionMetrics, setTokenCounter, startStreamingSession, summarizeObject, supportsAdaptiveThinking, textFromContent, toMessageUsage, toModelResult, toStrictCompatible, toStrictToolSchema, tokenize, toolPolicy, traceContinuationOf, traceSectionsFromMessages, traceSessionToOtlp, traceparentOf, validateReasoningConfig, validateToolArgs, webhookApproval, withTools, withinDepth, writeSummaryFactsToMemory };