@zuplo/cli 6.71.21 → 6.71.23

package/node_modules/@zuplo/runtime/out/types/index.d.ts

@@ -1,11 +1,28 @@
 import { Attributes } from "@opentelemetry/api";
 import { CallToolRequest } from "@zuplo/mcp/types";
 import { CallToolResult } from "@zuplo/mcp/types";
+import { InboundPolicyHandler as InboundPolicyHandler_2 } from "../../policies.js";
 import { KeyLike } from "jose";
 import { RequestGeneric as RequestGeneric_2 } from "../../request.js";
 import type { ValidateFunction } from "ajv";
 import { z } from "zod/v4";
 
+/**
+ * The request/response **schema dialect** a policy is dealing with — named after
+ * the schema, not the provider or the URL path. `openai-chat` is the OpenAI Chat
+ * Completions schema regardless of the downstream provider (Zuplo translates
+ * chat↔provider underneath); `openai-responses` and `anthropic-messages` are
+ * pass-through schemas whose native shape reaches the provider unchanged.
+ *
+ * Determined by the route, never sniffed from the body. New dialects
+ * (`openai-embeddings`, `openai-images`, …) extend this union.
+ * @public
+ */
+export declare type AiFormat =
+  | "openai-chat"
+  | "openai-responses"
+  | "anthropic-messages";
+
 /**
  * Converts Anthropic Messages API format requests to OpenAI Chat Completions format.
  * This policy translates between the two formats to allow seamless routing to different providers.
@@ -165,6 +182,7 @@ export declare function aiGatewayHandler(
  * @returns A Request or a Response
  */
 export declare class AIGatewayMeteringInboundPolicy extends InboundPolicy<AIGatewayMeteringInboundPolicyOptions> {
+  static readonly policyType = "ai-gateway-metering";
   /**
    * Set the meter increments for the current request.
    *
@@ -192,10 +210,6 @@ export declare class AIGatewayMeteringInboundPolicy extends InboundPolicy<AIGate
   static getQuotaFallback(
     context: ZuploContext
   ): QuotaFallbackModels | undefined;
-  constructor(
-    options: AIGatewayMeteringInboundPolicyOptions,
-    policyName: string
-  );
   handler(
     request: ZuploRequest,
     context: ZuploContext
@@ -333,6 +347,47 @@ export declare function AIGatewaySemanticCacheOutboundPolicy(
  */
 export declare interface AIGatewaySemanticCacheOutboundPolicyOptions {}
 
+/**
+ * AI Gateway Semantic Cache policy (AI Gateway v2). A single inbound policy that
+ * looks up the semantic cache on entry and, on a miss, registers a
+ * response-sending hook to write the upstream response back into the cache —
+ * matching the firewall's single-policy shape (no separate outbound policy).
+ *
+ * Caching parameters (semanticTolerance, expirationSecondsTtl, namespace) come
+ * from the policy options — the policy reads nothing from
+ * `request.user.configuration` to decide whether to cache, and presence in the
+ * route's chain is what enables it. `namespace` defaults to the AI Gateway
+ * configuration id when omitted so caching stays scoped per tenant.
+ *
+ * @title AI Gateway Semantic Cache (v2)
+ * @product ai-gateway
+ * @hidden
+ * @requiresAI
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare function AIGatewaySemanticCacheV2InboundPolicy(
+  request: ZuploRequest,
+  context: ZuploContext,
+  options: AIGatewaySemanticCacheV2InboundPolicyOptions,
+  policyName: string
+): Promise<Response | ZuploRequest<RequestGeneric_2>>;
+
+/**
+ * Options for the AI Gateway Semantic Cache (v2) policy. Configured inline in policies.json; the policy reads nothing from the AI Gateway configuration to decide whether to cache.
+ * @public
+ */
+export declare interface AIGatewaySemanticCacheV2InboundPolicyOptions {
+  semanticTolerance?: SemanticTolerance;
+  expirationSecondsTtl?: CacheTTLSeconds;
+  namespace?: CacheNamespace;
+  endpoints?: ApplicableEndpoints;
+  onUnknownShape?: OnUnknownShape;
+}
+
 /**
  * The options for this policy.
  * @public
@@ -381,6 +436,96 @@ export declare function AIGatewayUsageTrackerPolicy(
   _policyName: string
 ): Promise<Response>;
 
+/**
+ * Common options every AI Gateway policy understands for scoping itself across
+ * the multi-endpoint surface. A policy reads these from its own `options`.
+ * @public
+ */
+export declare interface AiPolicyScopeOptions {
+  /**
+   * The endpoint shapes this policy applies to. When set, the policy is inert on
+   * any other shape. Omit to apply to all shapes.
+   */
+  endpoints?: AiFormat[];
+  /**
+   * What to do when the policy meets a shape it cannot read. `skip` (the default
+   * for observers) passes through; guardrails MUST use `deny` so uninspectable
+   * content is never served.
+   */
+  onUnknownShape?: "deny" | "skip";
+}
+
+/**
+ * The request body for an AI Gateway endpoint, discriminated by {@link AiFormat}.
+ * A policy reads `getFormat(request)` and then narrows to the matching member —
+ * no field is normalized away, so tool calls, content blocks, images, and
+ * thinking are all preserved.
+ * @public
+ */
+export declare type AiRequestBody =
+  | {
+      format: "openai-chat";
+      body: ChatCompletionRequest;
+    }
+  | {
+      format: "openai-responses";
+      body: ResponsesRequest;
+    }
+  | {
+      format: "anthropic-messages";
+      body: AnthropicMessagesRequest;
+    };
+
+/**
+ * The response body for an AI Gateway endpoint, discriminated by {@link AiFormat}.
+ * For the Anthropic Messages pass-through the native response is returned as an
+ * opaque record (the runtime has no dedicated Anthropic response interface).
+ * @public
+ */
+export declare type AiResponseBody =
+  | {
+      format: "openai-chat";
+      body: ChatCompletionResponse;
+    }
+  | {
+      format: "openai-responses";
+      body: ResponsesResponse;
+    }
+  | {
+      format: "anthropic-messages";
+      body: Record<string, unknown>;
+    };
+
+/**
+ * A decoded streaming event, normalized just enough for an observer or guardrail
+ * to act without re-implementing per-dialect SSE parsing. `textDelta` is the
+ * incremental text in this event (if any); `usage` appears on the terminal
+ * event(s); `done` marks the end of the stream.
+ * @public
+ */
+export declare interface AiStreamEvent {
+  /** The raw SSE `data:` payload, parsed from JSON when possible. */
+  raw: unknown;
+  /** Incremental assistant text carried by this event, if any. */
+  textDelta?: string;
+  /** Usage totals, present on the terminal event(s) for the shape. */
+  usage?: AiUsage;
+  /** True for the stream-terminating event (`[DONE]` or shape equivalent). */
+  done?: boolean;
+}
+
+/**
+ * A normalized usage record. Consolidates the per-shape token field names
+ * (`prompt_tokens`/`completion_tokens` for chat, `input_tokens`/`output_tokens`
+ * for responses and Anthropic) into one set.
+ * @public
+ */
+export declare interface AiUsage {
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+}
+
 /**
  * Akamai AI Firewall Inbound Policy
  * @title Akamai AI Firewall
@@ -418,6 +563,48 @@ export declare interface AkamaiAIFirewallPolicyOptions {
   streamingAccumulation?: StreamingAccumulationSettings;
 }
 
+/**
+ * Akamai AI Firewall Inbound Policy (AI Gateway v2)
+ * @title Akamai AI Firewall (v2)
+ * @product ai-gateway
+ * @hidden
+ * @requiresAI
+ *
+ * Detects and blocks malicious AI inputs and outputs via Akamai's AI Firewall
+ * service. Settings come from the policy options (configurationId, api-key,
+ * applicationId, streamingAccumulation) — the policy reads nothing from
+ * `request.user.configuration`, and presence in the route's `inbound[]` chain is
+ * what enables it.
+ *
+ * For streaming responses it uses a transform stream that can block content
+ * mid-stream if harmful content is detected.
+ *
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare function AkamaiAIFirewallV2InboundPolicy(
+  request: ZuploRequest,
+  context: ZuploContext,
+  options: AkamaiAIFirewallV2PolicyOptions,
+  _policyName: string
+): Promise<ZuploRequest | Response>;
+
+/**
+ * The options for the Akamai AI Firewall policy.
+ * @public
+ */
+export declare interface AkamaiAIFirewallV2PolicyOptions {
+  configurationId: ConfigurationID_2;
+  "api-key": APIKey_2;
+  applicationId?: ApplicationID_2;
+  streamingAccumulation?: StreamingAccumulationSettings_2;
+  endpoints?: ApplicableEndpoints_2;
+  onUnknownShape?: OnUnknownShape_2;
+}
+
 /**
  * Entry format for Akamai API Security logger
  * @public
@@ -697,6 +884,39 @@ declare interface AmberfloMeteringProperties extends Omit<
   customerId: string;
 }
 
+declare interface AnthropicMessage {
+  role: "user" | "assistant";
+  content:
+    | string
+    | Array<{
+        type: "text" | "image";
+        text?: string;
+        source?: unknown;
+      }>;
+}
+
+/**
+ * A request to the Anthropic Messages API (`/v1/messages`).
+ *
+ * The gateway forwards this body to Anthropic verbatim on the native passthrough
+ * path, so the shape mirrors Anthropic's API rather than an internal contract.
+ * The index signature carries evolving Anthropic fields (`thinking`,
+ * `tool_choice`, `top_k`, structured `system` blocks, …) through unchanged.
+ */
+declare interface AnthropicMessagesRequest {
+  model: string;
+  messages: AnthropicMessage[];
+  max_tokens: number;
+  system?: string;
+  temperature?: number;
+  top_p?: number;
+  stop_sequences?: string[];
+  stream?: boolean;
+  metadata?: Record<string, unknown>;
+  tools?: unknown[];
+  [key: string]: unknown;
+}
+
 /**
  * Authenticates requests based on API Keys using Zuplo API Management.
  *
@@ -733,6 +953,12 @@ export declare interface ApiAuthKeyInboundPolicyOptions {
  */
 declare type APIKey = string;
 
+/**
+ * The API key for the AI Firewall.
+ * @public
+ */
+declare type APIKey_2 = string;
+
 /**
  * Represents a consumer in the API Key service.
  * @public
@@ -976,12 +1202,58 @@ declare interface APITokenCredentialConfig {
   headerValuePrefix?: string;
 }
 
+/**
+ * The endpoint shapes to cache. Defaults to ['openai-chat'] — the cache keys off chat `messages` and skips other shapes.
+ * @public
+ */
+declare type ApplicableEndpoints = (
+  | "openai-chat"
+  | "openai-responses"
+  | "anthropic-messages"
+)[];
+
+/**
+ * The endpoint shapes this policy applies to. Omit to apply to all (openai-chat, openai-responses, anthropic-messages).
+ * @public
+ */
+declare type ApplicableEndpoints_2 = (
+  | "openai-chat"
+  | "openai-responses"
+  | "anthropic-messages"
+)[];
+
+/**
+ * The endpoint shapes this policy applies to. Omit to apply to all (openai-chat, openai-responses, anthropic-messages).
+ * @public
+ */
+declare type ApplicableEndpoints_3 = (
+  | "openai-chat"
+  | "openai-responses"
+  | "anthropic-messages"
+)[];
+
+/**
+ * The endpoint shapes this policy applies to. Omit to apply to all (openai-chat, openai-responses, anthropic-messages).
+ * @public
+ */
+declare type ApplicableEndpoints_4 = (
+  | "openai-chat"
+  | "openai-responses"
+  | "anthropic-messages"
+)[];
+
 /**
  * The application ID to identify this usage of the AI Firewall (optional).
  * @public
  */
 declare type ApplicationID = string;
 
+/**
+ * The application ID to identify this usage of the AI Firewall (optional).
+ * @public
+ */
+declare type ApplicationID_2 = string;
+
 /**
  * A list of attributes that will be included in the authorization request.
  * @public
@@ -1174,6 +1446,7 @@ export declare interface Auth0JwtInboundPolicyOptions {
  */
 export declare class AuthZenInboundPolicy extends InboundPolicy<AuthZenInboundPolicyOptions> {
   #private;
+  static readonly policyType = "authzen";
   constructor(options: AuthZenInboundPolicyOptions, policyName: string);
   /**
    * The handler that is called each time this policy is invoked
@@ -1494,6 +1767,7 @@ export declare class AWSLoggingPlugin extends LogPlugin {
  */
 export declare class AxiomaticsAuthZInboundPolicy extends InboundPolicy<AxiomaticsAuthZInboundPolicyOptions> {
   #private;
+  static readonly policyType = "axiomatics-authz";
   private pdpService;
   static setAuthAttributes(
     context: ZuploContext,
@@ -1861,6 +2135,7 @@ declare interface BatchDispatcherOptions {
  * @returns A Request or a Response
  */
 export declare class BrownoutInboundPolicy extends InboundPolicy<BrownoutInboundPolicyOptions> {
+  static readonly policyType = "brownout";
   crons: Cron[];
   constructor(options: BrownoutInboundPolicyOptions, policyName: string);
   handler(
@@ -1948,6 +2223,12 @@ declare interface BuildRouteConfiguration {
   /* Excluded from this release type: raw */
 }
 
+/**
+ * Partitions the cache. Omit to default to the AI Gateway configuration id, which keeps caching scoped per tenant.
+ * @public
+ */
+declare type CacheNamespace = string;
+
 /**
  * Internal
  */
@@ -1955,6 +2236,12 @@ declare interface CacheOptions {
   logger?: Logger;
 }
 
+/**
+ * How long a cached response lives, in seconds. Defaults to 3600 (1 hour).
+ * @public
+ */
+declare type CacheTTLSeconds = number;
+
 /**
  * Respond to matched incoming requests with cached content
  *
@@ -2099,12 +2386,112 @@ export declare interface ChangeMethodInboundPolicyOptions {
   method: string;
 }
 
+declare interface ChatCompletionChoice {
+  index: number;
+  message: ChatCompletionMessage;
+  logprobs?: {
+    content: Array<{
+      token: string;
+      logprob: number;
+      bytes?: number[];
+      top_logprobs?: Array<{
+        token: string;
+        logprob: number;
+        bytes?: number[];
+      }>;
+    }> | null;
+  } | null;
+  finish_reason:
+    | "stop"
+    | "length"
+    | "function_call"
+    | "tool_calls"
+    | "content_filter";
+}
+
+declare interface ChatCompletionMessage {
+  role: "system" | "user" | "assistant" | "function" | "tool";
+  content: string;
+  name?: string;
+  function_call?: {
+    name: string;
+    arguments: string;
+  };
+  tool_calls?: Array<{
+    id: string;
+    type: "function";
+    function: {
+      name: string;
+      arguments: string;
+    };
+  }>;
+  tool_call_id?: string;
+}
+
+declare interface ChatCompletionRequest {
+  model: string;
+  messages: ChatCompletionMessage[];
+  temperature?: number;
+  top_p?: number;
+  n?: number;
+  stream?: boolean;
+  stop?: string | string[];
+  max_tokens?: number;
+  presence_penalty?: number;
+  frequency_penalty?: number;
+  user?: string;
+  seed?: number;
+  functions?: FunctionDefinition[];
+  function_call?:
+    | string
+    | {
+        name: string;
+      };
+  tools?: ToolDefinition[];
+  tool_choice?: string | ToolChoice;
+  parallel_tool_calls?: boolean;
+  response_format?: {
+    type: "text" | "json_object" | "json_schema";
+    json_schema?: {
+      name: string;
+      strict?: boolean;
+      schema: Record<string, unknown>;
+    };
+  };
+  logit_bias?: Record<string, number>;
+  logprobs?: boolean;
+  top_logprobs?: number;
+  max_completion_tokens?: number;
+  service_tier?: "auto" | "default";
+  stream_options?: {
+    include_usage?: boolean;
+  };
+}
+
+declare interface ChatCompletionResponse {
+  id: string;
+  object: "chat.completion";
+  created: number;
+  model: string;
+  system_fingerprint?: string;
+  choices: ChatCompletionChoice[];
+  usage: Usage;
+  service_tier?: string;
+  provider?: string;
+}
+
 /**
  * Time interval in milliseconds for periodic checks (alternative to chunk count).
  * @public
  */
 declare type CheckIntervalMs = number;
 
+/**
+ * Time interval in milliseconds for periodic checks (alternative to chunk count).
+ * @public
+ */
+declare type CheckIntervalMs_2 = number;
+
 /**
  * Removes all headers from the incoming request except for those in the exclude list.
  *
@@ -2215,6 +2602,19 @@ declare interface ClientCredentialsConfig {
   apiAudience?: string;
 }
 
+/**
+ * Code interpreter tool
+ */
+declare interface CodeInterpreterTool {
+  type: "code_interpreter";
+  container:
+    | string
+    | {
+        type: "auto";
+        file_ids?: string[];
+      };
+}
+
 /**
  * Authenticate requests with JWT tokens issued by AWS Cognito.
  *
@@ -2301,6 +2701,61 @@ export declare interface CometOpikTracingPolicyOptions {
   baseUrl?: string;
 }
 
+/**
+ * Comet Opik Tracing Inbound Policy (AI Gateway v2)
+ * @title Comet Opik Tracing (v2)
+ * @product ai-gateway
+ * @hidden
+ * @requiresAI
+ *
+ * Traces both streaming and non-streaming AI Gateway responses to Comet Opik,
+ * creating traces when requests start and spans when responses complete.
+ * Credentials (apiKey, projectName, workspace, baseUrl) come from the policy
+ * options — the policy reads nothing from `request.user.configuration` to decide
+ * whether to run, and presence in the route's chain is what enables it.
+ *
+ * For streaming responses, it clones the response stream and processes it in
+ * the background using `waitUntil`, allowing the original stream to pass through
+ * unmodified while still capturing the complete content for tracing.
+ *
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare function CometOpikTracingV2InboundPolicy(
+  request: ZuploRequest,
+  context: ZuploContext,
+  options: CometOpikTracingV2PolicyOptions,
+  _policyName: string
+): Promise<ZuploRequest | Response>;
+
+/**
+ * Track AI Gateway requests and responses using Comet Opik's LLM observability platform.
+ * @public
+ */
+export declare interface CometOpikTracingV2PolicyOptions {
+  /**
+   * The Comet Opik API key for authentication.
+   */
+  apiKey: string;
+  /**
+   * The Comet Opik project name for organizing traces.
+   */
+  projectName: string;
+  /**
+   * The Comet Opik workspace name.
+   */
+  workspace: string;
+  /**
+   * The base URL for the Comet Opik API (optional, defaults to https://www.comet.com/opik/api).
+   */
+  baseUrl?: string;
+  endpoints?: ApplicableEndpoints_3;
+  onUnknownShape?: OnUnknownShape_3;
+}
+
 /**
  * The compatibility date on which to run the gateway
  */
@@ -2411,6 +2866,7 @@ export declare type ComplexRateLimitFunction =
  * @returns A Request or a Response
  */
 export declare class ComplexRateLimitInboundPolicy extends InboundPolicy<ComplexRateLimitInboundPolicyOptions> {
+  static readonly policyType = "complex-rate-limit";
   /**
    * Override the increments for a limit in the current request.
    *
@@ -2519,6 +2975,16 @@ export declare interface CompositeOutboundPolicyOptions {
   policies?: string[];
 }
 
+/**
+ * Computer use tool (preview)
+ */
+declare interface ComputerUseTool {
+  type: "computer_use_preview";
+  display_height: number;
+  display_width: number;
+  environment: "windows" | "mac" | "linux" | "ubuntu" | "browser";
+}
+
 /**
  * Errors caused by invalid user configuration such as invalid parameters on policies,
  * handlers that are not functions, or missing required configuration values.
@@ -2556,6 +3022,12 @@ export declare class ConfigurationError extends RuntimeError {
  */
 declare type ConfigurationID = string;
 
+/**
+ * The configuration ID of the AI Firewall.
+ * @public
+ */
+declare type ConfigurationID_2 = string;
+
 /* Excluded from this release type: ContentTypes */
 
 /**
@@ -2848,6 +3320,16 @@ declare interface CustomRateLimitDetailsBase {
 export declare type CustomRateLimitFunction =
   RateLimitFunction<CustomRateLimitDetails>;
 
+/**
+ * Custom tool
+ */
+declare interface CustomTool {
+  name: string;
+  type: "custom";
+  description?: string;
+  format?: Record<string, unknown>;
+}
+
 declare interface DataDogLoggingOptions {
   url?: string;
   apiKey: string;
@@ -3295,6 +3777,12 @@ export declare class DynatraceMetricsPlugin extends MetricsPlugin {
  */
 declare type EnableStreamingAccumulation = boolean;
 
+/**
+ * Enable accumulation and validation of streaming responses.
+ * @public
+ */
+declare type EnableStreamingAccumulation_2 = boolean;
+
 /**
  * @beta
  * Object exposing environment variables
@@ -3318,6 +3806,12 @@ export declare interface ErrorHandler {
  */
 declare type EventsInterval = number;
 
+/**
+ * Number of SSE events to accumulate before checking with Akamai (default: 5).
+ * @public
+ */
+declare type EventsInterval_2 = number;
+
 declare const EventType: {
   readonly AI_GATEWAY_COST_SUM: "ai_gateway_cost_sum";
   readonly AI_GATEWAY_REQUEST_COUNT: "ai_gateway_request_count";
@@ -3357,6 +3851,16 @@ declare const EventType: {
 
 declare type EventType = (typeof EventType)[keyof typeof EventType];
 
+/**
+ * Best-effort flatten of ALL human/assistant text in a request OR response body,
+ * across every shape — the one sanctioned cross-shape helper. Intended for
+ * guardrails that just need "all the text to scan/moderate"; it is deliberately
+ * lossy (drops roles, structure, tool calls). Everything else should read the
+ * typed body via {@link getRequestBody} / {@link getResponseBody}.
+ * @public
+ */
+export declare function extractAllText(body: unknown): string;
+
 /**
  * Parse a response body and extract its GraphQL `errors[]`, including
  * across an Apollo-style batched (array) response.
@@ -3370,12 +3874,40 @@ export declare function extractGraphqlErrors(
   bodyText: string
 ): GraphqlResponseError[] | null;
 
+/**
+ * Pull the incremental ASSISTANT TEXT from a parsed stream event per shape. The
+ * single source of truth for "is this delta assistant text" — chat
+ * `choices[].delta.content`, Responses `response.output_text.delta` only (NOT
+ * tool-args / audio / refusal / code deltas), Anthropic `content_block_delta`.
+ * Stream-scanning policies (e.g. the firewall accumulator) should call this
+ * rather than re-deriving the per-shape extraction.
+ * @public
+ */
+export declare function extractStreamTextDelta(
+  parsed: unknown,
+  format: AiFormat
+): string | undefined;
+
 declare interface FetchOptions<T> {
   method?: HttpMethod_2;
   data?: T;
   headers?: Record<string, string>;
 }
 
+/**
+ * File search tool
+ */
+declare interface FileSearchTool {
+  type: "file_search";
+  vector_store_ids: string[];
+  filters?: Record<string, unknown> | null;
+  max_num_results?: number;
+  ranking_options?: {
+    ranker?: "auto" | "default-2024-11-15";
+    score_threshold?: number;
+  };
+}
+
 /**
  * Authenticate users using Firebase issued JWT tokens.
  *
@@ -3409,6 +3941,17 @@ export declare interface FirebaseJwtInboundPolicyOptions {
   oAuthResourceMetadataEnabled?: boolean;
 }
 
+/**
+ * Flatten a single message's `content` field to plain text. Content may be a
+ * string (OpenAI chat / simple Anthropic) or an array of content blocks
+ * (Anthropic Messages, OpenAI multi-modal vision, Responses input items). Use
+ * this anywhere a policy needs the text of one message without assuming the
+ * content is a string — a bare `${msg.content}` stringifies array content to
+ * `[object Object]`.
+ * @public
+ */
+export declare function flattenMessageContent(content: unknown): string;
+
 /**
  * Converts form data in the incoming request to JSON.
  *
@@ -3438,6 +3981,23 @@ export declare interface FormDataToJsonInboundPolicyOptions {
   optionalHoneypotName?: string;
 }
 
+declare interface FunctionDefinition {
+  name: string;
+  description?: string;
+  parameters: Record<string, unknown>;
+}
+
+/**
+ * Function tool for Responses API
+ */
+declare interface FunctionTool {
+  name: string;
+  type: "function";
+  parameters: Record<string, unknown> | null;
+  strict: boolean | null;
+  description?: string | null;
+}
+
 /**
  * Galileo Tracing Inbound Policy
  * @title Galileo Tracing
@@ -3487,6 +4047,62 @@ export declare interface GalileoTracingPolicyOptions {
   baseUrl?: string;
 }
 
+/**
+ * Galileo Tracing Inbound Policy (AI Gateway v2)
+ * @title Galileo Tracing (v2)
+ * @product ai-gateway
+ * @hidden
+ * @requiresAI
+ *
+ * Traces both streaming and non-streaming AI Gateway responses to Galileo's LLM
+ * observability platform, creating complete traces with workflow and LLM spans
+ * when responses complete. Credentials (apiKey, projectId, logStreamId, baseUrl)
+ * come from the policy options — the policy reads nothing from
+ * `request.user.configuration` to decide whether to run, and presence in the
+ * route's chain is what enables it.
+ *
+ * For streaming responses, it clones the response stream and processes it in
+ * the background using `waitUntil`, allowing the original stream to pass through
+ * unmodified while still capturing the complete content for tracing.
+ *
+ * @param request - The ZuploRequest
+ * @param context - The ZuploContext
+ * @param options - The policy options set in policies.json
+ * @param policyName - The name of the policy as set in policies.json
+ * @returns A Request or a Response
+ */
+export declare function GalileoTracingV2InboundPolicy(
+  request: ZuploRequest,
+  context: ZuploContext,
+  options: GalileoTracingV2PolicyOptions,
+  _policyName: string
+): Promise<ZuploRequest | Response>;
+
+/**
+ * Track AI Gateway requests and responses using Galileo's LLM observability platform.
+ * @public
+ */
+export declare interface GalileoTracingV2PolicyOptions {
+  /**
+   * The Galileo API key for authentication.
+   */
+  apiKey: string;
+  /**
+   * The Galileo project ID (UUID) for organizing traces.
+   */
+  projectId: string;
+  /**
+   * The Galileo log stream ID (UUID) for organizing traces.
+   */
+  logStreamId: string;
+  /**
+   * The base URL for the Galileo API (optional, defaults to https://api.galileo.ai).
+   */
+  baseUrl?: string;
+  endpoints?: ApplicableEndpoints_4;
+  onUnknownShape?: OnUnknownShape_4;
+}
+
 /**
  * Function to generate request logger entries
  * @public
@@ -3542,6 +4158,18 @@ declare interface GeoSpec {
   asns?: string;
 }
 
+/**
+ * Resolve the AI shape for a request from its endpoint. Mirrors the handler's
+ * base-path resolution so routes mounted under a prefix
+ * (`/{prefix}/v1/chat/completions`) classify the same as the bare path. Returns
+ * `null` for an endpoint that carries no AI body shape (e.g. `/v1/embeddings`).
+ *
+ * The shape is NEVER sniffed from the body — sniffing `!!body.input` misclassifies
+ * an Anthropic body as chat.
+ * @public
+ */
+export declare function getFormat(request: ZuploRequest): AiFormat | null;
+
 /* Excluded from this release type: getIdForParameterSchema */
 
 /* Excluded from this release type: getIdForRefSchema */
@@ -3576,6 +4204,49 @@ declare interface GetQuotaResult {
 
 /* Excluded from this release type: getRawOperationDataIdentifierName */
 
+/**
+ * Read the request body, typed and discriminated by endpoint shape. Returns
+ * `null` for a non-AI endpoint. The body is the native shape — no field is
+ * flattened away.
+ * @public
+ */
+export declare function getRequestBody(
+  request: ZuploRequest
+): Promise<AiRequestBody | null>;
+
+/**
+ * Read the response body, typed and discriminated by endpoint shape. Returns
+ * `null` for a non-AI endpoint or an unparseable body.
+ * @public
+ */
+export declare function getResponseBody(
+  request: ZuploRequest,
+  response: Response
+): Promise<AiResponseBody | null>;
+
+/**
+ * Decode a streamed AI response into normalized {@link AiStreamEvent}s, hiding
+ * the per-shape SSE dialect. A `post_call`-style streaming hook reads
+ * `textDelta` / `usage` / `done` without re-writing SSE parsing per endpoint.
+ * Reads a `clone()` of the response, so the original stream is untouched (the
+ * caller can still return/pipe `response` as-is) — the same observe-via-clone
+ * pattern the tracing policies use.
+ * @public
+ */
+export declare function getStreamEvents(
+  request: ZuploRequest,
+  response: Response
+): AsyncIterable<AiStreamEvent>;
+
+/**
+ * Normalize the usage record from a (non-streaming) response body, regardless of
+ * shape. Chat reports `prompt_tokens`/`completion_tokens`; responses and
+ * Anthropic report `input_tokens`/`output_tokens`. Returns `undefined` when no
+ * usage is present.
+ * @public
+ */
+export declare function getUsage(body: unknown): AiUsage | undefined;
+
 declare interface GoogleCloudLoggingOptions {
   serviceAccountJson: string;
   logName: string;
@@ -3659,6 +4330,21 @@ export declare interface GraphqlAnalyticsOutboundPolicyOptions {
   maxScanBytes?: number;
 }
 
+/**
+ * GraphQL response-cache outcome, as decided by the Zuplo-provided GraphQL
+ * Cache policy (`graphql-cache-inbound`) and reported on its `x-cache`
+ * response header:
+ *  - `"hit"`  — the response was served from cache.
+ *  - `"miss"` — a cache-eligible query that was not in cache (forwarded to
+ *               the origin).
+ *
+ * Operations that are not cache-eligible (mutations, subscriptions,
+ * uncacheable/credentialed requests) — or that ran on a route without the
+ * GraphQL Cache policy — carry no cache state (`null`), and are excluded
+ * from the cache-hit-rate denominator.
+ */
+export declare type GraphqlCacheState = "hit" | "miss";
+
 /**
  * One GraphQL error extracted from a response body, reduced to the
  * fields the GraphQL Analytics outbound policy consumes for
@@ -5318,6 +6004,26 @@ export declare interface HydrolixRequestLoggerPluginOptions<T> {
   batchPeriodSeconds?: number;
 }
 
+/**
+ * Image generation tool
+ */
+declare interface ImageGenerationTool {
+  type: "image_generation";
+  model?: "gpt-image-1" | "gpt-image-1-mini";
+  background?: "transparent" | "opaque" | "auto";
+  input_fidelity?: "high" | "low" | null;
+  input_image_mask?: {
+    file_id?: string;
+    image_url?: string;
+  };
+  moderation?: "auto" | "low";
+  output_compression?: number;
+  output_format?: "png" | "webp" | "jpeg";
+  partial_images?: number;
+  quality?: "low" | "medium" | "high" | "auto";
+  size?: "1024x1024" | "1024x1536" | "1536x1024" | "auto";
+}
+
 /**
  * A policy that can modify the incoming HTTP request before it is sent to
  * the handler. If a response is returned, the request is short-circuited and
@@ -5365,6 +6071,7 @@ export declare interface HydrolixRequestLoggerPluginOptions<T> {
 export declare abstract class InboundPolicy<
   TOptions = any,
 > extends PolicyBase<TOptions> {
+  readonly direction: PolicyDirection;
   /**
    * The handler that is called each time this policy is invoked
    *
@@ -5942,6 +6649,13 @@ export declare const legacyDevPortalHandler: (
   context: ZuploContext
 ) => Response | Promise<Response>;
 
+/**
+ * Local shell tool
+ */
+declare interface LocalShellTool {
+  type: "local_shell";
+}
+
 /**
  * @beta
  */
@@ -6116,6 +6830,7 @@ declare type LokiTransportVersion = 1 | 2;
  */
 export declare class McpAuth0OAuthInboundPolicy extends InboundPolicy<ValidatedAuth0OAuthOptions> {
   #private;
+  static readonly policyType = "mcp-auth0-oauth";
   constructor(rawOptions: unknown, policyName: string);
   handler(
     request: ZuploRequest,
@@ -6294,6 +7009,7 @@ declare const mcpAuth0OAuthOptionsSchema: z.ZodObject<
  */
 export declare class McpClerkOAuthInboundPolicy extends InboundPolicy<McpClerkOAuthInboundPolicyOptions> {
   #private;
+  static readonly policyType = "mcp-clerk-oauth";
   constructor(rawOptions: unknown, policyName: string);
   handler(
     request: ZuploRequest,
@@ -6364,6 +7080,7 @@ export declare interface McpClerkOAuthInboundPolicyOptions {
  */
 export declare class McpCognitoOAuthInboundPolicy extends InboundPolicy<McpCognitoOAuthInboundPolicyOptions> {
   #private;
+  static readonly policyType = "mcp-cognito-oauth";
   constructor(rawOptions: unknown, policyName: string);
   handler(
     request: ZuploRequest,
@@ -6445,6 +7162,7 @@ export declare interface McpCognitoOAuthInboundPolicyOptions {
  */
 export declare class McpEntraOAuthInboundPolicy extends InboundPolicy<McpEntraOAuthInboundPolicyOptions> {
   #private;
+  static readonly policyType = "mcp-entra-oauth";
   constructor(rawOptions: unknown, policyName: string);
   handler(
     request: ZuploRequest,
@@ -6521,6 +7239,7 @@ export declare interface McpEntraOAuthInboundPolicyOptions {
  */
 export declare class McpGoogleOAuthInboundPolicy extends InboundPolicy<McpGoogleOAuthInboundPolicyOptions> {
   #private;
+  static readonly policyType = "mcp-google-oauth";
   constructor(rawOptions: unknown, policyName: string);
   handler(
     request: ZuploRequest,
@@ -6591,6 +7310,7 @@ export declare interface McpGoogleOAuthInboundPolicyOptions {
  */
 export declare class McpKeycloakOAuthInboundPolicy extends InboundPolicy<McpKeycloakOAuthInboundPolicyOptions> {
   #private;
+  static readonly policyType = "mcp-keycloak-oauth";
   constructor(rawOptions: unknown, policyName: string);
   handler(
     request: ZuploRequest,
@@ -6668,6 +7388,7 @@ export declare interface McpKeycloakOAuthInboundPolicyOptions {
  */
 export declare class McpLogtoOAuthInboundPolicy extends InboundPolicy<McpLogtoOAuthInboundPolicyOptions> {
   #private;
+  static readonly policyType = "mcp-logto-oauth";
   constructor(rawOptions: unknown, policyName: string);
   handler(
     request: ZuploRequest,
@@ -6746,6 +7467,7 @@ export declare interface McpLogtoOAuthInboundPolicyOptions {
  * @product mcp-gateway
  */
 export declare class McpOAuthInboundPolicy extends InboundPolicy<McpOAuthRuntimeConfig> {
+  static readonly policyType = "mcp-oauth";
   constructor(rawOptions: unknown, policyName: string);
   handler(
     request: ZuploRequest,
@@ -7022,6 +7744,7 @@ declare const mcpOAuthRuntimeConfigSchema: z.ZodObject<
  */
 export declare class McpOktaOAuthInboundPolicy extends InboundPolicy<McpOktaOAuthInboundPolicyOptions> {
   #private;
+  static readonly policyType = "mcp-okta-oauth";
   constructor(rawOptions: unknown, policyName: string);
   handler(
     request: ZuploRequest,
@@ -7099,6 +7822,7 @@ export declare interface McpOktaOAuthInboundPolicyOptions {
  */
 export declare class McpOneLoginOAuthInboundPolicy extends InboundPolicy<McpOneLoginOAuthInboundPolicyOptions> {
   #private;
+  static readonly policyType = "mcp-onelogin-oauth";
   constructor(rawOptions: unknown, policyName: string);
   handler(
     request: ZuploRequest,
@@ -7169,6 +7893,7 @@ export declare interface McpOneLoginOAuthInboundPolicyOptions {
  */
 export declare class McpPingOAuthInboundPolicy extends InboundPolicy<McpPingOAuthInboundPolicyOptions> {
   #private;
+  static readonly policyType = "mcp-ping-oauth";
   constructor(rawOptions: unknown, policyName: string);
   handler(
     request: ZuploRequest,
@@ -7256,6 +7981,29 @@ export declare function mcpServerHandler(
   context: ZuploContext
 ): Promise<Response>;
 
+/**
+ * MCP (Model Context Protocol) tool
+ */
+declare interface McpTool {
+  server_label: string;
+  type: "mcp";
+  allowed_tools?: string[] | Record<string, unknown> | null;
+  authorization?: string;
+  connector_id?:
+    | "connector_dropbox"
+    | "connector_gmail"
+    | "connector_googlecalendar"
+    | "connector_googledrive"
+    | "connector_microsoftteams"
+    | "connector_outlookcalendar"
+    | "connector_outlookemail"
+    | "connector_sharepoint";
+  headers?: Record<string, string> | null;
+  require_approval?: Record<string, unknown> | "always" | "never" | null;
+  server_description?: string;
+  server_url?: string;
+}
+
 /**
  * Authenticate MCP gateway requests using a gateway-issued OAuth access token,
  * with browser login delegated to WorkOS.
@@ -7271,6 +8019,7 @@ export declare function mcpServerHandler(
  */
 export declare class McpWorkosOAuthInboundPolicy extends InboundPolicy<McpWorkosOAuthInboundPolicyOptions> {
   #private;
+  static readonly policyType = "mcp-workos-oauth";
   constructor(rawOptions: unknown, policyName: string);
   handler(
     request: ZuploRequest,
@@ -7614,6 +8363,7 @@ export declare interface MoesifInboundPolicyOptions {
  */
 export declare class MonetizationInboundPolicy extends InboundPolicy<MonetizationInboundPolicyOptions> {
   #private;
+  static readonly policyType = "monetization";
   /**
    * Set the monetization subscription data for the current request.
    *
@@ -7936,6 +8686,7 @@ export declare interface OAuthProtectedResourcePluginOptions {
  * @returns A Request or a Response
  */
 export declare class OktaFGAAuthZInboundPolicy extends BaseOpenFGAAuthZInboundPolicy {
+  static readonly policyType = "oktafga-authz";
   constructor(options: OktaFGAAuthZInboundPolicyOptions, policyName: string);
 }
 
@@ -8055,6 +8806,30 @@ declare interface OnSendingAwsLambdaEventHook {
   ): Promise<AwsLambdaEventV1 | AwsLambdaEventV2>;
 }
 
+/**
+ * Unused by the cache (a cache miss is never unsafe, so it always fails open). Present for interface consistency.
+ * @public
+ */
+declare type OnUnknownShape = "deny" | "skip";
+
+/**
+ * What to do when the request shape cannot be inspected. As a guardrail, this policy defaults to 'deny' (fail closed) so uninspectable content is never served.
+ * @public
+ */
+declare type OnUnknownShape_2 = "deny" | "skip";
+
+/**
+ * What to do on a shape the policy cannot read. As an observer this defaults to 'skip' (fail open — pass through untraced).
+ * @public
+ */
+declare type OnUnknownShape_3 = "deny" | "skip";
+
+/**
+ * What to do on a shape the policy cannot read. As an observer this defaults to 'skip' (fail open — pass through untraced).
+ * @public
+ */
+declare type OnUnknownShape_4 = "deny" | "skip";
+
 /**
  * Handler that serves OpenAPI specification files.
  * Use this to expose your API documentation in a standard format that can be
@@ -8651,7 +9426,7 @@ declare namespace OpenAPIV3_1 {
  * @returns A Request or a Response
  */
 export declare class OpenFGAAuthZInboundPolicy extends BaseOpenFGAAuthZInboundPolicy {
-  constructor(options: OpenFGAAuthZInboundPolicyOptions, policyName: string);
+  static readonly policyType = "openfga-authz";
 }
 
 /**
@@ -8787,6 +9562,7 @@ export declare interface OpenIdJwtInboundPolicyOptions {
  */
 export declare class OpenMeterInboundPolicy extends InboundPolicy<OpenMeterInboundPolicyOptions> {
   #private;
+  static readonly policyType = "openmeter-metering";
   constructor(options: OpenMeterInboundPolicyOptions, policyName: string);
   handler(
     request: ZuploRequest<RequestGeneric>,
@@ -8972,6 +9748,7 @@ export declare class OTelMetricsPlugin extends MetricsPlugin {
 export declare abstract class OutboundPolicy<
   TOptions = any,
 > extends PolicyBase<TOptions> {
+  readonly direction: PolicyDirection;
   /**
    * The handler that is called each time this policy is invoked
    *
@@ -9098,16 +9875,11 @@ declare interface ParsedRouteData extends Omit<RouteData, "corsPolicies"> {
   /* Excluded from this release type: getInboundPolicyInstance */
 }
 
-/**
- * The base class for inbound and outbound policies.
- * Provides common functionality for all policy types.
- *
- * @public
- */
 declare abstract class PolicyBase<TOptions = any> {
   options: TOptions;
   policyName: string;
-  policyType: string;
+  /* Excluded from this release type: policyType */
+  /* Excluded from this release type: direction */
   /* Excluded from this release type: __constructor */
 }
 
@@ -9121,6 +9893,22 @@ export declare interface PolicyConfiguration {
   options?: unknown;
 }
 
+/**
+ * The base class for inbound and outbound policies.
+ * Provides common functionality for all policy types.
+ *
+ * @public
+ */
+/**
+ * The pipeline phase a policy runs in. Inbound policies run on the request
+ * before the handler; outbound policies run on the response after it. This is
+ * determined structurally by whether a policy extends {@link InboundPolicy} or
+ * {@link OutboundPolicy}, so it can never drift from the policy's real phase.
+ *
+ * @public
+ */
+declare type PolicyDirection = "inbound" | "outbound";
+
 /**
  * @public
  */
@@ -9398,7 +10186,7 @@ declare interface QuotaFallbackModels {
  */
 export declare class QuotaInboundPolicy extends InboundPolicy<QuotaInboundPolicyOptions> {
   #private;
-  constructor(options: QuotaInboundPolicyOptions, policyName: string);
+  static readonly policyType = "quota";
   handler(
     request: ZuploRequest<RequestGeneric>,
     context: ZuploContext
@@ -9696,6 +10484,28 @@ export declare function ReadmeMetricsInboundPolicy(
   policyName: string
 ): Promise<ZuploRequest<RequestGeneric_2>>;
 
+/**
+ * Record the GraphQL response-cache outcome for the in-flight operation so
+ * the analytics middleware can emit it as the `cacheState` dimension on the
+ * `graphql_operation` event.
+ *
+ * Called by the Zuplo-provided GraphQL Cache policy (`graphql-cache-inbound`,
+ * in the `@zuplo/graphql` package) the moment it resolves a cache hit or
+ * miss — synchronously during inbound processing, before the analytics
+ * middleware finalizes the event. Mirrors how the GraphQL Analytics outbound
+ * policy feeds errors through {@link getOperationContext}.
+ *
+ * No-op when the request isn't running the GraphQL analytics middleware (the
+ * route lacks the `x-graphql: true` marker, so there's no operation context to
+ * write to), so it's always safe to call.
+ *
+ * @public
+ */
+export declare function recordGraphqlCacheState(
+  context: ZuploContext,
+  cacheState: GraphqlCacheState
+): void;
+
 /**
  * Handler that returns HTTP redirects.
  * Useful for URL shortening, legacy URL handling, or routing to external services.
@@ -10187,6 +10997,43 @@ export declare function responseHasGraphqlErrors(
   maxScanBytes?: number
 ): Promise<boolean>;
 
+declare interface ResponseInputItem {
+  type?: "message";
+  role: "user" | "assistant" | "system" | "developer";
+  content:
+    | string
+    | Array<{
+        type: "text" | "image_url" | "audio";
+        text?: string;
+        image_url?: {
+          url: string;
+        };
+        audio?: {
+          data: string;
+          format: string;
+        };
+      }>;
+}
+
+declare interface ResponsesChoice {
+  index: number;
+  id?: string;
+  type?: "message";
+  role?: "assistant";
+  content?: Array<{
+    type: "output_text";
+    text: string;
+    annotations?: Array<unknown>;
+  }>;
+  status?: string | null;
+  finish_reason?:
+    | "stop"
+    | "length"
+    | "function_call"
+    | "tool_calls"
+    | "content_filter";
+}
+
 /**
  * Definition of responses for a route
  * @public
@@ -10223,6 +11070,115 @@ export declare class ResponseSentEvent extends Event {
   readonly response: Response;
 }
 
+declare interface ResponsesRequest {
+  input?: string | ResponseInputItem[];
+  model?: string;
+  instructions?: string;
+  previous_response_id?: string;
+  temperature?: number;
+  top_p?: number;
+  stream?: boolean;
+  max_output_tokens?: number;
+  tools?: ResponsesToolDefinition[];
+  tool_choice?: ResponsesToolChoice;
+  parallel_tool_calls?: boolean;
+  reasoning?: {
+    effort: "low" | "medium" | "high";
+  };
+  service_tier?: "auto" | "default" | "flex" | "scale" | "priority";
+  stream_options?: {
+    include_usage?: boolean;
+  };
+  background?: boolean;
+  conversation?: string;
+  include?: string[];
+  metadata?: Record<string, unknown>;
+  store?: boolean;
+  truncation?: "auto" | "disabled";
+  prompt_cache_key?: string;
+  safety_identifier?: string;
+}
+
+declare interface ResponsesResponse {
+  id: string;
+  object: "response";
+  created: number;
+  model: string;
+  status:
+    | "queued"
+    | "in_progress"
+    | "completed"
+    | "failed"
+    | "cancelled"
+    | "incomplete";
+  system_fingerprint?: string;
+  output?: ResponsesChoice[];
+  usage?: ResponsesUsage;
+  error?: {
+    type: string;
+    message: string;
+  };
+  service_tier?: string;
+  provider?: string;
+}
+
+declare type ResponsesToolChoice =
+  | "none"
+  | "auto"
+  | "required"
+  | {
+      mode: "auto" | "required";
+      tools: Array<Record<string, unknown>>;
+      type: "allowed_tools";
+    }
+  | {
+      name: string;
+      type: "custom";
+    }
+  | {
+      name: string;
+      type: "function";
+    }
+  | {
+      server_label: string;
+      type: "mcp";
+      name?: string | null;
+    }
+  | {
+      type:
+        | "file_search"
+        | "web_search_preview"
+        | "computer_use_preview"
+        | "web_search_preview_2025_03_11"
+        | "image_generation"
+        | "code_interpreter"
+        | "mcp";
+    };
+
+declare type ResponsesToolDefinition =
+  | FunctionTool
+  | WebSearchTool
+  | WebSearchPreviewTool
+  | CodeInterpreterTool
+  | FileSearchTool
+  | ComputerUseTool
+  | ImageGenerationTool
+  | LocalShellTool
+  | CustomTool
+  | McpTool;
+
+declare interface ResponsesUsage {
+  input_tokens: number;
+  output_tokens: number;
+  total_tokens: number;
+  input_tokens_details?: {
+    cached_tokens?: number;
+  };
+  output_tokens_details?: {
+    reasoning_tokens?: number;
+  };
+}
+
 /**
  * @public
  */
@@ -10500,6 +11456,12 @@ export declare type SemanticCacheInboundPolicyOptions = {
   cacheStatusHeaderName?: string;
 };
 
+/**
+ * The semantic similarity threshold for semantic cache matches. Values closer to 0 require closer similarity, while larger values allow more flexible matching. Default is 0.2.
+ * @public
+ */
+declare type SemanticTolerance = number;
+
 /* Excluded from this release type: serialize */
 
 /**
@@ -10550,7 +11512,7 @@ export declare interface SetBodyInboundPolicyOptions {
  * @param policyName - The name of the policy as set in policies.json
  * @returns A Request or a Response
  */
-export declare const SetHeadersInboundPolicy: InboundPolicyHandler<SetHeadersInboundPolicyOptions>;
+export declare const SetHeadersInboundPolicy: InboundPolicyHandler_2<SetHeadersInboundPolicyOptions>;
 
 /**
  * The options for this policy.
@@ -10823,6 +11785,16 @@ declare interface StreamingAccumulationSettings {
   checkIntervalMs?: CheckIntervalMs;
 }
 
+/**
+ * Configuration for accumulating and validating streaming responses.
+ * @public
+ */
+declare interface StreamingAccumulationSettings_2 {
+  enabled?: EnableStreamingAccumulation_2;
+  eventsInterval?: EventsInterval_2;
+  checkIntervalMs?: CheckIntervalMs_2;
+}
+
 /**
  * A specialized zone cache for storing and retrieving ReadableStreams.
  * Unlike regular ZoneCache which serializes to JSON, this cache stores raw stream data,
@@ -10928,10 +11900,7 @@ export declare class StreamingZoneCache {
  * @returns A Request or a Response
  */
 export declare class StripeWebhookVerificationInboundPolicy extends InboundPolicy<StripeWebhookVerificationInboundPolicyOptions> {
-  constructor(
-    options: StripeWebhookVerificationInboundPolicyOptions,
-    policyName: string
-  );
+  static readonly policyType = "stripe-webhook-verification";
   handler(
     request: ZuploRequest,
     context: ZuploContext
@@ -11048,6 +12017,18 @@ export declare abstract class TelemetryPlugin extends RuntimePlugin {
   /* Excluded from this release type: instrument */
 }
 
+declare interface ToolChoice {
+  type: "function";
+  function: {
+    name: string;
+  };
+}
+
+declare interface ToolDefinition {
+  type: "function";
+  function: FunctionDefinition;
+}
+
 /* Excluded from this release type: trackFeature */
 
 /**
@@ -11283,6 +12264,7 @@ export declare interface UpstreamFirebaseUserAuthInboundPolicyOptions {
  * @returns A Request or a Response
  */
 export declare class UpstreamGcpFederatedAuthInboundPolicy extends InboundPolicy<UpstreamGcpFederatedAuthInboundPolicyOptions> {
+  static readonly policyType = "upstream-gcp-federated-auth";
   private cacheName;
   private normalizedWorkloadIdentityProvider;
   constructor(
@@ -11438,6 +12420,7 @@ export declare interface UpstreamGcpServiceAuthInboundPolicyOptions {
  * @returns A ZuploRequest
  */
 export declare class UpstreamZuploJwtAuthInboundPolicy extends InboundPolicy<UpstreamZuploJwtAuthInboundPolicyOptions> {
+  static readonly policyType = "upstream-zuplo-jwt";
   constructor(
     options: UpstreamZuploJwtAuthInboundPolicyOptions,
     policyName: string
@@ -11622,6 +12605,22 @@ export declare function urlRewriteHandler(
   context: ZuploContext
 ): Promise<Response>;
 
+declare interface Usage {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+  prompt_tokens_details?: {
+    cached_tokens?: number;
+    audio_tokens?: number;
+  };
+  completion_tokens_details?: {
+    reasoning_tokens?: number;
+    audio_tokens?: number;
+    accepted_prediction_tokens?: number;
+    rejected_prediction_tokens?: number;
+  };
+}
+
 declare type UserDataDefault = any;
 
 declare type ValidatedAuth0OAuthOptions = z.infer<
@@ -11788,6 +12787,38 @@ export declare interface WebBotAuthInboundPolicyOptions {
   directoryUrl?: string;
 }
 
+/**
+ * Web search tool (preview version)
+ */
+declare interface WebSearchPreviewTool {
+  type: "web_search_preview" | "web_search_preview_2025_03_11";
+  search_context_size?: "low" | "medium" | "high";
+  user_location?: {
+    type: "approximate";
+    city?: string | null;
+    country?: string | null;
+    region?: string | null;
+    timezone?: string | null;
+  } | null;
+}
+
+/**
+ * Web search tool (stable version)
+ */
+declare interface WebSearchTool {
+  type: "web_search" | "web_search_2025_08_26";
+  filters?: {
+    allowed_domains?: string[] | null;
+  } | null;
+  search_context_size?: "low" | "medium" | "high";
+  user_location?: {
+    city?: string | null;
+    country?: string | null;
+    region?: string | null;
+    timezone?: string | null;
+  } | null;
+}
+
 /**
  * Handler that proxies WebSocket connections to a different URL.
  * Enables WebSocket support in your API gateway for real-time communication.
@@ -11891,6 +12922,7 @@ declare interface XacmlRequest {
  * @returns A Request or a Response
  */
 export declare class XmlToJsonOutboundPolicy extends OutboundPolicy<XmlToJsonPolicyOptions> {
+  static readonly policyType = "xml-to-json";
   private parser;
   private parseOnStatusCodes;
   constructor(options: XmlToJsonPolicyOptions, policyName: string);