@travisennis/acai 0.0.1

package/dist/models/openrouter-provider.js

@@ -0,0 +1,276 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { objectKeys } from "@travisennis/stdlib/object";
+import { customProvider } from "ai";
+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"),
+};
+export const openrouterModelNames = objectKeys(openrouterModels).map((key) => `openrouter:${key}`);
+export const openrouterProvider = {
+    openrouter: customProvider({
+        languageModels: openrouterModels,
+        fallbackProvider: openRouterClient,
+    }),
+};
+export const openrouterModelRegistry = {
+    "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/dist/models/providers.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export declare const providers: readonly ["anthropic", "openai", "google", "deepseek", "openrouter", "xai"];
+export type ModelProvider = (typeof providers)[number];
+export declare const models: readonly ("anthropic:opus" | "anthropic:sonnet" | "anthropic:sonnet37" | "anthropic:sonnet37-token-efficient-tools" | "anthropic:sonnet37-128k" | "anthropic:sonnet35" | "anthropic:haiku" | "deepseek:deepseek-chat" | "deepseek:deepseek-reasoner" | "google:flash25lite" | "google:pro25" | "google:flash25" | "openai:o3" | "openai:gpt-4.1" | "openai:o4-mini" | "openai:codex-mini" | "openrouter:gpt-5" | "openrouter:gpt-5-mini" | "openrouter:gpt-4.1" | "openrouter:deepseek-v3" | "openrouter:deepseek-r1" | "openrouter:deepseek-v3-free" | "openrouter:deepseek-r1-free" | "openrouter:gemini-flash25" | "openrouter:gemini-pro25" | "openrouter:sonnet4" | "openrouter:opus4" | "openrouter:opus-4.1" | "openrouter:kimi-k2" | "openrouter:kimi-k2-free" | "openrouter:devstral-medium" | "openrouter:qwen3-coder" | "openrouter:qwen3-coder-free" | "openrouter:glm-4.5" | "xai:grok3" | "xai:grok3-mini")[];
+export type ModelName = (typeof models)[number] | (`xai:${string}` & {}) | (`openai:${string}` & {}) | (`anthropic:${string}` & {}) | (`google:${string}` & {}) | (`deepseek:${string}` & {}) | (`openrouter:${string}` & {});
+export declare function isSupportedModel(model: unknown): model is ModelName;
+export declare function languageModel(model: ModelName): import("@ai-sdk/provider").LanguageModelV2;
+export interface ModelMetadata<T = ModelName> {
+    id: T;
+    provider: ModelProvider;
+    contextWindow: number;
+    supportsToolCalling: boolean;
+    supportsReasoning: boolean;
+    costPerInputToken: number;
+    costPerOutputToken: number;
+    maxOutputTokens: number;
+    defaultTemperature: number;
+    promptFormat: "xml" | "markdown" | "bracket";
+    category: "fast" | "balanced" | "powerful";
+}
+export declare const modelRegistry: Record<ModelName, ModelMetadata>;
+export declare const ModelSelectionSchema: z.ZodEnum<[string, ...string[]]>;
+export declare function getModelsByProvider(): Record<ModelProvider, ModelMetadata[]>;
+export declare function getModelsById(): Record<ModelName, string>;
+export declare function getModelInfo(modelName: ModelName): ModelMetadata | undefined;
+export declare function getModelsByCategory(category: "fast" | "balanced" | "powerful"): ModelMetadata[];
+export declare function formatModelInfo(model: ModelMetadata): string;
+export declare function isValidModel(modelName: string): modelName is ModelName;
+export declare function getRecommendedModels(options: {
+    requiresTools?: boolean;
+    requiresReasoning?: boolean;
+    speedPriority?: boolean;
+}): ModelName[];

package/dist/models/providers.js

@@ -0,0 +1,116 @@
+import { isString } from "@travisennis/stdlib/typeguards";
+import { createProviderRegistry } from "ai";
+import { z } from "zod";
+import { anthropicModelNames, anthropicModelRegistry, anthropicProvider, } from "./anthropic-provider.js";
+import { deepseekModelNames, deepseekModelRegistry, deepseekProvider, } from "./deepseek-provider.js";
+import { googleModelNames, googleModelRegistry, googleProvider, } from "./google-provider.js";
+import { openaiModelNames, openaiModelRegistry, openaiProvider, } from "./openai-provider.js";
+import { openrouterModelNames, openrouterModelRegistry, openrouterProvider, } from "./openrouter-provider.js";
+import { xaiModelNames, xaiModelRegistry, xaiProvider, } from "./xai-provider.js";
+export const providers = [
+    "anthropic",
+    "openai",
+    "google",
+    "deepseek",
+    "openrouter",
+    "xai",
+];
+const registry = createProviderRegistry({
+    ...anthropicProvider,
+    ...deepseekProvider,
+    ...googleProvider,
+    ...openaiProvider,
+    ...openrouterProvider,
+    ...xaiProvider,
+});
+export const models = [
+    ...anthropicModelNames,
+    ...openaiModelNames,
+    ...googleModelNames,
+    ...deepseekModelNames,
+    ...openrouterModelNames,
+    ...xaiModelNames,
+];
+export function isSupportedModel(model) {
+    return (models.includes(model) ||
+        (isString(model) &&
+            (model.startsWith("openrouter:") ||
+                model.startsWith("anthropic:") ||
+                model.startsWith("openai:") ||
+                model.startsWith("google:") ||
+                model.startsWith("xai:") ||
+                model.startsWith("deepseek:"))));
+}
+export function languageModel(model) {
+    return registry.languageModel(model);
+}
+// https://openrouter.ai/api/v1/models
+export const modelRegistry = {
+    ...anthropicModelRegistry,
+    ...openaiModelRegistry,
+    ...googleModelRegistry,
+    ...deepseekModelRegistry,
+    ...openrouterModelRegistry,
+    ...xaiModelRegistry,
+};
+// Schema for validating model selection
+export const ModelSelectionSchema = z.enum(Object.keys(modelRegistry));
+// Get available models grouped by provider
+export function getModelsByProvider() {
+    const result = {
+        anthropic: [],
+        openai: [],
+        google: [],
+        deepseek: [],
+        openrouter: [],
+        xai: [],
+    };
+    for (const model of Object.values(modelRegistry)) {
+        result[model.provider].push(model);
+    }
+    return result;
+}
+export function getModelsById() {
+    const result = new Map();
+    for (const name of models) {
+        const langModel = registry.languageModel(name);
+        result.set(name, langModel.modelId);
+    }
+    return Object.fromEntries(result);
+}
+// Get detailed information about a specific model
+export function getModelInfo(modelName) {
+    return modelRegistry[modelName];
+}
+// Get models by category
+export function getModelsByCategory(category) {
+    return Object.values(modelRegistry).filter((model) => model.category === category);
+}
+// Format model information for display
+export function formatModelInfo(model) {
+    return `${model.id} [${model.category}] - Tools: ${model.supportsToolCalling ? "✓" : "✗"}, Reasoning: ${model.supportsReasoning ? "✓" : "✗"}`;
+}
+// Check if a model name is valid
+export function isValidModel(modelName) {
+    return modelName in modelRegistry;
+}
+// Get recommended models based on task requirements
+export function getRecommendedModels(options) {
+    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/dist/models/xai-provider.d.ts

@@ -0,0 +1,20 @@
+import type { ModelMetadata } from "./providers.ts";
+declare const xaiModels: {
+    readonly grok3: import("@ai-sdk/provider").LanguageModelV2;
+    readonly "grok3-mini": import("@ai-sdk/provider").LanguageModelV2;
+};
+type ModelName = `xai:${keyof typeof xaiModels}`;
+export declare const xaiModelNames: ModelName[];
+export declare const xaiProvider: {
+    xai: import("@ai-sdk/provider").ProviderV2 & {
+        languageModel(modelId: "grok3" | "grok3-mini"): import("@ai-sdk/provider").LanguageModelV2;
+        textEmbeddingModel(modelId: string): import("@ai-sdk/provider").EmbeddingModelV2<string>;
+        imageModel(modelId: string): import("@ai-sdk/provider").ImageModelV2;
+        transcriptionModel(modelId: string): import("@ai-sdk/provider").TranscriptionModelV2;
+        speechModel(modelId: string): import("@ai-sdk/provider").SpeechModelV2;
+    };
+};
+export declare const xaiModelRegistry: {
+    [K in ModelName]: ModelMetadata<ModelName>;
+};
+export {};

package/dist/models/xai-provider.js

@@ -0,0 +1,47 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { objectKeys } from "@travisennis/stdlib/object";
+import { customProvider } from "ai";
+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"),
+};
+export const xaiModelNames = objectKeys(xaiModels).map((key) => `xai:${key}`);
+export const xaiProvider = {
+    xai: customProvider({
+        languageModels: xaiModels,
+        fallbackProvider: xaiClient,
+    }),
+};
+export const xaiModelRegistry = {
+    "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/dist/parsing.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare function jsonParser<T extends z.ZodTypeAny>(input: T): z.ZodEffects<T, T["_output"], unknown>;

package/dist/parsing.js

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

package/dist/prompts/manager.d.ts

@@ -0,0 +1,19 @@
+import type { UserModelMessage } from "ai";
+import { type UserMessageContentItem } from "../messages.ts";
+import type { TokenCounter } from "../token-utils.ts";
+export type ContextItem = UserMessageContentItem;
+export declare class PromptManager {
+    private prompt;
+    private context;
+    private tokenCounter;
+    constructor(tokenCounter: TokenCounter);
+    set(prompt: string): void;
+    get(): string;
+    getUserMessage(): UserModelMessage;
+    private _applyProviderOptionsToMessage;
+    isPending(): boolean;
+    addContext(item: ContextItem): void;
+    hasContext(): boolean;
+    clearContext(): void;
+    clearAll(): void;
+}

package/dist/prompts/manager.js

@@ -0,0 +1,71 @@
+import { isString } from "@travisennis/stdlib/typeguards";
+import { createUserMessage } from "../messages.js";
+export class PromptManager {
+    prompt;
+    context;
+    tokenCounter;
+    constructor(tokenCounter) {
+        this.prompt = undefined;
+        this.context = [];
+        this.tokenCounter = tokenCounter;
+    }
+    set(prompt) {
+        this.prompt = prompt;
+    }
+    get() {
+        const prompt = this.prompt;
+        if (isString(prompt) && prompt.trim().length > 0) {
+            return prompt;
+        }
+        throw new Error("No prompt available.");
+    }
+    getUserMessage() {
+        const currentPrompt = this.prompt;
+        if (isString(currentPrompt) && currentPrompt.trim().length > 0) {
+            let userMessage;
+            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.");
+    }
+    _applyProviderOptionsToMessage(userMessage) {
+        if (Array.isArray(userMessage.content)) {
+            for (const part of userMessage.content) {
+                if (typeof part === "object" && part !== null && part.type === "text") {
+                    const textPart = part;
+                    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) {
+        this.context.push(item);
+    }
+    hasContext() {
+        return this.context.length > 0;
+    }
+    clearContext() {
+        this.context.length = 0;
+    }
+    clearAll() {
+        this.clearContext();
+        this.prompt = undefined;
+    }
+}

package/dist/prompts.d.ts

@@ -0,0 +1,4 @@
+export declare function systemPrompt(options?: {
+    supportsToolCalling?: boolean;
+}): Promise<string>;
+export declare function minSystemPrompt(): Promise<string>;