flexinference 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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

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;
@@ -79,6 +93,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 +135,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;
@@ -114,6 +137,7 @@ export class FlexInference {
     responses;
     chat;
     interactions;
+    messages;
     apiKey;
     baseURL;
     fetchImpl;
@@ -133,6 +157,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
@@ -261,6 +286,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.2.0",
   "description": "Official TypeScript SDK for FlexInference - a deadline-aware, OpenAI-compatible inference router.",
   "license": "MIT",
   "author": "Aditya Perswal <adityaperswal@gmail.com>",