flexinference 1.1.0 → 1.3.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 1.3.0
+
+Adds a typed **`PaymentRequiredError`** (a subclass of `FlexInferenceError`) thrown on
+HTTP `402`, which the router returns when billing is past due and billable flex is paused
+(free routing still works). Catch it on its own to prompt the user to update payment;
+existing `catch (err instanceof FlexInferenceError)` handlers keep catching 402s because
+it is a subclass. No other API or type changes.
+
+## 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

package/README.md

@@ -1,6 +1,6 @@
 # FlexInference (TypeScript)
 
-The official TypeScript SDK for [FlexInference](https://flexinference.com) - a deadline-aware, OpenAI-compatible inference router. Send the OpenAI requests you already send, bring your own OpenAI key, and set one required field - `start_within` - to trade latency for cost.
+The official TypeScript SDK for [FlexInference](https://flexinference.com) - a deadline-aware inference router across **OpenAI, Google Gemini, and Anthropic**. Send the OpenAI requests you already send, bring your own provider key, and set one required field - `start_within` - to trade latency for cost. Four caller formats are supported: `responses`, `chat.completions`, `interactions` (Gemini shape), and `messages` (Anthropic shape) - any of them reaches any provider.
 
 ```bash
 npm install flexinference
@@ -26,14 +26,15 @@ Responses come back as the **raw OpenAI JSON** (we never reshape the body), so t
 
 `start_within` is **required** on every request. It takes `"default"`, `"priority"`, `"auto"`, or a duration `"HHh-MMm-SSs"` (5s-10m). The duration races OpenAI's flex tier on a flex-capable model and falls back to standard if it can't start in time; `"default"`, `"priority"`, and `"auto"` map to those OpenAI service tiers and proxy any model. It is typed, so a missing value or a value outside the allowed shapes is a **compile-time** error; a duration that fits the shape but is malformed or out of range is caught at **runtime**, the same check plain-JavaScript callers get. See the [docs](https://flexinference.mintlify.app/deadline-routing).
 
-## Providers (OpenAI and Gemini)
+## Providers (OpenAI, Gemini, and Anthropic)
 
-FlexInference routes to **OpenAI** and **Google Gemini**. Send the same OpenAI-shaped request and pass whichever model id you want - `gpt-5.5`, `o4-mini`, `gemini-3.5-flash`, and so on. We run Gemini through its Interactions API and translate it back to the OpenAI shape, so your code is identical for both.
+FlexInference routes to **OpenAI**, **Google Gemini**, and **Anthropic**. Send the same OpenAI-shaped request and pass whichever model id you want - `gpt-5.5`, `o4-mini`, `gemini-3.5-flash`, `claude-opus-4-8`, and so on. We translate Gemini and Anthropic to and from the OpenAI shape, so your code is identical for all three.
 
 - **OpenAI:** `default` (standard tier), `priority`, `auto`, and the flex race (a duration) on flex-capable models.
 - **Gemini:** `default` maps to Gemini's **standard** tier, plus `priority` and the flex race on the Gemini flex models (`gemini-3.5-flash`, `gemini-3.1-flash-lite`, `gemini-3.1-pro-preview`, `gemini-3-flash-preview`, `gemini-2.5-pro`, `gemini-2.5-flash`, `gemini-2.5-flash-lite`). Gemini has no `auto` tier, so `start_within: "auto"` on a Gemini model returns `400`.
+- **Anthropic (Claude):** proxy-only. `default`, `priority`, and `auto` work; there is **no flex race**, so a duration `start_within` on a `claude-*` model returns `400 flex_unsupported_for_anthropic`. Anthropic requires a token cap, so set `max_output_tokens` (`max_completion_tokens` on Chat, `max_tokens` on Messages) or you get `400 missing_max_tokens`. You keep the unified API and tier control, and draw down your own Anthropic credits.
 
-Add the provider key you'll use (OpenAI and/or Gemini) in the [dashboard](https://www.flexinference.com/dashboard). Text, streaming, structured outputs, function calling, image input, and web search work on both providers (send a Responses `web_search` tool; we map it to Gemini's `google_search`).
+Add the provider key you'll use (OpenAI, Gemini, and/or Anthropic) in the [dashboard](https://www.flexinference.com/dashboard). Text, streaming, structured outputs, function calling, image input, and web search work across providers (send a Responses `web_search` tool; we map it to Gemini's `google_search`).
 
 Don't send `service_tier` - the router controls the tier from `start_within` and rejects a caller-supplied `service_tier` with `400 service_tier_not_allowed`.
 
@@ -64,6 +65,39 @@ const res = await client.chat.completions.create({
 });
 ```
 
+## Interactions (Gemini shape)
+
+Speak Google's Interactions shape and reach any model. `interactionText(res)` pulls the assistant text out of the interaction's `steps`.
+
+```ts
+import { interactionText } from "flexinference";
+
+const res = await client.interactions.create({
+  model: "gemini-3.5-flash",
+  input: "Summarize this contract.",
+  start_within: "00h-01m-00s",
+});
+
+console.log(interactionText(res));
+```
+
+## Messages (Anthropic shape)
+
+Speak Anthropic's Messages shape and reach any model. `max_tokens` is required (Anthropic requires it). `messageText(res)` pulls the assistant text out of the message `content`.
+
+```ts
+import { messageText } from "flexinference";
+
+const res = await client.messages.create({
+  model: "claude-opus-4-8",
+  max_tokens: 1024,
+  messages: [{ role: "user", content: "Summarize this contract." }],
+  start_within: "default",
+});
+
+console.log(messageText(res));
+```
+
 ## Timeouts and cancellation
 
 Every client has a built-in timeout: **10 seconds to connect** and **600 seconds (10 min) total**, matching the router's budget, so a request can never hang forever. Override the total with the `timeout` option (raise it for very long streams):
@@ -102,6 +136,31 @@ try {
 }
 ```
 
+## Billing / 402
+
+If your account's billing is past due, the router pauses **billable flex** and returns
+`402 Payment Required` on those requests; free routing keeps working. The SDK throws a
+typed `PaymentRequiredError` (a subclass of `FlexInferenceError`) for HTTP 402, so you
+can catch it on its own and prompt the user to update payment while letting other errors
+propagate:
+
+```ts
+import { PaymentRequiredError } from "flexinference";
+
+try {
+  await client.responses.create({ model: "gpt-5.5", input: "hi", start_within: "00h-00m-30s" });
+} catch (err) {
+  if (err instanceof PaymentRequiredError) {
+    console.log("Billing is past due - update payment in the dashboard to resume flex.");
+  } else {
+    throw err;
+  }
+}
+```
+
+Because `PaymentRequiredError extends FlexInferenceError`, existing
+`catch (err instanceof FlexInferenceError)` handlers keep catching 402s too.
+
 ## Configuration
 
 | Option    | Default                            | Description                                      |

package/dist/index.d.ts

@@ -22,6 +22,11 @@ export type InteractionCreateParams = WithStartWithin<Schemas["InteractionCreate
 };
 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
@@ -40,6 +45,15 @@ export declare function outputText(response: ResponseObject | ChatCompletion): s
  * 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;
@@ -55,6 +69,13 @@ export declare class FlexInferenceError extends Error {
     readonly param: string | null | undefined;
     constructor(status: number, body: Partial<FlexErrorBody> | undefined, fallback: string);
 }
+/**
+ * Thrown on HTTP 402: billing is past due, so billable flex is paused. Free routing
+ * still works. A subclass of FlexInferenceError, so existing `catch (err instanceof
+ * FlexInferenceError)` handlers keep working; narrow to this to handle 402 specially.
+ */
+export declare class PaymentRequiredError extends FlexInferenceError {
+}
 export interface ClientOptions {
     apiKey: string;
     /** Base URL of the FlexInference router. Defaults to the hosted endpoint. */
@@ -79,6 +100,7 @@ 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;
@@ -120,4 +142,14 @@ declare class Interactions {
         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

@@ -62,6 +62,29 @@ export function interactionText(interaction) {
     }
     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;
@@ -77,6 +100,13 @@ export class FlexInferenceError extends Error {
         this.param = err?.param;
     }
 }
+/**
+ * Thrown on HTTP 402: billing is past due, so billable flex is paused. Free routing
+ * still works. A subclass of FlexInferenceError, so existing `catch (err instanceof
+ * FlexInferenceError)` handlers keep working; narrow to this to handle 402 specially.
+ */
+export class PaymentRequiredError extends FlexInferenceError {
+}
 const DEFAULT_BASE_URL = "https://api.flexinference.com/v1";
 const DEFAULT_TIMEOUT_MS = 600_000; // 10 min total budget, matching the router's generosity
 const CONNECT_TIMEOUT_MS = 10_000; // fail fast if the router is unreachable
@@ -114,6 +144,7 @@ export class FlexInference {
     responses;
     chat;
     interactions;
+    messages;
     apiKey;
     baseURL;
     fetchImpl;
@@ -133,6 +164,7 @@ export class FlexInference {
         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
@@ -193,6 +225,9 @@ export class FlexInference {
             finally {
                 cleanup();
             }
+            if (res.status === 402) {
+                throw new PaymentRequiredError(res.status, parsed, `HTTP ${String(res.status)} ${res.statusText}`);
+            }
             throw new FlexInferenceError(res.status, parsed, `HTTP ${String(res.status)} ${res.statusText}`);
         }
         return { res, cleanup };
@@ -261,6 +296,25 @@ class Interactions {
         }
     }
 }
+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

@@ -81,6 +81,23 @@ export interface paths {
         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 {
@@ -5675,6 +5692,287 @@ export interface components {
          * @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;
@@ -5813,4 +6111,47 @@ export interface operations {
             };
         };
     };
+    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;
+                };
+                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"];
+                };
+            };
+        };
+    };
 }

package/package.json

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