flexinference 1.0.1 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 1.2.0
+
+Adds the **Messages** caller format (`client.messages.create`), the fourth format
+alongside Responses, chat completions, and Interactions. It takes and returns the
+Anthropic Messages shape and works for any model via the canonical Responses path,
+posting to `/messages`. `max_tokens` is required (Anthropic requires it) and
+`start_within` is required (same rule as the other formats); `service_tier` is a
+compile-time error (the router owns the tier). New `messageText(obj)` helper pulls the
+assistant text out of the response `content[]` blocks, where `outputText` and
+`interactionText` return "". Also adds first-class Anthropic (`claude-*`) upstream
+support behind the existing formats.
+
+## 1.1.0
+
+Adds the **Interactions** caller format (`client.interactions.create`), the third format
+alongside Responses and chat completions. It works for both OpenAI and Gemini models and
+posts to `/interactions`. `start_within` is required (same rule as the other formats) and
+`service_tier` is a compile-time error (the router owns the tier). New `interactionText(obj)`
+helper pulls the assistant text out of the `steps[]` shape, where `outputText` returns "".
+
 ## 1.0.1
 
 Gemini now supports **image input** and **web search** (send a Responses `web_search`

package/dist/index.d.ts

@@ -17,6 +17,16 @@ type RawChatRequest = Schemas["CreateChatCompletionRequest"];
 export type ChatCompletionCreateParams = WithStartWithin<Partial<RawChatRequest> & Required<Pick<RawChatRequest, "model" | "messages">>>;
 export type ChatCompletion = Schemas["CreateChatCompletionResponse"];
 export type ChatCompletionChunk = Schemas["CreateChatCompletionStreamResponse"];
+export type InteractionCreateParams = WithStartWithin<Schemas["InteractionCreateParams"]> & {
+    service_tier?: never;
+};
+export type InteractionObject = Schemas["InteractionObject"];
+export type InteractionStreamEvent = Schemas["InteractionStreamEvent"];
+export type MessageCreateParams = WithStartWithin<Schemas["MessageCreateParams"]> & {
+    service_tier?: never;
+};
+export type MessageObject = Schemas["MessageObject"];
+export type MessageStreamEvent = Schemas["MessageStreamEvent"];
 /**
  * Concatenate the assistant's text from a non-streamed response. Works on a Responses
  * object (walks `output[].content[]` for `output_text` parts) and on a chat completion
@@ -27,6 +37,23 @@ export type ChatCompletionChunk = Schemas["CreateChatCompletionStreamResponse"];
  * their `output_text.delta` events instead.
  */
 export declare function outputText(response: ResponseObject | ChatCompletion): string;
+/**
+ * Concatenate the assistant's text from a non-streamed Interactions response. The text
+ * lives in `steps[]` of type `model_output`, each a `content[]` of `{type:"text",text}`
+ * parts (a different shape from Responses/chat, so `outputText` returns "" on it). Returns
+ * "" when there is no text (e.g. a function-call-only interaction). Read-only: nothing is
+ * reshaped. Streamed interactions are not objects; collect their `step.delta` text events.
+ */
+export declare function interactionText(interaction: InteractionObject): string;
+/**
+ * Concatenate the assistant's text from a non-streamed Messages response. The text lives
+ * in `content[]` as `{type:"text",text}` blocks (thinking and tool_use blocks are
+ * skipped) - the Anthropic Messages shape, a different layout from Responses/chat and
+ * Interactions, so `outputText` and `interactionText` return "" on it. Returns "" when
+ * there is no text (e.g. a tool_use-only response). Read-only: nothing is reshaped.
+ * Streamed messages are not objects; collect their `content_block_delta` text events.
+ */
+export declare function messageText(message: MessageObject): string;
 export interface FlexErrorBody {
     error: {
         message: string;
@@ -65,6 +92,8 @@ type Post = (path: string, body: unknown, signal: AbortSignal | undefined) => Pr
 export declare class FlexInference {
     readonly responses: Responses;
     readonly chat: Chat;
+    readonly interactions: Interactions;
+    readonly messages: Messages;
     private readonly apiKey;
     private readonly baseURL;
     private readonly fetchImpl;
@@ -96,4 +125,24 @@ declare class ChatCompletions {
         stream: true;
     }, options?: RequestOptions): Promise<AsyncIterable<ChatCompletionChunk>>;
 }
+declare class Interactions {
+    private readonly post;
+    constructor(post: Post);
+    create(body: InteractionCreateParams & {
+        stream?: false | null;
+    }, options?: RequestOptions): Promise<InteractionObject>;
+    create(body: InteractionCreateParams & {
+        stream: true;
+    }, options?: RequestOptions): Promise<AsyncIterable<InteractionStreamEvent>>;
+}
+declare class Messages {
+    private readonly post;
+    constructor(post: Post);
+    create(body: MessageCreateParams & {
+        stream?: false | null;
+    }, options?: RequestOptions): Promise<MessageObject>;
+    create(body: MessageCreateParams & {
+        stream: true;
+    }, options?: RequestOptions): Promise<AsyncIterable<MessageStreamEvent>>;
+}
 export {};

package/dist/index.js

@@ -36,6 +36,55 @@ export function outputText(response) {
     }
     return "";
 }
+/**
+ * Concatenate the assistant's text from a non-streamed Interactions response. The text
+ * lives in `steps[]` of type `model_output`, each a `content[]` of `{type:"text",text}`
+ * parts (a different shape from Responses/chat, so `outputText` returns "" on it). Returns
+ * "" when there is no text (e.g. a function-call-only interaction). Read-only: nothing is
+ * reshaped. Streamed interactions are not objects; collect their `step.delta` text events.
+ */
+export function interactionText(interaction) {
+    const obj = interaction;
+    if (!isRecord(obj))
+        return "";
+    const steps = obj.steps;
+    if (!Array.isArray(steps))
+        return "";
+    let text = "";
+    for (const step of steps) {
+        if (!isRecord(step) || step.type !== "model_output" || !Array.isArray(step.content))
+            continue;
+        for (const part of step.content) {
+            if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
+                text += part.text;
+            }
+        }
+    }
+    return text;
+}
+/**
+ * Concatenate the assistant's text from a non-streamed Messages response. The text lives
+ * in `content[]` as `{type:"text",text}` blocks (thinking and tool_use blocks are
+ * skipped) - the Anthropic Messages shape, a different layout from Responses/chat and
+ * Interactions, so `outputText` and `interactionText` return "" on it. Returns "" when
+ * there is no text (e.g. a tool_use-only response). Read-only: nothing is reshaped.
+ * Streamed messages are not objects; collect their `content_block_delta` text events.
+ */
+export function messageText(message) {
+    const obj = message;
+    if (!isRecord(obj))
+        return "";
+    const content = obj.content;
+    if (!Array.isArray(content))
+        return "";
+    let text = "";
+    for (const block of content) {
+        if (isRecord(block) && block.type === "text" && typeof block.text === "string") {
+            text += block.text;
+        }
+    }
+    return text;
+}
 export class FlexInferenceError extends Error {
     status;
     type;
@@ -87,6 +136,8 @@ function assertStartWithin(body) {
 export class FlexInference {
     responses;
     chat;
+    interactions;
+    messages;
     apiKey;
     baseURL;
     fetchImpl;
@@ -105,6 +156,8 @@ export class FlexInference {
         const post = (path, body, signal) => this.post(path, body, signal);
         this.responses = new Responses(post);
         this.chat = new Chat(post);
+        this.interactions = new Interactions(post);
+        this.messages = new Messages(post);
     }
     async post(path, body, signal) {
         // One AbortController fed by three sources: the caller's signal, a 10s connect
@@ -214,6 +267,44 @@ class ChatCompletions {
         }
     }
 }
+class Interactions {
+    post;
+    constructor(post) {
+        this.post = post;
+    }
+    async create(body, options) {
+        assertStartWithin(body);
+        const { res, cleanup } = await this.post("/interactions", body, options?.signal);
+        if (body.stream) {
+            return streamSSE(res, cleanup);
+        }
+        try {
+            return (await res.json());
+        }
+        finally {
+            cleanup();
+        }
+    }
+}
+class Messages {
+    post;
+    constructor(post) {
+        this.post = post;
+    }
+    async create(body, options) {
+        assertStartWithin(body);
+        const { res, cleanup } = await this.post("/messages", body, options?.signal);
+        if (body.stream) {
+            return streamSSE(res, cleanup);
+        }
+        try {
+            return (await res.json());
+        }
+        finally {
+            cleanup();
+        }
+    }
+}
 async function* streamSSE(res, cleanup) {
     if (!res.body) {
         cleanup();

package/dist/types.d.ts

@@ -64,6 +64,40 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/interactions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Create an interaction. The third FlexInference caller format; works for OpenAI and Gemini models via the canonical Responses path. Send start_within and do not send service_tier. */
+        post: operations["createInteraction"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/messages": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /** Create a message. The fourth FlexInference caller format (Anthropic Messages shape in and out); works for any model via the canonical Responses path. Send start_within and do not send service_tier. max_tokens is required. */
+        post: operations["createMessage"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -1105,7 +1139,7 @@ export interface components {
              */
             top_logprobs?: number;
             /**
-             * @description FlexInference deadline control. Required on every request. "default", "priority", and "auto" map to those OpenAI service tiers ("auto" lets OpenAI pick) and proxy any model. A duration "HHh-MMm-SSs" between 5 seconds and 10 minutes runs the flex tier on a flex-capable model and automatically falls back to standard if it has not started within the window. The retired value "standard" is no longer accepted (use "default").
+             * @description FlexInference deadline control. Required on every request. "default" maps to the provider's standard real-time tier (OpenAI "default", Gemini "standard"), "priority" to the provider's priority tier, and "auto" to OpenAI's auto tier (OpenAI only; Gemini has no auto tier). These proxy any model. A duration "HHh-MMm-SSs" between 5 seconds and 10 minutes runs the provider's flex tier (OpenAI or Gemini) on a flex-capable model and automatically falls back to standard if it has not started within the window. Do not send service_tier (the router controls the tier). The retired value "standard" is no longer accepted (use "default").
              * @example 00h-00m-30s
              */
             start_within?: string;
@@ -5366,6 +5400,579 @@ export interface components {
                 param?: string | null;
             };
         };
+        /** Interaction Text Part */
+        InteractionTextPart: {
+            /** @constant */
+            type: "text";
+            text: string;
+        };
+        /** Interaction Image Part */
+        InteractionImagePart: {
+            /** @constant */
+            type: "image";
+            mime_type: string;
+            /** @description Base64-encoded image bytes. */
+            data: string;
+        };
+        /** Interaction Document Part */
+        InteractionDocumentPart: {
+            /** @constant */
+            type: "document";
+            mime_type: string;
+            /** @description Base64-encoded document bytes. */
+            data: string;
+        };
+        /**
+         * Interaction Content Part
+         * @description A single piece of multimodal content in an Interactions request.
+         */
+        InteractionContentPart: components["schemas"]["InteractionTextPart"] | components["schemas"]["InteractionImagePart"] | components["schemas"]["InteractionDocumentPart"];
+        /** Interaction User Input Step */
+        InteractionUserInputStep: {
+            /** @constant */
+            type: "user_input";
+            content: components["schemas"]["InteractionContentPart"][];
+        };
+        /** Interaction Model Output Step */
+        InteractionModelOutputStep: {
+            /** @constant */
+            type: "model_output";
+            content: components["schemas"]["InteractionContentPart"][];
+        };
+        /** Interaction Function Call Step */
+        InteractionFunctionCallStep: {
+            /** @constant */
+            type: "function_call";
+            id?: string;
+            name: string;
+            /** @description Parsed function arguments object (not a JSON string). */
+            arguments: {
+                [key: string]: unknown;
+            };
+        };
+        /** Interaction Function Result Step */
+        InteractionFunctionResultStep: {
+            /** @constant */
+            type: "function_result";
+            name: string;
+            /** @description Tool result payload; any JSON value. */
+            result: unknown;
+        };
+        /**
+         * Interaction Step
+         * @description One turn in a multi-turn Interactions request (a step list).
+         */
+        InteractionStep: components["schemas"]["InteractionUserInputStep"] | components["schemas"]["InteractionModelOutputStep"] | components["schemas"]["InteractionFunctionCallStep"] | components["schemas"]["InteractionFunctionResultStep"];
+        /** Interaction Function Tool */
+        InteractionFunctionTool: {
+            /** @constant */
+            type: "function";
+            name: string;
+            description?: string;
+            /** @description JSON Schema for the function parameters. */
+            parameters?: {
+                [key: string]: unknown;
+            };
+        };
+        /** Interaction Google Search Tool */
+        InteractionGoogleSearchTool: {
+            /** @constant */
+            type: "google_search";
+        };
+        /** Interaction Tool */
+        InteractionTool: components["schemas"]["InteractionFunctionTool"] | components["schemas"]["InteractionGoogleSearchTool"];
+        /**
+         * Interaction Generation Config
+         * @description Generation controls. thinking_level maps to canonical reasoning.effort.
+         */
+        InteractionGenerationConfig: {
+            max_output_tokens?: number;
+            temperature?: number;
+            top_p?: number;
+            /** @enum {string} */
+            thinking_level?: "minimal" | "low" | "medium" | "high";
+            /** @description auto, none, or any. "any" maps to canonical tool_choice "required". */
+            tool_choice?: string;
+        };
+        /**
+         * Interaction Create Params
+         * @description Request body for POST /v1/interactions. Works for both OpenAI and Gemini models via the canonical Responses path. Does not accept service_tier (the router owns the tier). start_within is required at runtime but left optional here.
+         */
+        InteractionCreateParams: {
+            model: string;
+            /** @description A prompt string, a content-part array (one turn), or a step list (multi-turn). */
+            input?: string | components["schemas"]["InteractionContentPart"][] | components["schemas"]["InteractionStep"][];
+            /** @description System instruction as a string or a content-part array. */
+            system_instruction?: string | components["schemas"]["InteractionContentPart"][];
+            tools?: components["schemas"]["InteractionTool"][];
+            /** @description Inline JSON schema, mapped to canonical text.format.json_schema. */
+            response_format?: {
+                [key: string]: unknown;
+            };
+            generation_config?: components["schemas"]["InteractionGenerationConfig"];
+            previous_interaction_id?: string;
+            stream?: boolean;
+            background?: boolean;
+            store?: boolean;
+            /** @description FlexInference deadline control (see the Responses/Chat ops). Required on every request; enforced by the router at runtime, not by this schema. */
+            start_within?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /** Interaction Usage */
+        InteractionUsage: {
+            total_input_tokens?: number;
+            total_output_tokens?: number;
+            total_thought_tokens?: number;
+            total_cached_tokens?: number;
+            total_tokens?: number;
+            total_tool_use_tokens?: number;
+        };
+        /**
+         * Interaction Text Annotation
+         * @description An opaque annotation on emitted text (e.g. a web-search citation).
+         */
+        InteractionTextAnnotation: {
+            [key: string]: unknown;
+        };
+        /** Interaction Response Text Content */
+        InteractionResponseTextContent: {
+            /** @constant */
+            type: "text";
+            text: string;
+            annotations?: components["schemas"]["InteractionTextAnnotation"][];
+        };
+        /** Interaction Model Output Response Step */
+        InteractionModelOutputResponseStep: {
+            /** @constant */
+            type: "model_output";
+            content: components["schemas"]["InteractionResponseTextContent"][];
+        };
+        /** Interaction Function Call Response Step */
+        InteractionFunctionCallResponseStep: {
+            /** @constant */
+            type: "function_call";
+            id?: string;
+            name: string;
+            arguments: {
+                [key: string]: unknown;
+            };
+        };
+        /** Interaction Google Search Call Step */
+        InteractionGoogleSearchCallStep: {
+            /** @constant */
+            type: "google_search_call";
+            id: string;
+        };
+        /** Interaction Response Step */
+        InteractionResponseStep: components["schemas"]["InteractionModelOutputResponseStep"] | components["schemas"]["InteractionFunctionCallResponseStep"] | components["schemas"]["InteractionGoogleSearchCallStep"];
+        /**
+         * Interaction Object
+         * @description Non-stream response from POST /v1/interactions.
+         */
+        InteractionObject: {
+            id: string;
+            /** @constant */
+            object: "interaction";
+            /** @enum {string} */
+            status: "completed" | "requires_action" | "incomplete" | "failed";
+            model: string;
+            created?: number;
+            updated?: number;
+            service_tier?: string;
+            usage?: components["schemas"]["InteractionUsage"];
+            steps: components["schemas"]["InteractionResponseStep"][];
+        };
+        /**
+         * Interaction Stream Snapshot
+         * @description Interaction state carried by created and completed stream events.
+         */
+        InteractionStreamSnapshot: {
+            id: string;
+            status: string;
+            /** @constant */
+            object: "interaction";
+            model: string;
+            usage?: components["schemas"]["InteractionUsage"];
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * Interaction Stream Step
+         * @description The step descriptor on a step.start event.
+         */
+        InteractionStreamStep: {
+            /** @enum {string} */
+            type: "model_output" | "function_call" | "google_search_call";
+            id?: string;
+            name?: string;
+        };
+        /**
+         * Interaction Stream Delta
+         * @description The incremental payload on a step.delta event.
+         */
+        InteractionStreamDelta: {
+            /** @enum {string} */
+            type?: "text" | "arguments_delta";
+            text?: string;
+            arguments?: string;
+            annotations?: components["schemas"]["InteractionTextAnnotation"][];
+        };
+        /** Interaction Created Event */
+        InteractionCreatedEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            event_type: "interaction.created";
+            interaction: components["schemas"]["InteractionStreamSnapshot"];
+        };
+        /** Interaction Status Update Event */
+        InteractionStatusUpdateEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            event_type: "interaction.status_update";
+            interaction_id: string;
+            status: string;
+        };
+        /** Interaction Completed Event */
+        InteractionCompletedEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            event_type: "interaction.completed";
+            interaction: components["schemas"]["InteractionStreamSnapshot"];
+        };
+        /** Interaction Step Start Event */
+        InteractionStepStartEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            event_type: "step.start";
+            index: number;
+            step: components["schemas"]["InteractionStreamStep"];
+        };
+        /** Interaction Step Delta Event */
+        InteractionStepDeltaEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            event_type: "step.delta";
+            index: number;
+            delta: components["schemas"]["InteractionStreamDelta"];
+        };
+        /** Interaction Step Stop Event */
+        InteractionStepStopEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            event_type: "step.stop";
+            index: number;
+        };
+        /** Interaction Error Event */
+        InteractionErrorEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            event_type: "error";
+            /** @description Error payload (mirrors the FlexError error object). */
+            error: {
+                [key: string]: unknown;
+            };
+        };
+        /**
+         * Interaction Stream Event
+         * @description One server-sent event frame on the Interactions stream.
+         */
+        InteractionStreamEvent: components["schemas"]["InteractionCreatedEvent"] | components["schemas"]["InteractionStatusUpdateEvent"] | components["schemas"]["InteractionCompletedEvent"] | components["schemas"]["InteractionStepStartEvent"] | components["schemas"]["InteractionStepDeltaEvent"] | components["schemas"]["InteractionStepStopEvent"] | components["schemas"]["InteractionErrorEvent"];
+        /** Message Text Block */
+        MessageTextBlock: {
+            /** @constant */
+            type: "text";
+            text: string;
+        };
+        /**
+         * Message Image Source
+         * @description An image source, either base64-encoded bytes or a URL.
+         */
+        MessageImageSource: {
+            /** @enum {string} */
+            type: "base64" | "url";
+            media_type?: string;
+            /** @description Base64-encoded image bytes (type base64). */
+            data?: string;
+            /** @description Image URL (type url). */
+            url?: string;
+        };
+        /** Message Image Block */
+        MessageImageBlock: {
+            /** @constant */
+            type: "image";
+            source: components["schemas"]["MessageImageSource"];
+        };
+        /** Message Thinking Block */
+        MessageThinkingBlock: {
+            /** @constant */
+            type: "thinking";
+            thinking: string;
+            signature?: string;
+        };
+        /** Message Tool Use Block */
+        MessageToolUseBlock: {
+            /** @constant */
+            type: "tool_use";
+            id: string;
+            name: string;
+            /** @description Parsed tool input object (not a JSON string). */
+            input: {
+                [key: string]: unknown;
+            };
+        };
+        /**
+         * Message Tool Result Content Block
+         * @description A single content block inside a tool_result (text or image).
+         */
+        MessageToolResultContentBlock: components["schemas"]["MessageTextBlock"] | components["schemas"]["MessageImageBlock"];
+        /** Message Tool Result Block */
+        MessageToolResultBlock: {
+            /** @constant */
+            type: "tool_result";
+            tool_use_id: string;
+            /** @description Tool result payload; a string or an array of content blocks. */
+            content?: string | components["schemas"]["MessageToolResultContentBlock"][];
+        };
+        /**
+         * Message Content Block
+         * @description A single piece of multimodal content in a Messages request.
+         */
+        MessageContentBlock: components["schemas"]["MessageTextBlock"] | components["schemas"]["MessageImageBlock"] | components["schemas"]["MessageThinkingBlock"] | components["schemas"]["MessageToolUseBlock"] | components["schemas"]["MessageToolResultBlock"];
+        /**
+         * Message
+         * @description One turn in a Messages conversation.
+         */
+        Message: {
+            /** @enum {string} */
+            role: "user" | "assistant";
+            /** @description The turn content as a string or an array of content blocks. */
+            content: string | components["schemas"]["MessageContentBlock"][];
+        };
+        /** Message Tool */
+        MessageTool: {
+            name: string;
+            description?: string;
+            /** @description JSON Schema for the tool input. */
+            input_schema: {
+                [key: string]: unknown;
+            };
+        };
+        /** Message Tool Choice */
+        MessageToolChoice: {
+            /** @enum {string} */
+            type: "auto" | "any" | "tool";
+            /** @description Required when type is tool. */
+            name?: string;
+        };
+        /**
+         * Message Thinking Config
+         * @description Extended thinking controls. "adaptive" lets the model choose the budget; "enabled" requires budget_tokens. display "summarized" surfaces reasoning text.
+         */
+        MessageThinkingConfig: {
+            /** @enum {string} */
+            type: "adaptive" | "enabled";
+            /** @description Required when type is enabled; must be >= 1024 and less than max_tokens. */
+            budget_tokens?: number;
+            display?: string;
+        };
+        /**
+         * Message Create Params
+         * @description Request body for POST /v1/messages (Anthropic Messages shape). Works for any model via the canonical Responses path. max_tokens is required (Anthropic requires it and the router rejects a claude-* request that reaches the Anthropic upstream without a canonical max_output_tokens). Does not accept service_tier (the router owns the tier). start_within is required at runtime but left optional here.
+         */
+        MessageCreateParams: {
+            model: string;
+            max_tokens: number;
+            /** @description System prompt as a string or an array of text blocks. */
+            system?: string | components["schemas"]["MessageTextBlock"][];
+            messages: components["schemas"]["Message"][];
+            temperature?: number;
+            top_p?: number;
+            tools?: components["schemas"]["MessageTool"][];
+            tool_choice?: components["schemas"]["MessageToolChoice"];
+            thinking?: components["schemas"]["MessageThinkingConfig"];
+            stream?: boolean;
+            /** @description FlexInference deadline control (see the Responses/Chat ops). Required on every request; enforced by the router at runtime, not by this schema. */
+            start_within?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /** Message Cache Creation */
+        MessageCacheCreation: {
+            ephemeral_5m_input_tokens?: number;
+            ephemeral_1h_input_tokens?: number;
+        };
+        /** Message Usage Output Tokens Details */
+        MessageUsageOutputTokensDetails: {
+            thinking_tokens?: number;
+        };
+        /**
+         * Message Usage
+         * @description Anthropic usage. input_tokens EXCLUDES cache; output_tokens INCLUDES thinking. The router folds cache_read/cache_creation into canonical input and keeps output_tokens verbatim. service_tier here is authoritative for the served tier.
+         */
+        MessageUsage: {
+            input_tokens?: number;
+            cache_creation_input_tokens?: number | null;
+            cache_read_input_tokens?: number | null;
+            cache_creation?: components["schemas"]["MessageCacheCreation"];
+            output_tokens?: number;
+            output_tokens_details?: components["schemas"]["MessageUsageOutputTokensDetails"];
+            service_tier?: string;
+            inference_geo?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * Message Response Content Block
+         * @description A content block on a Messages response (text, thinking, or tool_use).
+         */
+        MessageResponseContentBlock: components["schemas"]["MessageTextBlock"] | components["schemas"]["MessageThinkingBlock"] | components["schemas"]["MessageToolUseBlock"];
+        /**
+         * Message Object
+         * @description Non-stream response from POST /v1/messages (Anthropic Messages shape).
+         */
+        MessageObject: {
+            id: string;
+            /** @constant */
+            type: "message";
+            /** @constant */
+            role: "assistant";
+            model: string;
+            content: components["schemas"]["MessageResponseContentBlock"][];
+            /** @enum {string|null} */
+            stop_reason?: "end_turn" | "max_tokens" | "tool_use" | "stop_sequence" | "refusal" | null;
+            stop_sequence?: string | null;
+            /** @description The served tier, authoritative from usage.service_tier. Anthropic serves "standard" even when sent "standard_only". */
+            service_tier?: string;
+            usage?: components["schemas"]["MessageUsage"];
+        };
+        /**
+         * Message Stream Content Block
+         * @description The content block descriptor on a content_block_start event.
+         */
+        MessageStreamContentBlock: {
+            type: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /**
+         * Message Stream Delta
+         * @description The incremental payload on a content_block_delta event.
+         */
+        MessageStreamDelta: {
+            /** @enum {string} */
+            type: "text_delta" | "thinking_delta" | "input_json_delta" | "signature_delta";
+            text?: string;
+            thinking?: string;
+            partial_json?: string;
+            signature?: string;
+        };
+        /**
+         * Message Delta Stop Info
+         * @description The stop info carried by a message_delta event.
+         */
+        MessageDeltaStopInfo: {
+            stop_reason?: string | null;
+            stop_sequence?: string | null;
+        };
+        /** Message Start Event */
+        MessageStartEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "message_start";
+            message: components["schemas"]["MessageObject"];
+        };
+        /** Message Content Block Start Event */
+        MessageContentBlockStartEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "content_block_start";
+            index: number;
+            content_block: components["schemas"]["MessageStreamContentBlock"];
+        };
+        /** Message Content Block Delta Event */
+        MessageContentBlockDeltaEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "content_block_delta";
+            index: number;
+            delta: components["schemas"]["MessageStreamDelta"];
+        };
+        /** Message Content Block Stop Event */
+        MessageContentBlockStopEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "content_block_stop";
+            index: number;
+        };
+        /** Message Delta Event */
+        MessageDeltaEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "message_delta";
+            delta: components["schemas"]["MessageDeltaStopInfo"];
+            usage?: components["schemas"]["MessageUsage"];
+        };
+        /** Message Stop Event */
+        MessageStopEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "message_stop";
+        };
+        /** Message Ping Event */
+        MessagePingEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "ping";
+        };
+        /**
+         * Message Error Event
+         * @description Terminal error frame emitted when the upstream stream fails.
+         */
+        MessageErrorEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "error";
+            error: {
+                type?: string;
+                message?: string;
+            };
+        };
+        /**
+         * Message Stream Event
+         * @description One server-sent event frame on the Messages stream.
+         */
+        MessageStreamEvent: components["schemas"]["MessageStartEvent"] | components["schemas"]["MessageContentBlockStartEvent"] | components["schemas"]["MessageContentBlockDeltaEvent"] | components["schemas"]["MessageContentBlockStopEvent"] | components["schemas"]["MessageDeltaEvent"] | components["schemas"]["MessageStopEvent"] | components["schemas"]["MessagePingEvent"] | components["schemas"]["MessageErrorEvent"];
     };
     responses: never;
     parameters: never;
@@ -5398,7 +6005,7 @@ export interface operations {
                     "text/event-stream": components["schemas"]["CreateChatCompletionStreamResponse"];
                 };
             };
-            /** @description Bad request. A FlexInference-layer rejection (type flexinference_error, e.g. missing_start_within, invalid_start_within, model_not_flex_capable, no_byok_key) or an OpenAI rejection passed through unchanged. */
+            /** @description Bad request. A FlexInference-layer rejection (type flexinference_error, e.g. missing_start_within, invalid_start_within, model_not_flex_capable, no_byok_key, no_gemini_key, auto_unsupported_for_gemini, service_tier_not_allowed) or an OpenAI/Gemini rejection passed through unchanged. */
             400: {
                 headers: {
                     [name: string]: unknown;
@@ -5441,7 +6048,93 @@ export interface operations {
                     "text/event-stream": components["schemas"]["ResponseStreamEvent"];
                 };
             };
-            /** @description Bad request. A FlexInference-layer rejection (type flexinference_error, e.g. missing_start_within, invalid_start_within, model_not_flex_capable, no_byok_key) or an OpenAI rejection passed through unchanged. */
+            /** @description Bad request. A FlexInference-layer rejection (type flexinference_error, e.g. missing_start_within, invalid_start_within, model_not_flex_capable, no_byok_key, no_gemini_key, auto_unsupported_for_gemini, service_tier_not_allowed) or an OpenAI/Gemini rejection passed through unchanged. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FlexError"];
+                };
+            };
+            /** @description Invalid or missing FlexInference API key (type flexinference_error, code invalid_api_key). */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FlexError"];
+                };
+            };
+        };
+    };
+    createInteraction: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["InteractionCreateParams"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["InteractionObject"];
+                    "text/event-stream": components["schemas"]["InteractionStreamEvent"];
+                };
+            };
+            /** @description Bad request. A FlexInference-layer rejection (type flexinference_error, e.g. missing_start_within, invalid_start_within, model_not_flex_capable, auto_unsupported_for_gemini, service_tier_not_allowed) or an OpenAI/Gemini rejection passed through unchanged. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FlexError"];
+                };
+            };
+            /** @description Invalid or missing FlexInference API key (type flexinference_error, code invalid_api_key). */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FlexError"];
+                };
+            };
+        };
+    };
+    createMessage: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["MessageCreateParams"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["MessageObject"];
+                    "text/event-stream": components["schemas"]["MessageStreamEvent"];
+                };
+            };
+            /** @description Bad request. A FlexInference-layer rejection (type flexinference_error, e.g. missing_start_within, invalid_start_within, model_not_flex_capable, flex_unsupported_for_anthropic, missing_max_tokens, service_tier_not_allowed) or an upstream provider rejection passed through unchanged. */
             400: {
                 headers: {
                     [name: string]: unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flexinference",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "Official TypeScript SDK for FlexInference - a deadline-aware, OpenAI-compatible inference router.",
   "license": "MIT",
   "author": "Aditya Perswal <adityaperswal@gmail.com>",