flexinference 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aditya Perswal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# 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 add one field - `start_within` - to trade latency for cost.
+
+```bash
+npm install flexinference
+```
+
+## Quickstart
+
+```ts
+import { FlexInference } from "flexinference";
+
+const client = new FlexInference({ apiKey: "flex_live_..." });
+
+const res = await client.responses.create({
+  model: "gpt-5.5",
+  input: "Write a haiku about cheap GPUs.",
+  start_within: "00h-00m-30s", // typed - no cast needed
+});
+
+console.log(res.output_text);
+```
+
+`start_within` takes `"priority"`, `"standard"`, or a duration `"HHh-MMm-SSs"` (5s-10m) that races OpenAI's flex tier and falls back to standard if it can't start in time. See the [docs](https://flexinference.com/docs/deadline-routing).
+
+## Streaming
+
+```ts
+const stream = await client.responses.create({
+  model: "gpt-5-nano",
+  input: "Count to ten.",
+  stream: true,
+  start_within: "00h-00m-20s",
+});
+
+for await (const event of stream) {
+  if (event.type === "response.output_text.delta") process.stdout.write(event.delta);
+}
+```
+
+## Chat Completions
+
+The Chat Completions endpoint works identically:
+
+```ts
+const res = await client.chat.completions.create({
+  model: "gpt-5.5",
+  messages: [{ role: "user", content: "Hello!" }],
+  start_within: "standard",
+});
+```
+
+## Cancellation
+
+Every call accepts an `AbortSignal` as a second argument, so you can cancel a request (or wire up your own timeout). Cancelling a stream stops it mid-flight:
+
+```ts
+const controller = new AbortController();
+const timeout = setTimeout(() => controller.abort(), 5_000);
+
+try {
+  const res = await client.responses.create(
+    { model: "gpt-5.5", input: "Write a haiku about cheap GPUs.", start_within: "priority" },
+    { signal: controller.signal },
+  );
+  console.log(res.output_text);
+} finally {
+  clearTimeout(timeout);
+}
+```
+
+## Errors
+
+Non-2xx responses throw `FlexInferenceError`, carrying the OpenAI-shaped `status`, `type`, `code`, and `param`:
+
+```ts
+import { FlexInferenceError } from "flexinference";
+
+try {
+  await client.responses.create({ model: "gpt-5.5", input: "hi", start_within: "priority" });
+} catch (err) {
+  if (err instanceof FlexInferenceError && err.code === "no_byok_key") {
+    console.log("Add your OpenAI key in the dashboard.");
+  } else {
+    throw err;
+  }
+}
+```
+
+## Configuration
+
+| Option    | Default                            | Description                            |
+| --------- | ---------------------------------- | -------------------------------------- |
+| `apiKey`  | -                                  | Your `flex_live_` key (required).      |
+| `baseURL` | `https://api.flexinference.com/v1` | Override the router endpoint.          |
+| `fetch`   | global `fetch`                     | Provide a custom fetch implementation. |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import type { components } from "./types.js";
+type Schemas = components["schemas"];
+export type ResponseCreateParams = Schemas["CreateResponse"];
+export type ResponseObject = Schemas["Response"];
+export type ResponseStreamEvent = Schemas["ResponseStreamEvent"];
+export type ChatCompletionCreateParams = Schemas["CreateChatCompletionRequest"];
+export type ChatCompletion = Schemas["CreateChatCompletionResponse"];
+export type ChatCompletionChunk = Schemas["CreateChatCompletionStreamResponse"];
+export interface FlexErrorBody {
+    error: {
+        message: string;
+        type: string;
+        code?: string | null;
+        param?: string | null;
+    };
+}
+export declare class FlexInferenceError extends Error {
+    readonly status: number;
+    readonly type: string | undefined;
+    readonly code: string | null | undefined;
+    readonly param: string | null | undefined;
+    constructor(status: number, body: Partial<FlexErrorBody> | undefined, fallback: string);
+}
+export interface ClientOptions {
+    apiKey: string;
+    /** Base URL of the FlexInference router. Defaults to the hosted endpoint. */
+    baseURL?: string;
+    /** Override the global fetch (e.g. for tests or non-standard runtimes). */
+    fetch?: typeof fetch;
+}
+export interface RequestOptions {
+    signal?: AbortSignal;
+}
+type Post = (path: string, body: unknown, signal: AbortSignal | undefined) => Promise<Response>;
+export declare class FlexInference {
+    readonly responses: Responses;
+    readonly chat: Chat;
+    private readonly apiKey;
+    private readonly baseURL;
+    private readonly fetchImpl;
+    constructor(options: ClientOptions);
+    private post;
+}
+declare class Responses {
+    private readonly post;
+    constructor(post: Post);
+    create(body: ResponseCreateParams & {
+        stream?: false | null;
+    }, options?: RequestOptions): Promise<ResponseObject>;
+    create(body: ResponseCreateParams & {
+        stream: true;
+    }, options?: RequestOptions): Promise<AsyncIterable<ResponseStreamEvent>>;
+}
+declare class Chat {
+    readonly completions: ChatCompletions;
+    constructor(post: Post);
+}
+declare class ChatCompletions {
+    private readonly post;
+    constructor(post: Post);
+    create(body: ChatCompletionCreateParams & {
+        stream?: false | null;
+    }, options?: RequestOptions): Promise<ChatCompletion>;
+    create(body: ChatCompletionCreateParams & {
+        stream: true;
+    }, options?: RequestOptions): Promise<AsyncIterable<ChatCompletionChunk>>;
+}
+export {};

package/dist/index.js

@@ -0,0 +1,126 @@
+export class FlexInferenceError extends Error {
+    status;
+    type;
+    code;
+    param;
+    constructor(status, body, fallback) {
+        const err = body?.error;
+        super(err?.message ?? fallback);
+        this.name = "FlexInferenceError";
+        this.status = status;
+        this.type = err?.type;
+        this.code = err?.code;
+        this.param = err?.param;
+    }
+}
+const DEFAULT_BASE_URL = "https://api.flexinference.com/v1";
+export class FlexInference {
+    responses;
+    chat;
+    apiKey;
+    baseURL;
+    fetchImpl;
+    constructor(options) {
+        if (!options.apiKey)
+            throw new Error("FlexInference: `apiKey` is required.");
+        this.apiKey = options.apiKey;
+        this.baseURL = (options.baseURL ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+        const f = options.fetch ?? globalThis.fetch;
+        if (typeof f !== "function") {
+            throw new Error("FlexInference: no global fetch found; pass `fetch` in options.");
+        }
+        this.fetchImpl = f;
+        const post = (path, body, signal) => this.post(path, body, signal);
+        this.responses = new Responses(post);
+        this.chat = new Chat(post);
+    }
+    async post(path, body, signal) {
+        const res = await this.fetchImpl(`${this.baseURL}${path}`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+                Accept: "text/event-stream, application/json",
+            },
+            body: JSON.stringify(body),
+            signal,
+        });
+        if (!res.ok) {
+            let parsed;
+            try {
+                parsed = (await res.json());
+            }
+            catch {
+                parsed = undefined;
+            }
+            throw new FlexInferenceError(res.status, parsed, `HTTP ${String(res.status)} ${res.statusText}`);
+        }
+        return res;
+    }
+}
+class Responses {
+    post;
+    constructor(post) {
+        this.post = post;
+    }
+    async create(body, options) {
+        const res = await this.post("/responses", body, options?.signal);
+        if (body.stream) {
+            return streamSSE(res);
+        }
+        return (await res.json());
+    }
+}
+class Chat {
+    completions;
+    constructor(post) {
+        this.completions = new ChatCompletions(post);
+    }
+}
+class ChatCompletions {
+    post;
+    constructor(post) {
+        this.post = post;
+    }
+    async create(body, options) {
+        const res = await this.post("/chat/completions", body, options?.signal);
+        if (body.stream) {
+            return streamSSE(res);
+        }
+        return (await res.json());
+    }
+}
+async function* streamSSE(res) {
+    if (!res.body)
+        throw new Error("FlexInference: streaming response has no body.");
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true }).replace(/\r/g, "");
+            let sep;
+            while ((sep = buffer.indexOf("\n\n")) !== -1) {
+                const frame = buffer.slice(0, sep);
+                buffer = buffer.slice(sep + 2);
+                const dataLines = [];
+                for (const line of frame.split("\n")) {
+                    if (line.startsWith("data:"))
+                        dataLines.push(line.slice(5).replace(/^ /, ""));
+                }
+                if (dataLines.length === 0)
+                    continue;
+                const data = dataLines.join("\n");
+                if (data === "[DONE]")
+                    return;
+                yield JSON.parse(data);
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}