@travisennis/acai 0.0.1

package/source/models/anthropic-provider.ts

@@ -0,0 +1,199 @@
+import {
+  createAnthropic,
+  anthropic as originalAnthropic,
+} from "@ai-sdk/anthropic";
+import { objectKeys } from "@travisennis/stdlib/object";
+import { isRecord } from "@travisennis/stdlib/typeguards";
+import { customProvider } from "ai";
+import type { ModelMetadata } from "./providers.ts";
+
+// Helper function copied from original providers.ts
+function addCacheControlToTools(body: string) {
+  const parsedBody = JSON.parse(body);
+  if (isRecord(parsedBody)) {
+    const tools = parsedBody["tools"];
+    if (Array.isArray(tools)) {
+      tools.at(-1).cache_control = { type: "ephemeral" };
+    }
+  }
+  return JSON.stringify(parsedBody);
+}
+
+const anthropicModels = {
+  opus: createAnthropic({
+    fetch(input, init) {
+      const body = init?.body;
+      if (body && typeof body === "string") {
+        init.body = addCacheControlToTools(body);
+      }
+      return fetch(input, init);
+    },
+  })("claude-4-opus-20250514"),
+  sonnet: createAnthropic({
+    fetch(input, init) {
+      const body = init?.body;
+      if (body && typeof body === "string") {
+        init.body = addCacheControlToTools(body);
+      }
+      return fetch(input, init);
+    },
+  })("claude-4-sonnet-20250514"),
+  sonnet37: createAnthropic({
+    fetch(input, init) {
+      const body = init?.body;
+      if (body && typeof body === "string") {
+        init.body = addCacheControlToTools(body);
+      }
+      return fetch(input, init);
+    },
+  })("claude-3-7-sonnet-20250219"),
+  "sonnet37-token-efficient-tools": createAnthropic({
+    headers: {
+      "anthropic-version": "2023-06-01",
+      "anthropic-beta": "token-efficient-tools-2025-02-19",
+    },
+    fetch(input, init) {
+      const body = init?.body;
+      if (body && typeof body === "string") {
+        init.body = addCacheControlToTools(body);
+      }
+      return fetch(input, init);
+    },
+  })("claude-3-7-sonnet-20250219"),
+  "sonnet37-128k": createAnthropic({
+    headers: {
+      "anthropic-version": "2023-06-01",
+      "anthropic-beta": "output-128k-2025-02-19",
+    },
+    fetch(input, init) {
+      const body = init?.body;
+      if (body && typeof body === "string") {
+        init.body = addCacheControlToTools(body);
+      }
+      return fetch(input, init);
+    },
+  })("claude-3-7-sonnet-20250219"),
+  sonnet35: createAnthropic({
+    headers: {
+      "anthropic-version": "2023-06-01",
+      "anthropic-beta": "max-tokens-3-5-sonnet-2024-07-15",
+    },
+    fetch(input, init) {
+      const body = init?.body;
+      if (body && typeof body === "string") {
+        init.body = addCacheControlToTools(body);
+      }
+      return fetch(input, init);
+    },
+  })("claude-3-5-sonnet-20241022"),
+  haiku: originalAnthropic("claude-3-5-haiku-20241022"),
+} as const;
+
+type ModelName = `anthropic:${keyof typeof anthropicModels}`;
+
+export const anthropicModelNames: ModelName[] = objectKeys(anthropicModels).map(
+  (key) => `anthropic:${key}` as const,
+);
+
+export const anthropicProvider = {
+  anthropic: customProvider({
+    languageModels: anthropicModels,
+    fallbackProvider: originalAnthropic,
+  }),
+};
+
+export const anthropicModelRegistry: {
+  [K in ModelName]: ModelMetadata<ModelName>;
+} = {
+  "anthropic:opus": {
+    id: "anthropic:opus",
+    provider: "anthropic",
+    contextWindow: 200000,
+    maxOutputTokens: 64000,
+    defaultTemperature: 0.3,
+    promptFormat: "xml",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0.000015,
+    costPerOutputToken: 0.000075,
+    category: "powerful",
+  },
+  "anthropic:sonnet": {
+    id: "anthropic:sonnet",
+    provider: "anthropic",
+    contextWindow: 200000,
+    maxOutputTokens: 64000,
+    defaultTemperature: 0.3,
+    promptFormat: "xml",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0.000003,
+    costPerOutputToken: 0.000015,
+    category: "balanced",
+  },
+  "anthropic:sonnet37": {
+    id: "anthropic:sonnet37",
+    provider: "anthropic",
+    contextWindow: 200000,
+    maxOutputTokens: 64000,
+    defaultTemperature: 0.3,
+    promptFormat: "xml",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0.000003,
+    costPerOutputToken: 0.000015,
+    category: "balanced",
+  },
+  "anthropic:sonnet37-token-efficient-tools": {
+    id: "anthropic:sonnet37-token-efficient-tools",
+    provider: "anthropic",
+    contextWindow: 200000,
+    maxOutputTokens: 64000,
+    defaultTemperature: 0.3,
+    promptFormat: "xml",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0.000003,
+    costPerOutputToken: 0.000015,
+    category: "balanced",
+  },
+  "anthropic:sonnet37-128k": {
+    id: "anthropic:sonnet37-128k",
+    provider: "anthropic",
+    contextWindow: 200000,
+    maxOutputTokens: 128000,
+    defaultTemperature: 0.3,
+    promptFormat: "xml",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0.000003,
+    costPerOutputToken: 0.000015,
+    category: "powerful",
+  },
+  "anthropic:sonnet35": {
+    id: "anthropic:sonnet35",
+    provider: "anthropic",
+    contextWindow: 200000,
+    maxOutputTokens: 8096,
+    defaultTemperature: 0.3,
+    promptFormat: "xml",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0.000003,
+    costPerOutputToken: 0.000015,
+    category: "balanced",
+  },
+  "anthropic:haiku": {
+    id: "anthropic:haiku",
+    provider: "anthropic",
+    contextWindow: 200000,
+    maxOutputTokens: 4096,
+    defaultTemperature: 0.3,
+    promptFormat: "xml",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0.0000008,
+    costPerOutputToken: 0.000004,
+    category: "fast",
+  },
+};

package/source/models/deepseek-provider.ts

@@ -0,0 +1,53 @@
+import { deepseek as originalDeepseek } from "@ai-sdk/deepseek";
+import { objectKeys } from "@travisennis/stdlib/object";
+import { customProvider } from "ai";
+import type { ModelMetadata } from "./providers.ts";
+
+const deepseekModels = {
+  "deepseek-chat": originalDeepseek("deepseek-chat"),
+  "deepseek-reasoner": originalDeepseek("deepseek-reasoner"),
+} as const;
+
+type ModelName = `deepseek:${keyof typeof deepseekModels}`;
+
+export const deepseekModelNames: ModelName[] = objectKeys(deepseekModels).map(
+  (key) => `deepseek:${key}` as const,
+);
+
+export const deepseekProvider = {
+  deepseek: customProvider({
+    languageModels: deepseekModels,
+    fallbackProvider: originalDeepseek,
+  }),
+};
+
+export const deepseekModelRegistry: {
+  [K in ModelName]: ModelMetadata<ModelName>;
+} = {
+  "deepseek:deepseek-chat": {
+    id: "deepseek:deepseek-chat",
+    provider: "deepseek",
+    contextWindow: 128000,
+    maxOutputTokens: 8000,
+    defaultTemperature: 0.3,
+    promptFormat: "bracket",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0.0000012, // Check official pricing
+    costPerOutputToken: 0.0000012, // Check official pricing
+    category: "balanced",
+  },
+  "deepseek:deepseek-reasoner": {
+    id: "deepseek:deepseek-reasoner",
+    provider: "deepseek",
+    contextWindow: 128000,
+    maxOutputTokens: 32768,
+    defaultTemperature: 0.6,
+    promptFormat: "bracket",
+    supportsReasoning: true,
+    supportsToolCalling: true, // Check if this model supports tools
+    costPerInputToken: 0.00000055, // Check official pricing
+    costPerOutputToken: 0.00000219, // Check official pricing
+    category: "balanced",
+  },
+};

package/source/models/google-provider.ts

@@ -0,0 +1,68 @@
+import { google as originalGoogle } from "@ai-sdk/google";
+import { objectKeys } from "@travisennis/stdlib/object";
+import { customProvider } from "ai";
+import type { ModelMetadata } from "./providers.ts";
+
+const googleModels = {
+  flash25lite: originalGoogle("gemini-2.5-flash-lite-preview-06-17"),
+  pro25: originalGoogle("gemini-2.5-pro"),
+  flash25: originalGoogle("gemini-2.5-flash"),
+} as const;
+
+type ModelName = `google:${keyof typeof googleModels}`;
+
+export const googleModelNames: ModelName[] = objectKeys(googleModels).map(
+  (key) => `google:${key}` as const,
+);
+
+export const googleProvider = {
+  google: customProvider({
+    languageModels: googleModels,
+    fallbackProvider: originalGoogle,
+  }),
+};
+
+export const googleModelRegistry: Record<
+  ModelName,
+  ModelMetadata<ModelName>
+> = {
+  "google:flash25lite": {
+    id: "google:flash25lite",
+    provider: "google",
+    contextWindow: 1000000,
+    maxOutputTokens: 8192,
+    defaultTemperature: 0.3,
+    promptFormat: "markdown",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0,
+    costPerOutputToken: 0,
+    category: "fast",
+  },
+  "google:pro25": {
+    id: "google:pro25",
+    provider: "google",
+    contextWindow: 1000000,
+    maxOutputTokens: 64000,
+    defaultTemperature: 0.7,
+    promptFormat: "markdown",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0,
+    costPerOutputToken: 0,
+    category: "powerful",
+  },
+  "google:flash25": {
+    id: "google:flash25",
+    provider: "google",
+    contextWindow: 1048576,
+    maxOutputTokens: 65536,
+    defaultTemperature: 0.3,
+    promptFormat: "markdown",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0.00000015,
+    costPerOutputToken: 0.0000035,
+    category: "balanced",
+  },
+};

package/source/models/manager.ts

@@ -0,0 +1,84 @@
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+import { wrapLanguageModel } from "ai";
+import {
+  auditMessage,
+  createRateLimitMiddleware,
+} from "../middleware/index.ts";
+import {
+  languageModel,
+  type ModelMetadata,
+  type ModelName,
+  modelRegistry,
+} from "./providers.ts";
+
+function getLanguageModel({
+  model,
+  app,
+  stateDir,
+}: {
+  model: ModelName;
+  app: string;
+  stateDir: string;
+}) {
+  const langModel = wrapLanguageModel({
+    model: languageModel(model),
+    middleware: [
+      createRateLimitMiddleware({ requestsPerMinute: 30 }),
+      auditMessage({ filePath: stateDir, app }),
+    ],
+  });
+
+  return langModel;
+}
+
+type App =
+  | "repl"
+  | "cli"
+  | "title-conversation"
+  | "conversation-summarizer"
+  | "conversation-analyzer"
+  | "tool-repair"
+  | "init-project"
+  | "task-agent";
+
+export class ModelManager {
+  private modelMap: Map<App, LanguageModelV2>;
+  private modelMetadataMap: Map<App, ModelMetadata>;
+  private stateDir: string;
+  constructor({ stateDir }: { stateDir: string }) {
+    this.modelMap = new Map();
+    this.modelMetadataMap = new Map();
+    this.stateDir = stateDir;
+  }
+
+  setModel(app: App, model: ModelName) {
+    this.modelMap.set(
+      app,
+      getLanguageModel({
+        model,
+        app,
+        stateDir: this.stateDir,
+      }),
+    );
+    const modelMetadata = modelRegistry[model];
+    if (modelMetadata) {
+      this.modelMetadataMap.set(app, modelMetadata);
+    }
+  }
+
+  getModel(app: App) {
+    const model = this.modelMap.get(app);
+    if (!model) {
+      throw new Error("Model not initialized.");
+    }
+    return model;
+  }
+
+  getModelMetadata(app: App) {
+    const metadata = this.modelMetadataMap.get(app);
+    if (!metadata) {
+      throw new Error("Model not initialized.");
+    }
+    return metadata;
+  }
+}

package/source/models/openai-provider.ts

@@ -0,0 +1,81 @@
+import { openai as originalOpenAi } from "@ai-sdk/openai";
+import { objectKeys } from "@travisennis/stdlib/object";
+import { customProvider } from "ai";
+import type { ModelMetadata } from "./providers.ts";
+
+const openaiModels = {
+  "gpt-4.1": originalOpenAi("gpt-4.1"),
+  o3: originalOpenAi.responses("o3"),
+  "o4-mini": originalOpenAi.responses("o4-mini"),
+  "codex-mini": originalOpenAi("codex-mini-latest"),
+} as const;
+
+type ModelName = `openai:${keyof typeof openaiModels}`;
+
+export const openaiModelNames: ModelName[] = objectKeys(openaiModels).map(
+  (key) => `openai:${key}` as const,
+);
+
+export const openaiProvider = {
+  openai: customProvider({
+    languageModels: openaiModels,
+    fallbackProvider: originalOpenAi,
+  }),
+};
+
+export const openaiModelRegistry: {
+  [K in ModelName]: ModelMetadata<ModelName>;
+} = {
+  "openai:gpt-4.1": {
+    id: "openai:gpt-4.1",
+    provider: "openai",
+    contextWindow: 1000000,
+    maxOutputTokens: 32768,
+    defaultTemperature: 0.3,
+    promptFormat: "markdown",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0.000002,
+    costPerOutputToken: 0.000008,
+    category: "balanced",
+  },
+  "openai:o3": {
+    id: "openai:o3",
+    provider: "openai",
+    contextWindow: 200000,
+    maxOutputTokens: 100000,
+    defaultTemperature: 0.3,
+    promptFormat: "markdown",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0.00001,
+    costPerOutputToken: 0.00004,
+    category: "powerful",
+  },
+  "openai:o4-mini": {
+    id: "openai:o4-mini",
+    provider: "openai",
+    contextWindow: 200000,
+    maxOutputTokens: 100000,
+    defaultTemperature: 0.3,
+    promptFormat: "markdown",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0.0000011,
+    costPerOutputToken: 0.0000044,
+    category: "balanced",
+  },
+  "openai:codex-mini": {
+    id: "openai:codex-mini",
+    provider: "openai",
+    contextWindow: 200000,
+    maxOutputTokens: 100000,
+    defaultTemperature: 0.3,
+    promptFormat: "markdown",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0.0000015,
+    costPerOutputToken: 0.000006,
+    category: "balanced",
+  },
+};