@travisennis/acai 0.0.1

package/source/models/openrouter-provider.ts

@@ -0,0 +1,288 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { objectKeys } from "@travisennis/stdlib/object";
+import { customProvider } from "ai";
+import type { ModelMetadata } from "./providers.ts";
+
+const openRouterClient = createOpenAICompatible({
+  name: "openrouter",
+  apiKey: process.env["OPENROUTER_API_KEY"] ?? "",
+  // biome-ignore lint/style/useNamingConvention: third-party controlled
+  baseURL: "https://openrouter.ai/api/v1",
+  headers: {
+    "HTTP-Referer": "https://github.com/travisennis/acai-ts",
+    "X-Title": "acai",
+  },
+});
+
+const openrouterModels = {
+  "deepseek-v3": openRouterClient("deepseek/deepseek-chat-v3-0324"),
+  "deepseek-r1": openRouterClient("deepseek/deepseek-r1-0528"),
+  "deepseek-v3-free": openRouterClient("deepseek/deepseek-chat-v3-0324:free"),
+  "deepseek-r1-free": openRouterClient("deepseek/deepseek-r1-0528:free"),
+  "gemini-flash25": openRouterClient("google/gemini-2.5-flash"),
+  "gemini-pro25": openRouterClient("google/gemini-2.5-pro"),
+  sonnet4: openRouterClient("anthropic/claude-sonnet-4"),
+  opus4: openRouterClient("anthropic/claude-opus-4"),
+  "opus-4.1": openRouterClient("anthropic/claude-opus-4.1"),
+  "gpt-4.1": openRouterClient("openai/gpt-4.1"),
+  "kimi-k2": openRouterClient("moonshotai/kimi-k2:nitro"),
+  "kimi-k2-free": openRouterClient("moonshotai/kimi-k2:free"),
+  "devstral-medium": openRouterClient("mistralai/devstral-medium"),
+  "qwen3-coder": openRouterClient("qwen/qwen3-coder"),
+  "qwen3-coder-free": openRouterClient("qwen/qwen3-coder:free"),
+  "glm-4.5": openRouterClient("z-ai/glm-4.5"),
+  "gpt-5": openRouterClient("openai/gpt-5"),
+  "gpt-5-mini": openRouterClient("openai/gpt-5-mini"),
+} as const;
+
+type ModelName = `openrouter:${keyof typeof openrouterModels}`;
+
+export const openrouterModelNames: ModelName[] = objectKeys(
+  openrouterModels,
+).map((key) => `openrouter:${key}` as const);
+
+export const openrouterProvider = {
+  openrouter: customProvider({
+    languageModels: openrouterModels,
+    fallbackProvider: openRouterClient,
+  }),
+};
+
+export const openrouterModelRegistry: {
+  [K in ModelName]: ModelMetadata<ModelName>;
+} = {
+  "openrouter:deepseek-v3": {
+    id: "openrouter:deepseek-v3",
+    provider: "openrouter",
+    contextWindow: 128000,
+    maxOutputTokens: 8000,
+    defaultTemperature: 0.3,
+    promptFormat: "bracket",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0, // Assuming free tier or unknown cost
+    costPerOutputToken: 0, // Assuming free tier or unknown cost
+    category: "balanced",
+  },
+  "openrouter:deepseek-r1": {
+    id: "openrouter:deepseek-r1",
+    provider: "openrouter",
+    contextWindow: 128000,
+    maxOutputTokens: 32768,
+    defaultTemperature: 0.6,
+    promptFormat: "bracket",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0, // Assuming free tier or unknown cost
+    costPerOutputToken: 0, // Assuming free tier or unknown cost
+    category: "balanced",
+  },
+  "openrouter:deepseek-v3-free": {
+    id: "openrouter:deepseek-v3-free",
+    provider: "openrouter",
+    contextWindow: 128000,
+    maxOutputTokens: 8000,
+    defaultTemperature: 0.3,
+    promptFormat: "bracket",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0, // Assuming free tier or unknown cost
+    costPerOutputToken: 0, // Assuming free tier or unknown cost
+    category: "balanced",
+  },
+  "openrouter:deepseek-r1-free": {
+    id: "openrouter:deepseek-r1-free",
+    provider: "openrouter",
+    contextWindow: 128000,
+    maxOutputTokens: 32768,
+    defaultTemperature: 0.6,
+    promptFormat: "bracket",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0, // Assuming free tier or unknown cost
+    costPerOutputToken: 0, // Assuming free tier or unknown cost
+    category: "balanced",
+  },
+  "openrouter:gemini-flash25": {
+    id: "openrouter:gemini-flash25",
+    provider: "openrouter",
+    contextWindow: 1000000,
+    maxOutputTokens: 66000,
+    defaultTemperature: 0.5,
+    promptFormat: "markdown",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0,
+    costPerOutputToken: 0,
+    category: "fast",
+  },
+  "openrouter:gemini-pro25": {
+    id: "openrouter:gemini-pro25",
+    provider: "openrouter",
+    contextWindow: 1000000,
+    maxOutputTokens: 64000,
+    defaultTemperature: 0.5,
+    promptFormat: "markdown",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0,
+    costPerOutputToken: 0,
+    category: "powerful",
+  },
+  "openrouter:opus4": {
+    id: "openrouter:opus4",
+    provider: "openrouter",
+    contextWindow: 200000,
+    maxOutputTokens: 64000,
+    defaultTemperature: 0.5,
+    promptFormat: "markdown",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0,
+    costPerOutputToken: 0,
+    category: "powerful",
+  },
+  "openrouter:opus-4.1": {
+    id: "openrouter:opus-4.1",
+    provider: "openrouter",
+    contextWindow: 200000,
+    maxOutputTokens: 32000,
+    defaultTemperature: 0.5,
+    promptFormat: "markdown",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0.000015,
+    costPerOutputToken: 0.000075,
+    category: "powerful",
+  },
+  "openrouter:sonnet4": {
+    id: "openrouter:sonnet4",
+    provider: "openrouter",
+    contextWindow: 200000,
+    maxOutputTokens: 64000,
+    defaultTemperature: 0.5,
+    promptFormat: "markdown",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0,
+    costPerOutputToken: 0,
+    category: "balanced",
+  },
+  "openrouter:gpt-4.1": {
+    id: "openrouter:gpt-4.1",
+    provider: "openrouter",
+    contextWindow: 1000000,
+    maxOutputTokens: 32768,
+    defaultTemperature: 0.3,
+    promptFormat: "markdown",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0.000002,
+    costPerOutputToken: 0.000008,
+    category: "balanced",
+  },
+  "openrouter:kimi-k2": {
+    id: "openrouter:kimi-k2",
+    provider: "openrouter",
+    contextWindow: 131072,
+    maxOutputTokens: 8192,
+    defaultTemperature: 0.6,
+    promptFormat: "markdown",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0.00000057,
+    costPerOutputToken: 0.0000023,
+    category: "balanced",
+  },
+  "openrouter:kimi-k2-free": {
+    id: "openrouter:kimi-k2-free",
+    provider: "openrouter",
+    contextWindow: 65536,
+    maxOutputTokens: 8192,
+    defaultTemperature: 0.6,
+    promptFormat: "markdown",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0,
+    costPerOutputToken: 0,
+    category: "balanced",
+  },
+  "openrouter:devstral-medium": {
+    id: "openrouter:devstral-medium",
+    provider: "openrouter",
+    contextWindow: 131000,
+    maxOutputTokens: 8192,
+    defaultTemperature: 0.3,
+    promptFormat: "markdown",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0.0000004,
+    costPerOutputToken: 0.000002,
+    category: "balanced",
+  },
+  "openrouter:qwen3-coder": {
+    id: "openrouter:qwen3-coder",
+    provider: "openrouter",
+    contextWindow: 262000,
+    maxOutputTokens: 66000,
+    defaultTemperature: 0.7,
+    promptFormat: "markdown",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0.0000004,
+    costPerOutputToken: 0.000002,
+    category: "balanced",
+  },
+  "openrouter:qwen3-coder-free": {
+    id: "openrouter:qwen3-coder-free",
+    provider: "openrouter",
+    contextWindow: 262000,
+    maxOutputTokens: 66000,
+    defaultTemperature: 0.7,
+    promptFormat: "markdown",
+    supportsReasoning: false,
+    supportsToolCalling: true,
+    costPerInputToken: 0.0000004,
+    costPerOutputToken: 0.000002,
+    category: "balanced",
+  },
+  "openrouter:glm-4.5": {
+    id: "openrouter:glm-4.5",
+    provider: "openrouter",
+    contextWindow: 128000,
+    maxOutputTokens: 8192,
+    defaultTemperature: 0.7,
+    promptFormat: "markdown",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0.0000006,
+    costPerOutputToken: 0.0000022,
+    category: "balanced",
+  },
+  "openrouter:gpt-5": {
+    id: "openrouter:gpt-5",
+    provider: "openrouter",
+    contextWindow: 400000,
+    maxOutputTokens: 128000,
+    defaultTemperature: 0.3,
+    promptFormat: "markdown",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0.00000125,
+    costPerOutputToken: 0.00001,
+    category: "powerful",
+  },
+  "openrouter:gpt-5-mini": {
+    id: "openrouter:gpt-5-mini",
+    provider: "openrouter",
+    contextWindow: 200000,
+    maxOutputTokens: 64000,
+    defaultTemperature: 0.3,
+    promptFormat: "markdown",
+    supportsReasoning: true,
+    supportsToolCalling: true,
+    costPerInputToken: 0.00000015,
+    costPerOutputToken: 0.0000006,
+    category: "balanced",
+  },
+};

package/source/models/providers.ts

@@ -0,0 +1,197 @@
+import { isString } from "@travisennis/stdlib/typeguards";
+import { createProviderRegistry } from "ai";
+import { z } from "zod";
+import {
+  anthropicModelNames,
+  anthropicModelRegistry,
+  anthropicProvider,
+} from "./anthropic-provider.ts";
+import {
+  deepseekModelNames,
+  deepseekModelRegistry,
+  deepseekProvider,
+} from "./deepseek-provider.ts";
+import {
+  googleModelNames,
+  googleModelRegistry,
+  googleProvider,
+} from "./google-provider.ts";
+import {
+  openaiModelNames,
+  openaiModelRegistry,
+  openaiProvider,
+} from "./openai-provider.ts";
+import {
+  openrouterModelNames,
+  openrouterModelRegistry,
+  openrouterProvider,
+} from "./openrouter-provider.ts";
+import {
+  xaiModelNames,
+  xaiModelRegistry,
+  xaiProvider,
+} from "./xai-provider.ts";
+
+export const providers = [
+  "anthropic",
+  "openai",
+  "google",
+  "deepseek",
+  "openrouter",
+  "xai",
+] as const;
+
+export type ModelProvider = (typeof providers)[number];
+
+const registry = createProviderRegistry({
+  ...anthropicProvider,
+  ...deepseekProvider,
+  ...googleProvider,
+  ...openaiProvider,
+  ...openrouterProvider,
+  ...xaiProvider,
+});
+
+export const models = [
+  ...anthropicModelNames,
+  ...openaiModelNames,
+  ...googleModelNames,
+  ...deepseekModelNames,
+  ...openrouterModelNames,
+  ...xaiModelNames,
+] as const;
+
+export type ModelName =
+  | (typeof models)[number]
+  | (`xai:${string}` & {})
+  | (`openai:${string}` & {})
+  | (`anthropic:${string}` & {})
+  | (`google:${string}` & {})
+  | (`deepseek:${string}` & {})
+  | (`openrouter:${string}` & {});
+
+export function isSupportedModel(model: unknown): model is ModelName {
+  return (
+    models.includes(model as (typeof models)[number]) ||
+    (isString(model) &&
+      (model.startsWith("openrouter:") ||
+        model.startsWith("anthropic:") ||
+        model.startsWith("openai:") ||
+        model.startsWith("google:") ||
+        model.startsWith("xai:") ||
+        model.startsWith("deepseek:")))
+  );
+}
+
+export function languageModel(model: ModelName) {
+  return registry.languageModel(model as (typeof models)[number]);
+}
+
+export interface ModelMetadata<T = ModelName> {
+  id: T;
+  provider: ModelProvider;
+  // displayName: string;
+  // description: string;
+  contextWindow: number;
+  supportsToolCalling: boolean;
+  supportsReasoning: boolean;
+  costPerInputToken: number;
+  costPerOutputToken: number;
+  maxOutputTokens: number;
+  defaultTemperature: number;
+  promptFormat: "xml" | "markdown" | "bracket";
+  category: "fast" | "balanced" | "powerful";
+}
+
+// https://openrouter.ai/api/v1/models
+export const modelRegistry: Record<ModelName, ModelMetadata> = {
+  ...anthropicModelRegistry,
+  ...openaiModelRegistry,
+  ...googleModelRegistry,
+  ...deepseekModelRegistry,
+  ...openrouterModelRegistry,
+  ...xaiModelRegistry,
+};
+
+// Schema for validating model selection
+export const ModelSelectionSchema = z.enum(
+  Object.keys(modelRegistry) as [string, ...string[]],
+);
+
+// Get available models grouped by provider
+export function getModelsByProvider(): Record<ModelProvider, ModelMetadata[]> {
+  const result: Record<ModelProvider, ModelMetadata[]> = {
+    anthropic: [],
+    openai: [],
+    google: [],
+    deepseek: [],
+    openrouter: [],
+    xai: [],
+  };
+
+  for (const model of Object.values(modelRegistry)) {
+    result[model.provider].push(model);
+  }
+
+  return result;
+}
+
+export function getModelsById(): Record<ModelName, string> {
+  const result: Map<ModelName, string> = new Map();
+
+  for (const name of models) {
+    const langModel = registry.languageModel(name);
+    result.set(name, langModel.modelId);
+  }
+
+  return Object.fromEntries(result) as Record<ModelName, string>;
+}
+
+// Get detailed information about a specific model
+export function getModelInfo(modelName: ModelName): ModelMetadata | undefined {
+  return modelRegistry[modelName];
+}
+
+// Get models by category
+export function getModelsByCategory(
+  category: "fast" | "balanced" | "powerful",
+): ModelMetadata[] {
+  return Object.values(modelRegistry).filter(
+    (model) => model.category === category,
+  );
+}
+
+// Format model information for display
+export function formatModelInfo(model: ModelMetadata): string {
+  return `${model.id} [${model.category}] - Tools: ${model.supportsToolCalling ? "✓" : "✗"}, Reasoning: ${model.supportsReasoning ? "✓" : "✗"}`;
+}
+
+// Check if a model name is valid
+export function isValidModel(modelName: string): modelName is ModelName {
+  return modelName in modelRegistry;
+}
+
+// Get recommended models based on task requirements
+export function getRecommendedModels(options: {
+  requiresTools?: boolean;
+  requiresReasoning?: boolean;
+  speedPriority?: boolean;
+}): ModelName[] {
+  return Object.values(modelRegistry)
+    .filter((model) => {
+      if (options.requiresTools && !model.supportsToolCalling) {
+        return false;
+      }
+      if (options.requiresReasoning && !model.supportsReasoning) {
+        return false;
+      }
+      return true;
+    })
+    .sort((a, b) => {
+      if (options.speedPriority) {
+        return a.category === "fast" ? -1 : 1;
+      }
+      return b.contextWindow - a.contextWindow;
+    })
+    .map((model) => model.id);
+}

package/source/models/xai-provider.ts

@@ -0,0 +1,59 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { objectKeys } from "@travisennis/stdlib/object";
+import { customProvider } from "ai";
+import type { ModelMetadata } from "./providers.ts";
+
+const xaiClient = createOpenAI({
+  apiKey: process.env["X_AI_API_KEY"] ?? process.env["XAI_API_KEY"],
+  // biome-ignore lint/style/useNamingConvention: third-party controlled
+  baseURL: "https://api.x.ai/v1",
+});
+
+const xaiModels = {
+  grok3: xaiClient("grok-3"),
+  "grok3-mini": xaiClient("grok-3-mini-beta"),
+} as const;
+
+type ModelName = `xai:${keyof typeof xaiModels}`;
+
+export const xaiModelNames: ModelName[] = objectKeys(xaiModels).map(
+  (key) => `xai:${key}` as const,
+);
+
+export const xaiProvider = {
+  xai: customProvider({
+    languageModels: xaiModels,
+    fallbackProvider: xaiClient,
+  }),
+};
+
+export const xaiModelRegistry: {
+  [K in ModelName]: ModelMetadata<ModelName>;
+} = {
+  "xai:grok3": {
+    id: "xai:grok3",
+    provider: "xai",
+    contextWindow: 131072,
+    maxOutputTokens: 131072, // Note: API docs might specify lower practical limits
+    defaultTemperature: 0.6,
+    promptFormat: "markdown",
+    supportsReasoning: false, // Assuming based on typical chat models
+    supportsToolCalling: true,
+    costPerInputToken: 0.000003, // Placeholder, check official pricing
+    costPerOutputToken: 0.000015, // Placeholder, check official pricing
+    category: "balanced",
+  },
+  "xai:grok3-mini": {
+    id: "xai:grok3-mini",
+    provider: "xai",
+    contextWindow: 131072,
+    maxOutputTokens: 131072, // Note: API docs might specify lower practical limits
+    defaultTemperature: 0.6,
+    promptFormat: "markdown",
+    supportsReasoning: true, // Assuming based on typical chat models
+    supportsToolCalling: true,
+    costPerInputToken: 0.0000003, // Placeholder, check official pricing
+    costPerOutputToken: 0.0000005, // Placeholder, check official pricing
+    category: "fast", // Or "fast" depending on performance
+  },
+};

package/source/parsing.ts

@@ -0,0 +1,20 @@
+import { ZodIssueCode, z } from "zod";
+
+const parseJsonPreprocessor = (value: unknown, ctx: z.RefinementCtx) => {
+  if (typeof value === "string") {
+    try {
+      return JSON.parse(value);
+    } catch (e) {
+      ctx.addIssue({
+        code: ZodIssueCode.custom,
+        message: (e as Error).message,
+      });
+    }
+  }
+
+  return value;
+};
+
+export function jsonParser<T extends z.ZodTypeAny>(input: T) {
+  return z.preprocess(parseJsonPreprocessor, input);
+}

package/source/prompts/manager.ts

@@ -0,0 +1,90 @@
+import { isString } from "@travisennis/stdlib/typeguards";
+import type { TextPart, UserModelMessage } from "ai"; // Corrected import
+import { createUserMessage, type UserMessageContentItem } from "../messages.ts";
+import type { TokenCounter } from "../token-utils.ts";
+
+export type ContextItem = UserMessageContentItem;
+
+export class PromptManager {
+  private prompt: string | undefined;
+  private context: ContextItem[];
+  private tokenCounter: TokenCounter;
+
+  constructor(tokenCounter: TokenCounter) {
+    this.prompt = undefined;
+    this.context = [];
+    this.tokenCounter = tokenCounter;
+  }
+
+  set(prompt: string) {
+    this.prompt = prompt;
+  }
+
+  get() {
+    const prompt = this.prompt;
+    if (isString(prompt) && prompt.trim().length > 0) {
+      return prompt;
+    }
+    throw new Error("No prompt available.");
+  }
+
+  getUserMessage(): UserModelMessage {
+    const currentPrompt = this.prompt;
+    if (isString(currentPrompt) && currentPrompt.trim().length > 0) {
+      let userMessage: UserModelMessage;
+      if (this.hasContext()) {
+        // Pass context items and the prompt string to createUserMessage
+        userMessage = createUserMessage([...this.context], currentPrompt);
+        this.clearAll(); // Clear context and prompt after using
+      } else {
+        // Pass an empty array for context items if no context
+        userMessage = createUserMessage([], currentPrompt);
+        this.prompt = undefined; // Clear only prompt if no context was used
+      }
+
+      return this._applyProviderOptionsToMessage(userMessage);
+    }
+    throw new Error("No prompt available.");
+  }
+
+  private _applyProviderOptionsToMessage(
+    userMessage: UserModelMessage,
+  ): UserModelMessage {
+    if (Array.isArray(userMessage.content)) {
+      for (const part of userMessage.content) {
+        if (typeof part === "object" && part !== null && part.type === "text") {
+          const textPart = part as TextPart & {
+            providerOptions?: Record<string, unknown>;
+          };
+          if (this.tokenCounter.count(textPart.text) > 4096) {
+            textPart.providerOptions = {
+              anthropic: { cacheControl: { type: "ephemeral" } },
+            };
+          }
+        }
+      }
+    }
+    return userMessage;
+  }
+
+  isPending() {
+    return isString(this.prompt) && this.prompt.trim().length > 0;
+  }
+
+  addContext(item: ContextItem): void {
+    this.context.push(item);
+  }
+
+  hasContext() {
+    return this.context.length > 0;
+  }
+
+  clearContext() {
+    this.context.length = 0;
+  }
+
+  clearAll() {
+    this.clearContext();
+    this.prompt = undefined;
+  }
+}