@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292116.41f7caa

package/src/providers/fireworks/client.test.ts

@@ -0,0 +1,168 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { setConfig } from "../../__tests__/helpers/set-config.js";
+import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+import { RetryProvider } from "../retry.js";
+import type { Message, SendMessageOptions } from "../types.js";
+import {
+  FIREWORKS_SESSION_AFFINITY_HEADER,
+  FireworksProvider,
+  resolveFireworksRequestHeaders,
+} from "./client.js";
+
+const USER_TURN: Message[] = [
+  { role: "user", content: [{ type: "text", text: "question" }] },
+];
+
+interface WireCall {
+  params: Record<string, unknown>;
+  headers: Record<string, string> | undefined;
+}
+
+/** Replace the SDK client so each chat-completions call is recorded. */
+function stubChatCompletions(provider: OpenAIChatCompletionsProvider) {
+  const calls: WireCall[] = [];
+  (provider as unknown as { client: unknown }).client = {
+    baseURL: "https://api.fireworks.example/inference/v1",
+    chat: {
+      completions: {
+        create: async (
+          params: Record<string, unknown>,
+          options?: { headers?: Record<string, string> },
+        ) => {
+          calls.push({ params, headers: options?.headers });
+          return {
+            async *[Symbol.asyncIterator]() {
+              yield {
+                choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+                usage: { prompt_tokens: 2, completion_tokens: 1 },
+              };
+            },
+          };
+        },
+      },
+    },
+  };
+  return calls;
+}
+
+function fireworksPipeline() {
+  const inner = new FireworksProvider(
+    "fw-test",
+    "accounts/fireworks/models/example-model",
+  );
+  const calls = stubChatCompletions(inner);
+  return { provider: new RetryProvider(inner), calls };
+}
+
+async function send(
+  provider: RetryProvider,
+  config: SendMessageOptions["config"],
+): Promise<void> {
+  await provider.sendMessage(USER_TURN, { config });
+}
+
+beforeEach(() => {
+  setConfig("llm", {});
+});
+
+describe("resolveFireworksRequestHeaders", () => {
+  test("sets the session affinity header from the key", () => {
+    expect(resolveFireworksRequestHeaders("conv-xyz")).toEqual({
+      [FIREWORKS_SESSION_AFFINITY_HEADER]: "conv-xyz",
+    });
+  });
+
+  test("omits the header without a usable key", () => {
+    expect(resolveFireworksRequestHeaders(undefined)).toEqual({});
+    expect(resolveFireworksRequestHeaders("   ")).toEqual({});
+  });
+});
+
+describe("Fireworks session affinity on the wire", () => {
+  test("sends the selectionSeed as x-session-affinity and keeps it out of the body", async () => {
+    const { provider, calls } = fireworksPipeline();
+
+    await send(provider, {
+      selectionSeed: "conv-seed",
+      conversationId: "conv-other",
+    });
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0]!.headers?.[FIREWORKS_SESSION_AFFINITY_HEADER]).toBe(
+      "conv-seed",
+    );
+    const body = JSON.stringify(calls[0]!.params);
+    expect(body).not.toContain(FIREWORKS_SESSION_AFFINITY_HEADER);
+    expect(body).not.toContain("conv-seed");
+    expect(body).not.toContain("conv-other");
+    expect(calls[0]!.params).not.toHaveProperty("requestHeaders");
+    expect(calls[0]!.params).not.toHaveProperty("user");
+  });
+
+  test("falls back to conversationId when there is no selectionSeed", async () => {
+    const { provider, calls } = fireworksPipeline();
+
+    await send(provider, { conversationId: "conv-xyz" });
+
+    expect(calls[0]!.headers?.[FIREWORKS_SESSION_AFFINITY_HEADER]).toBe(
+      "conv-xyz",
+    );
+    expect(JSON.stringify(calls[0]!.params)).not.toContain("conv-xyz");
+  });
+
+  test("uses the same key on every call of a conversation", async () => {
+    const { provider, calls } = fireworksPipeline();
+
+    await send(provider, { selectionSeed: "conv-xyz" });
+    await send(provider, { selectionSeed: "conv-xyz" });
+
+    expect(
+      calls.map((call) => call.headers?.[FIREWORKS_SESSION_AFFINITY_HEADER]),
+    ).toEqual(["conv-xyz", "conv-xyz"]);
+  });
+
+  test("sends no header when the call has no conversation key", async () => {
+    const { provider, calls } = fireworksPipeline();
+
+    await send(provider, {});
+    await send(provider, { selectionSeed: "  ", conversationId: "" });
+
+    for (const call of calls) {
+      expect(call.headers ?? {}).not.toHaveProperty(
+        FIREWORKS_SESSION_AFFINITY_HEADER,
+      );
+    }
+  });
+
+  test("ignores caller-set request headers", async () => {
+    const { provider, calls } = fireworksPipeline();
+
+    await send(provider, {
+      requestHeaders: { [FIREWORKS_SESSION_AFFINITY_HEADER]: "shared-key" },
+    });
+
+    expect(calls[0]!.headers ?? {}).not.toHaveProperty(
+      FIREWORKS_SESSION_AFFINITY_HEADER,
+    );
+  });
+
+  test("does not send the header for other chat-completions providers", async () => {
+    const inner = new OpenAIChatCompletionsProvider("sk-test", "some-model", {
+      providerName: "together",
+      providerLabel: "Together",
+    });
+    const calls = stubChatCompletions(inner);
+    const provider = new RetryProvider(inner);
+
+    await send(provider, {
+      selectionSeed: "conv-xyz",
+      conversationId: "conv-xyz",
+    });
+
+    expect(calls[0]!.headers ?? {}).not.toHaveProperty(
+      FIREWORKS_SESSION_AFFINITY_HEADER,
+    );
+    expect(JSON.stringify(calls[0]!.params)).not.toContain("conv-xyz");
+  });
+});

package/src/providers/fireworks/client.ts

@@ -12,6 +12,30 @@ export interface FireworksProviderOptions {
 
 const DEFAULT_FIREWORKS_BASE_URL = "https://api.fireworks.ai/inference/v1";
 
+/**
+ * Fireworks routing hint. Prompt caching works only within one replica, so
+ * serverless and multi-replica deployments use this header to send requests
+ * that share a key to the same replica.
+ * https://docs.fireworks.ai/guides/prompt-caching#optimizing-inference-request-for-caching
+ */
+export const FIREWORKS_SESSION_AFFINITY_HEADER = "x-session-affinity";
+
+/**
+ * Headers for one outgoing Fireworks request. `sessionKey` is the durable
+ * per-conversation key; without one the header is omitted, because a shared
+ * key would pin all keyless traffic to a single replica. Transport metadata
+ * only; nothing here enters the request body.
+ */
+export function resolveFireworksRequestHeaders(
+  sessionKey: string | undefined,
+): Record<string, string> {
+  const key = sessionKey?.trim();
+  if (!key) {
+    return {};
+  }
+  return { [FIREWORKS_SESSION_AFFINITY_HEADER]: key };
+}
+
 const FIREWORKS_MODEL_EFFORT_CEILINGS = modelEffortCeilings("fireworks");
 const FIREWORKS_MODEL_SUPPORTED_EFFORTS = modelSupportedEfforts("fireworks");
 

package/src/providers/inference/adapter-factory.ts

@@ -35,6 +35,7 @@ import { AtlasCloudProvider } from "../atlascloud/client.js";
 import { BasetenProvider } from "../baseten/client.js";
 import { FireworksProvider } from "../fireworks/client.js";
 import { GeminiProvider } from "../gemini/client.js";
+import { IonetProvider } from "../ionet/client.js";
 import { JevProvider } from "../jev/client.js";
 import { MinimaxProvider } from "../minimax/client.js";
 import { PROVIDER_CATALOG } from "../model-catalog.js";
@@ -206,6 +207,11 @@ const ADAPTER_FACTORIES: Record<string, AdapterFactory> = {
       streamTimeoutMs,
       ...(baseURL ? { baseURL } : {}),
     }),
+  ionet: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
+    new IonetProvider(apiKey, model, {
+      streamTimeoutMs,
+      ...(baseURL ? { baseURL } : {}),
+    }),
   typesafe: ({ apiKey, model, streamTimeoutMs, baseURL }) =>
     new JevProvider(apiKey, model, {
       streamTimeoutMs,

package/src/providers/ionet/client.test.ts

@@ -0,0 +1,143 @@
+/**
+ * Verifies the IO Intelligence (io.net) provider wiring: the SDK client must
+ * resolve to the documented IO Intelligence chat-completions endpoint unless
+ * an explicit override is supplied (custom-connection / test usage).
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { IonetProvider } from "./client.js";
+
+type MockChunk = {
+  choices: Array<{
+    delta: { content?: string | null };
+    finish_reason?: string | null;
+  }>;
+  usage?: { prompt_tokens: number; completion_tokens: number };
+};
+
+const OK_CHUNKS: MockChunk[] = [
+  {
+    choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+    usage: { prompt_tokens: 1, completion_tokens: 1 },
+  },
+];
+
+function makeStream(chunks: MockChunk[]): AsyncIterable<MockChunk> {
+  return {
+    async *[Symbol.asyncIterator]() {
+      for (const c of chunks) {
+        yield c;
+      }
+    },
+  };
+}
+
+function clientOf(provider: IonetProvider) {
+  return (
+    provider as unknown as {
+      client: {
+        baseURL: string;
+        chat: {
+          completions: {
+            create: (params: unknown) => Promise<AsyncIterable<MockChunk>>;
+          };
+        };
+      };
+    }
+  ).client;
+}
+
+describe("IonetProvider", () => {
+  test("defaults the SDK client to the IO Intelligence endpoint", async () => {
+    const provider = new IonetProvider(
+      "test-key",
+      "meta-llama/Llama-3.3-70B-Instruct",
+    );
+
+    const client = clientOf(provider);
+    expect(client.baseURL).toBe("https://api.intelligence.io.solutions/api/v1");
+
+    // The same base URL must be reported on the response, read off the live
+    // client instance rather than a constant.
+    client.chat.completions.create = async () => makeStream(OK_CHUNKS);
+    const response = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "hi" }] },
+    ]);
+    expect(response.resolvedEndpoint).toBe(
+      "https://api.intelligence.io.solutions/api/v1",
+    );
+  });
+
+  test("sends tool_choice auto when tools are offered without an explicit choice", async () => {
+    // io.net defaults an unspecified tool_choice to "none" (not OpenAI's
+    // "auto"), so the provider must send the explicit default or the model
+    // could never invoke an offered tool.
+    const provider = new IonetProvider(
+      "test-key",
+      "meta-llama/Llama-3.3-70B-Instruct",
+    );
+    const client = clientOf(provider);
+
+    let seenParams:
+      | {
+          tools?: unknown;
+          tool_choice?: unknown;
+        }
+      | undefined;
+    client.chat.completions.create = async (params) => {
+      seenParams = params as { tools?: unknown; tool_choice?: unknown };
+      return makeStream(OK_CHUNKS);
+    };
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      {
+        tools: [
+          {
+            name: "get_weather",
+            description: "Get the weather",
+            input_schema: { type: "object", properties: {} },
+          },
+        ],
+      },
+    );
+    expect(Array.isArray(seenParams?.tools)).toBe(true);
+    expect(seenParams?.tool_choice).toBe("auto");
+
+    // An explicit caller choice still wins.
+    let forcedParams: { tool_choice?: unknown } | undefined;
+    client.chat.completions.create = async (params) => {
+      forcedParams = params as { tool_choice?: unknown };
+      return makeStream(OK_CHUNKS);
+    };
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      {
+        tools: [
+          {
+            name: "get_weather",
+            description: "Get the weather",
+            input_schema: { type: "object", properties: {} },
+          },
+        ],
+        config: { tool_choice: { type: "none" } },
+      },
+    );
+    expect(forcedParams?.tool_choice).toBe("none");
+  });
+
+  test("honours an explicit baseURL override", async () => {
+    const provider = new IonetProvider("test-key", "test-model", {
+      baseURL: "https://inference.example.test/v1",
+    });
+
+    const client = clientOf(provider);
+    expect(client.baseURL).toBe("https://inference.example.test/v1");
+
+    client.chat.completions.create = async () => makeStream(OK_CHUNKS);
+    const response = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "hi" }] },
+    ]);
+    expect(response.resolvedEndpoint).toBe("https://inference.example.test/v1");
+  });
+});

package/src/providers/ionet/client.ts

@@ -0,0 +1,37 @@
+import { OpenAIChatCompletionsProvider } from "../openai/chat-completions-provider.js";
+
+export interface IonetProviderOptions {
+  apiKey?: string;
+  baseURL?: string;
+  streamTimeoutMs?: number;
+}
+
+const DEFAULT_IONET_BASE_URL = "https://api.intelligence.io.solutions/api/v1";
+
+/**
+ * IO Intelligence (io.net) serves an OpenAI chat-completions API with
+ * Hugging Face-style `org/name` model ids, so it rides the shared
+ * chat-completions client with its own default base URL.
+ */
+export class IonetProvider extends OpenAIChatCompletionsProvider {
+  constructor(
+    apiKey: string,
+    model: string,
+    options: IonetProviderOptions = {},
+  ) {
+    super(apiKey, model, {
+      baseURL: options.baseURL?.trim() || DEFAULT_IONET_BASE_URL,
+      providerName: "ionet",
+      providerLabel: "IO Intelligence",
+      streamTimeoutMs: options.streamTimeoutMs,
+      // IO Intelligence serves DeepSeek- and GLM-style thinking models whose
+      // reasoning arrives as `reasoning_content`; replay it there so
+      // follow-up requests that include tools stay acceptable upstream.
+      assistantReasoningField: "reasoning_content",
+      // io.net defaults an unspecified `tool_choice` to "none" (unlike
+      // OpenAI's "auto"), so tools offered without an explicit choice must
+      // still send one or the model could never invoke them.
+      defaultToolChoiceAuto: true,
+    });
+  }
+}

package/src/providers/model-catalog.ts

@@ -331,6 +331,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.5,
         },
       },
+      {
+        id: "claude-sonnet-5-5",
+        displayName: "Claude Sonnet 5.5",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 2,
+          outputPer1mTokens: 10,
+          cacheWritePer1mTokens: 2.5,
+          cacheReadPer1mTokens: 0.2,
+        },
+      },
       {
         id: "claude-sonnet-5",
         displayName: "Claude Sonnet 5",
@@ -1062,22 +1080,9 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.3,
         },
       },
-      {
-        id: "accounts/fireworks/models/kimi-k2p6",
-        displayName: "Kimi K2.6",
-        contextWindowTokens: 262144,
-        maxOutputTokens: 32768,
-        supportsThinking: true,
-        supportsCaching: true,
-        supportsVision: true,
-        supportsToolUse: true,
-        maxEffort: "high",
-        pricing: {
-          inputPer1mTokens: 0.95,
-          outputPer1mTokens: 4.0,
-          cacheReadPer1mTokens: 0.16,
-        },
-      },
+      // Kimi K2.6 (accounts/fireworks/models/kimi-k2p6) is intentionally
+      // absent: Fireworks has no serverless deployment for it (the serving
+      // API returns 404). Kimi K3 is its successor.
       {
         id: "accounts/fireworks/models/glm-5p3",
         displayName: "GLM 5.3",
@@ -1117,23 +1122,9 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.029,
         },
       },
-      {
-        id: "accounts/fireworks/models/glm-5p2",
-        displayName: "GLM 5.2",
-        // Fireworks serves GLM 5.2 with a 1,040K input window.
-        contextWindowTokens: 1040000,
-        maxOutputTokens: 131072,
-        supportsThinking: true,
-        supportsCaching: true,
-        supportsVision: false,
-        supportsToolUse: true,
-        maxEffort: "max",
-        pricing: {
-          inputPer1mTokens: 1.4,
-          outputPer1mTokens: 4.4,
-          cacheReadPer1mTokens: 0.26,
-        },
-      },
+      // GLM 5.2 (accounts/fireworks/models/glm-5p2) is intentionally absent:
+      // it is on the Fireworks serverless decommission list. GLM 5.3 is its
+      // successor.
       // Kimi K2.5 (accounts/fireworks/models/kimi-k2p5) is intentionally
       // absent: Fireworks serves it on-demand/dedicated only, so serverless
       // chat/completions calls 404 ("not found, inaccessible, and/or not
@@ -1160,40 +1151,30 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       // intentionally absent: Fireworks has no serverless deployment for
       // it (the model page claims serverless support, but the serving API
       // returns 404).
-      {
-        id: "accounts/fireworks/models/deepseek-v4-pro-0813",
-        displayName: "DeepSeek V4 Pro",
-        contextWindowTokens: 1040000,
-        maxOutputTokens: 131072,
-        supportsThinking: true,
-        supportsCaching: true,
-        supportsVision: false,
-        supportsToolUse: true,
-        maxEffort: "max",
-        pricing: {
-          inputPer1mTokens: 1.32,
-          outputPer1mTokens: 3.96,
-          cacheReadPer1mTokens: 0.044,
-        },
-      },
-      {
-        id: "accounts/fireworks/models/deepseek-v4-flash-0731",
-        displayName: "DeepSeek V4 Flash",
-        contextWindowTokens: 1040000,
+      // DeepSeek V4 Pro (accounts/fireworks/models/deepseek-v4-pro-0813)
+      // and DeepSeek V4 Flash
+      // (accounts/fireworks/models/deepseek-v4-flash-0731) are intentionally
+      // absent: Fireworks has no serverless deployment for them (the
+      // serving API returns 404). DeepSeek V4.1 Flash is the serverless
+      // successor Fireworks names for both.
+      {
+        id: "accounts/fireworks/models/deepseek-v4p1-flash",
+        displayName: "DeepSeek V4.1 Flash",
+        contextWindowTokens: 1048576,
         maxOutputTokens: 131072,
         supportsThinking: true,
         supportsCaching: true,
-        supportsVision: false,
+        supportsVision: true,
         supportsToolUse: true,
         maxEffort: "max",
         pricing: {
-          inputPer1mTokens: 0.14,
-          outputPer1mTokens: 0.28,
-          cacheReadPer1mTokens: 0.028,
+          inputPer1mTokens: 0.3,
+          outputPer1mTokens: 1.2,
+          cacheReadPer1mTokens: 0.006,
         },
       },
     ],
-    defaultModel: "accounts/fireworks/models/deepseek-v4-flash-0731",
+    defaultModel: "accounts/fireworks/models/deepseek-v4p1-flash",
     apiKeyUrl: "https://fireworks.ai/account/api-keys",
     apiKeyPlaceholder: "fw_...",
   },
@@ -1373,6 +1354,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.5,
         },
       },
+      {
+        id: "anthropic/claude-sonnet-5.5",
+        displayName: "Claude Sonnet 5.5",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 2,
+          outputPer1mTokens: 10,
+          cacheWritePer1mTokens: 2.5,
+          cacheReadPer1mTokens: 0.2,
+        },
+      },
       {
         id: "anthropic/claude-sonnet-5",
         displayName: "Claude Sonnet 5",
@@ -1911,32 +1910,6 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         },
       },
       // DeepSeek
-      {
-        id: "deepseek/deepseek-r1-0528",
-        displayName: "DeepSeek R1",
-        contextWindowTokens: 163840,
-        maxOutputTokens: 32000,
-        supportsThinking: true,
-        supportsCaching: true,
-        supportsVision: false,
-        supportsToolUse: true,
-        pricing: {
-          inputPer1mTokens: 0.5,
-          outputPer1mTokens: 2.15,
-          cacheReadPer1mTokens: 0.35,
-        },
-      },
-      {
-        id: "deepseek/deepseek-chat-v3-0324",
-        displayName: "DeepSeek V3",
-        contextWindowTokens: 163840,
-        maxOutputTokens: 32000,
-        supportsThinking: false,
-        supportsCaching: false,
-        supportsVision: false,
-        supportsToolUse: true,
-        pricing: { inputPer1mTokens: 0.25, outputPer1mTokens: 1.0 },
-      },
       {
         id: "deepseek/deepseek-v4-pro",
         displayName: "DeepSeek V4 Pro",
@@ -1971,6 +1944,32 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.028,
         },
       },
+      {
+        id: "deepseek/deepseek-r1-0528",
+        displayName: "DeepSeek R1",
+        contextWindowTokens: 163840,
+        maxOutputTokens: 32000,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 0.5,
+          outputPer1mTokens: 2.15,
+          cacheReadPer1mTokens: 0.35,
+        },
+      },
+      {
+        id: "deepseek/deepseek-chat-v3-0324",
+        displayName: "DeepSeek V3",
+        contextWindowTokens: 163840,
+        maxOutputTokens: 32000,
+        supportsThinking: false,
+        supportsCaching: false,
+        supportsVision: false,
+        supportsToolUse: true,
+        pricing: { inputPer1mTokens: 0.25, outputPer1mTokens: 1.0 },
+      },
       // Qwen
       {
         id: "qwen/qwen3.5-plus-02-15",
@@ -2427,6 +2426,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.5,
         },
       },
+      {
+        id: "anthropic/claude-sonnet-5.5",
+        displayName: "Claude Sonnet 5.5",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 2,
+          outputPer1mTokens: 10,
+          cacheWritePer1mTokens: 2.5,
+          cacheReadPer1mTokens: 0.2,
+        },
+      },
       {
         id: "anthropic/claude-sonnet-5",
         displayName: "Claude Sonnet 5",
@@ -2729,6 +2746,46 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
     apiKeyUrl: "https://app.baseten.co/settings/api_keys",
     apiKeyPlaceholder: "Your Baseten API key",
   },
+  {
+    id: "ionet",
+    displayName: "IO Intelligence",
+    subtitle:
+      "Open models served by IO Intelligence, io.net's inference platform (OpenAI-compatible). Requires an IO Intelligence API key.",
+    setupMode: "api-key",
+    setupHint:
+      "Enter your IO Intelligence API key to enable IO Intelligence models.",
+    envVar: "IONET_API_KEY",
+    credentialsGuide: {
+      description: "Sign in to io.net and create an IO Intelligence API key.",
+      url: "https://io.net/docs/guides/intelligence/api-keys-and-secrets",
+      linkLabel: "Open io.net",
+    },
+    // Model ids are Hugging Face-style `org/name`. Context windows and tool
+    // support come from the endpoint's live `GET /models` catalog, and every
+    // entry is accessible at the basic access tier.
+    models: [
+      {
+        id: "meta-llama/Llama-3.3-70B-Instruct",
+        displayName: "Llama 3.3 70B Instruct",
+        contextWindowTokens: 128000,
+        defaultContextWindowTokens: 128000,
+        maxOutputTokens: 4096,
+        supportsToolUse: true,
+      },
+      {
+        id: "openai/gpt-oss-20b",
+        displayName: "GPT-OSS 20B",
+        contextWindowTokens: 64000,
+        defaultContextWindowTokens: 64000,
+        maxOutputTokens: 32768,
+        supportsThinking: true,
+        supportsToolUse: true,
+      },
+    ],
+    defaultModel: "meta-llama/Llama-3.3-70B-Instruct",
+    apiKeyUrl: "https://io.net/docs/guides/intelligence/api-keys-and-secrets",
+    apiKeyPlaceholder: "Your IO Intelligence API key",
+  },
   {
     id: "poolside",
     displayName: "Poolside",