@stacksjs/ai 0.70.88 → 0.70.90

package/dist/drivers/anthropic/index.d.ts

@@ -0,0 +1,40 @@
+import type { AIDriver, AIDriverConfig, AIMessage, AIResult, ChatCompletionOptions } from '../../types';
+/**
+ * Configure Anthropic globally
+ */
+export declare function configure(config: AnthropicDriverConfig): void;
+export declare function createAnthropicDriver(config: AnthropicDriverConfig): AIDriver;
+/**
+ * Chat completion with full options. Supports tools + structured
+ * output via `responseFormat` (stacksjs/stacks#1878 A-1).
+ */
+export declare function chat(messages: AIMessage[], options?: ChatCompletionOptions & { system?: string }): Promise<AIResult>;
+/**
+ * Stream chat completion
+ */
+export declare function streamChat(messages: AIMessage[], options?: ChatCompletionOptions & { system?: string }): AsyncGenerator<string>;
+/**
+ * Simple prompt helper
+ */
+export declare function prompt(text: string, options?: ChatCompletionOptions & { system?: string }): Promise<string>;
+/**
+ * Count tokens (approximate)
+ * Note: This is a rough estimate. For accurate counts, use the tokenizer.
+ */
+export declare function estimateTokens(text: string): number;
+export declare const anthropicDriver: { create: typeof createAnthropicDriver };
+export declare const anthropic: {
+  configure: typeof configure;
+  chat: typeof chat;
+  streamChat: typeof streamChat;
+  prompt: typeof prompt;
+  estimateTokens: typeof estimateTokens;
+  createDriver: unknown
+};
+export declare interface AnthropicDriverConfig extends AIDriverConfig {
+  apiKey: string
+  model?: string
+  maxTokens?: number
+  anthropicVersion?: string
+}
+export default anthropic;

package/dist/drivers/anthropic/index.js

@@ -0,0 +1,276 @@
+import { fetchWithRetry } from "../../utils/retry";
+import { recordUsage } from "../../utils/usage";
+import { normalizeMessagesForProvider } from "../../utils/vision";
+const DEFAULT_MODEL = "claude-sonnet-4-20250514", DEFAULT_MAX_TOKENS = 4096, DEFAULT_VERSION = "2023-06-01", BASE_URL = "https://api.anthropic.com/v1";
+let globalConfig = null;
+export function configure(config) {
+  globalConfig = config;
+}
+function getConfig(config) {
+  const merged = { ...globalConfig, ...config };
+  if (!merged.apiKey)
+    merged.apiKey = process.env.ANTHROPIC_API_KEY || "";
+  return merged;
+}
+export function createAnthropicDriver(config) {
+  const {
+    apiKey,
+    model = DEFAULT_MODEL,
+    maxTokens = DEFAULT_MAX_TOKENS,
+    anthropicVersion = DEFAULT_VERSION
+  } = config;
+  return {
+    name: "Claude API",
+    async process(command, systemPrompt, history) {
+      if (!apiKey)
+        throw Error("Anthropic API key not set. Configure your API key in settings.");
+      const response = await fetchWithRetry(`${BASE_URL}/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": anthropicVersion
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: maxTokens,
+          system: systemPrompt,
+          messages: [...history, { role: "user", content: command }]
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw Error(`Claude API error: ${error}`);
+      }
+      const data = await response.json();
+      if (!data.content || data.content.length === 0)
+        throw Error("Claude API returned empty content");
+      return data.content[0].text;
+    },
+    async* stream(command, systemPrompt, history) {
+      if (!apiKey)
+        throw Error("Anthropic API key not set. Configure your API key in settings.");
+      const response = await fetch(`${BASE_URL}/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": anthropicVersion
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: maxTokens,
+          system: systemPrompt,
+          stream: !0,
+          messages: [...history, { role: "user", content: command }]
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        throw Error(`Claude API error: ${error}`);
+      }
+      const reader = response.body?.getReader();
+      if (!reader)
+        throw Error("No response body");
+      const decoder = new TextDecoder;
+      let buffer = "";
+      const handlePayload = function* (data) {
+        if (data === "[DONE]")
+          return;
+        let event;
+        try {
+          event = JSON.parse(data);
+        } catch {
+          return;
+        }
+        if (event.type === "error") {
+          const msg = event.error?.message ?? JSON.stringify(event.error ?? event);
+          throw Error(`[anthropic/stream] mid-stream error: ${msg}`);
+        }
+        if (event.type === "content_block_delta" && event.delta?.text)
+          yield event.delta.text;
+      };
+      while (!0) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        buffer += decoder.decode(value, { stream: !0 });
+        const lines = buffer.split(`
+`);
+        buffer = lines.pop() || "";
+        for (const line of lines)
+          if (line.startsWith("data: "))
+            yield* handlePayload(line.slice(6));
+      }
+      if (buffer.startsWith("data: "))
+        yield* handlePayload(buffer.slice(6));
+    }
+  };
+}
+export async function chat(messages, options = {}) {
+  const config = getConfig(), {
+    model = DEFAULT_MODEL,
+    maxTokens = DEFAULT_MAX_TOKENS,
+    temperature,
+    topP,
+    stop,
+    system,
+    tools,
+    toolChoice,
+    responseFormat
+  } = options, normalizedMessages = normalizeMessagesForProvider(messages, "anthropic"), startedAt = Date.now(), body = {
+    model,
+    max_tokens: maxTokens,
+    temperature,
+    top_p: topP,
+    stop_sequences: stop ? Array.isArray(stop) ? stop : [stop] : void 0,
+    system,
+    messages: normalizedMessages
+  };
+  if (tools && tools.length > 0) {
+    body.tools = tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.parameters ?? { type: "object", properties: {} }
+    }));
+    if (toolChoice !== void 0)
+      body.tool_choice = mapAnthropicToolChoice(toolChoice);
+  }
+  if (responseFormat && responseFormat.type !== "text") {
+    const outputTool = buildAnthropicJsonTool(responseFormat), existing = Array.isArray(body.tools) ? body.tools : [];
+    body.tools = [...existing, outputTool];
+    if (toolChoice === void 0)
+      body.tool_choice = { type: "tool", name: outputTool.name };
+  }
+  const response = await fetch(`${BASE_URL}/messages`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": config.apiKey,
+      "anthropic-version": config.anthropicVersion || DEFAULT_VERSION
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`Claude API error: ${error}`);
+  }
+  const data = await response.json();
+  if (!data.content || data.content.length === 0)
+    throw Error("Claude API returned empty content");
+  const block = data.content.find((b) => b.type === "tool_use") ?? data.content.find((b) => b.type === "text") ?? data.content[0], result = {
+    content: block?.type === "tool_use" ? JSON.stringify(block.input) : block?.text ?? "",
+    model: data.model,
+    usage: {
+      promptTokens: data.usage?.input_tokens || 0,
+      completionTokens: data.usage?.output_tokens || 0,
+      totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0)
+    },
+    finishReason: data.stop_reason
+  };
+  recordUsage({
+    provider: "anthropic",
+    model: data.model,
+    promptTokens: result.usage.promptTokens,
+    completionTokens: result.usage.completionTokens,
+    totalTokens: result.usage.totalTokens,
+    durationMs: Date.now() - startedAt,
+    timestamp: Date.now()
+  });
+  return result;
+}
+function mapAnthropicToolChoice(choice) {
+  if (choice === "auto")
+    return { type: "auto" };
+  if (choice === "required")
+    return { type: "any" };
+  if (choice === "none")
+    return { type: "auto", disable_parallel_tool_use: !0 };
+  return { type: "tool", name: choice.name };
+}
+function buildAnthropicJsonTool(format) {
+  if (format.type === "json_schema")
+    return {
+      name: format.json_schema.name,
+      description: `Returns the result as JSON matching the '${format.json_schema.name}' schema.`,
+      input_schema: format.json_schema.schema
+    };
+  return {
+    name: "structured_output",
+    description: "Returns the result as a JSON object.",
+    input_schema: { type: "object", additionalProperties: !0 }
+  };
+}
+export async function* streamChat(messages, options = {}) {
+  const config = getConfig(), {
+    model = DEFAULT_MODEL,
+    maxTokens = DEFAULT_MAX_TOKENS,
+    temperature,
+    topP,
+    stop,
+    system
+  } = options, response = await fetch(`${BASE_URL}/messages`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": config.apiKey,
+      "anthropic-version": config.anthropicVersion || DEFAULT_VERSION
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: maxTokens,
+      temperature,
+      top_p: topP,
+      stop_sequences: stop ? Array.isArray(stop) ? stop : [stop] : void 0,
+      system,
+      stream: !0,
+      messages: normalizeMessagesForProvider(messages, "anthropic")
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw Error(`Claude API error: ${error}`);
+  }
+  const reader = response.body?.getReader();
+  if (!reader)
+    throw Error("No response body");
+  const decoder = new TextDecoder;
+  let buffer = "";
+  while (!0) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder.decode(value, { stream: !0 });
+    const lines = buffer.split(`
+`);
+    buffer = lines.pop() || "";
+    for (const line of lines)
+      if (line.startsWith("data: ")) {
+        const data = line.slice(6);
+        if (data === "[DONE]")
+          continue;
+        try {
+          const event = JSON.parse(data);
+          if (event.type === "content_block_delta" && event.delta?.text)
+            yield event.delta.text;
+        } catch {}
+      }
+  }
+}
+export async function prompt(text, options = {}) {
+  return (await chat([{ role: "user", content: text }], options)).content;
+}
+export function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+export const anthropicDriver = {
+  create: createAnthropicDriver
+}, anthropic = {
+  configure,
+  chat,
+  streamChat,
+  prompt,
+  estimateTokens,
+  createDriver: createAnthropicDriver
+};
+export default anthropic;

package/dist/drivers/claude-agent-sdk/index.d.ts

@@ -0,0 +1,40 @@
+import type { AIDriver, AIDriverConfig, StreamingResult } from '../../types';
+/**
+ * Create a Claude Agent SDK driver instance
+ */
+export declare function createClaudeAgentSDKDriver(config?: ClaudeAgentSDKConfig): AIDriver;
+/**
+ * Process a command with streaming and return a StreamingResult
+ */
+export declare function processStreaming(command: string, cwd?: string, config?: Omit<ClaudeAgentSDKConfig, 'cwd'>): Promise<StreamingResult>;
+/**
+ * Resume a previous SDK session
+ */
+export declare function resumeSession(sessionId: string, prompt: string): Promise<string>;
+/**
+ * Get the last session ID for potential resume
+ */
+export declare function getLastSessionId(): string | undefined;
+/**
+ * Clear the stored session ID
+ */
+export declare function clearSession(): void;
+// Export the driver creator and utilities
+export declare const claudeAgentSDK: {
+  createDriver: unknown;
+  processStreaming: typeof processStreaming;
+  resumeSession: typeof resumeSession;
+  getLastSessionId: typeof getLastSessionId;
+  clearSession: typeof clearSession
+};
+export declare interface ClaudeAgentSDKConfig extends AIDriverConfig {
+  maxTurns?: number
+  cwd?: string
+  allowedTools?: string[]
+  disallowedTools?: string[]
+  permissionMode?: 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan'
+  customSystemPrompt?: string
+  appendSystemPrompt?: string
+  resumeSessionId?: string
+}
+export default claudeAgentSDK;

package/dist/drivers/claude-agent-sdk/index.js

@@ -0,0 +1,198 @@
+let sdkModule = null;
+async function getSDK() {
+  if (!sdkModule)
+    try {
+      sdkModule = await import("@anthropic-ai/claude-agent-sdk");
+    } catch {
+      throw Error("Claude Agent SDK not installed. Run: bun add @anthropic-ai/claude-agent-sdk");
+    }
+  return sdkModule;
+}
+const sdkState = {
+  lastSessionId: void 0
+}, DEFAULT_CONFIG = {
+  maxTurns: 25,
+  allowedTools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep"],
+  permissionMode: "bypassPermissions"
+};
+export function createClaudeAgentSDKDriver(config = {}) {
+  const {
+    maxTurns = DEFAULT_CONFIG.maxTurns,
+    cwd,
+    allowedTools = DEFAULT_CONFIG.allowedTools,
+    disallowedTools,
+    permissionMode = DEFAULT_CONFIG.permissionMode,
+    customSystemPrompt,
+    appendSystemPrompt,
+    resumeSessionId
+  } = config;
+  return {
+    name: "Claude Agent SDK",
+    async process(command, systemPrompt, _history) {
+      const sdk = await getSDK(), { query } = sdk, fullPrompt = systemPrompt ? `${systemPrompt}
+
+User request: ${command}` : command, options = {
+        allowedTools,
+        permissionMode,
+        maxTurns
+      };
+      if (disallowedTools)
+        options.disallowedTools = disallowedTools;
+      if (customSystemPrompt)
+        options.customSystemPrompt = customSystemPrompt;
+      if (appendSystemPrompt)
+        options.appendSystemPrompt = appendSystemPrompt;
+      if (cwd)
+        options.cwd = cwd;
+      if (resumeSessionId || sdkState.lastSessionId)
+        options.resume = resumeSessionId || sdkState.lastSessionId;
+      let result = "";
+      try {
+        for await (const message of query({ prompt: fullPrompt, options })) {
+          if (message.type === "system" && message.subtype === "init")
+            sdkState.lastSessionId = message.session_id;
+          if ("result" in message && typeof message.result === "string")
+            result = message.result;
+        }
+        return result || "No response from Claude Agent SDK";
+      } catch (error) {
+        const err = error;
+        if (err.message.includes("ANTHROPIC_API_KEY"))
+          throw Error("Claude Agent SDK requires ANTHROPIC_API_KEY environment variable or Claude Code authentication.");
+        throw Error(`Claude Agent SDK error: ${err.message}`);
+      }
+    },
+    async* stream(command, systemPrompt, _history) {
+      const sdk = await getSDK(), { query } = sdk, fullPrompt = systemPrompt ? `${systemPrompt}
+
+User request: ${command}` : command, options = {
+        allowedTools,
+        permissionMode,
+        maxTurns
+      };
+      if (disallowedTools)
+        options.disallowedTools = disallowedTools;
+      if (customSystemPrompt)
+        options.customSystemPrompt = customSystemPrompt;
+      if (appendSystemPrompt)
+        options.appendSystemPrompt = appendSystemPrompt;
+      if (cwd)
+        options.cwd = cwd;
+      if (resumeSessionId || sdkState.lastSessionId)
+        options.resume = resumeSessionId || sdkState.lastSessionId;
+      try {
+        for await (const message of query({ prompt: fullPrompt, options })) {
+          if (message.type === "system" && message.subtype === "init")
+            sdkState.lastSessionId = message.session_id;
+          if (message.type === "assistant") {
+            const assistantMsg = message;
+            if (assistantMsg.message?.content) {
+              for (const block of assistantMsg.message.content)
+                if (block.type === "text" && block.text)
+                  yield block.text;
+            }
+          }
+          if ("result" in message && typeof message.result === "string")
+            yield message.result;
+        }
+      } catch (error) {
+        const err = error;
+        if (err.message.includes("ANTHROPIC_API_KEY"))
+          throw Error("Claude Agent SDK requires ANTHROPIC_API_KEY environment variable or Claude Code authentication.");
+        throw Error(`Claude Agent SDK error: ${err.message}`);
+      }
+    }
+  };
+}
+export async function processStreaming(command, cwd, config = {}) {
+  const sdk = await getSDK(), { query } = sdk, {
+    maxTurns = DEFAULT_CONFIG.maxTurns,
+    allowedTools = DEFAULT_CONFIG.allowedTools,
+    disallowedTools,
+    permissionMode = DEFAULT_CONFIG.permissionMode,
+    customSystemPrompt,
+    appendSystemPrompt,
+    resumeSessionId
+  } = config, options = {
+    allowedTools,
+    permissionMode,
+    maxTurns
+  };
+  if (disallowedTools)
+    options.disallowedTools = disallowedTools;
+  if (customSystemPrompt)
+    options.customSystemPrompt = customSystemPrompt;
+  if (appendSystemPrompt)
+    options.appendSystemPrompt = appendSystemPrompt;
+  if (cwd)
+    options.cwd = cwd;
+  if (resumeSessionId || sdkState.lastSessionId)
+    options.resume = resumeSessionId || sdkState.lastSessionId;
+  const encoder = new TextEncoder;
+  let fullResponse = "", resolveFullResponse;
+  const fullResponsePromise = new Promise((resolve) => {
+    resolveFullResponse = resolve;
+  });
+  return {
+    stream: new ReadableStream({
+      async start(controller) {
+        try {
+          for await (const message of query({ prompt: command, options })) {
+            if (message.type === "system" && message.subtype === "init")
+              sdkState.lastSessionId = message.session_id;
+            if (message.type === "assistant") {
+              const assistantMsg = message;
+              if (assistantMsg.message?.content) {
+                for (const block of assistantMsg.message.content)
+                  if (block.type === "text" && block.text) {
+                    fullResponse += block.text;
+                    controller.enqueue(encoder.encode(block.text));
+                  }
+              }
+            }
+            if ("result" in message && typeof message.result === "string") {
+              if (!fullResponse) {
+                fullResponse = message.result;
+                controller.enqueue(encoder.encode(message.result));
+              }
+            }
+          }
+          resolveFullResponse(fullResponse);
+          controller.close();
+        } catch (error) {
+          resolveFullResponse(fullResponse);
+          controller.error(error);
+        }
+      }
+    }),
+    fullResponse: fullResponsePromise
+  };
+}
+export async function resumeSession(sessionId, prompt) {
+  const sdk = await getSDK(), { query } = sdk;
+  let result = "";
+  for await (const message of query({
+    prompt,
+    options: {
+      resume: sessionId,
+      permissionMode: "bypassPermissions"
+    }
+  }))
+    if ("result" in message && typeof message.result === "string")
+      result = message.result;
+  return result || "No response from resumed session";
+}
+export function getLastSessionId() {
+  return sdkState.lastSessionId;
+}
+export function clearSession() {
+  sdkState.lastSessionId = void 0;
+}
+export const claudeAgentSDK = {
+  createDriver: createClaudeAgentSDKDriver,
+  processStreaming,
+  resumeSession,
+  getLastSessionId,
+  clearSession
+};
+export default claudeAgentSDK;

package/dist/drivers/index.d.ts

@@ -0,0 +1,13 @@
+export type { AnthropicDriverConfig } from './anthropic/index';
+export type { OpenAIDriverConfig } from './openai/index';
+export type { OllamaDriverConfig } from './ollama/index';
+export type { ClaudeAgentSDKConfig } from './claude-agent-sdk/index';
+/**
+ * AI Drivers
+ *
+ * Export all available AI drivers.
+ */
+export { createAnthropicDriver, anthropicDriver, anthropic, estimateTokens } from './anthropic/index';
+export { createOpenAIDriver, openaiDriver, openai } from './openai/index';
+export { createOllamaDriver, ollamaDriver, ollama } from './ollama/index';
+export { createClaudeAgentSDKDriver, claudeAgentSDK, getLastSessionId, clearSession } from './claude-agent-sdk/index';

package/dist/drivers/index.js

@@ -0,0 +1,4 @@
+export { createAnthropicDriver, anthropicDriver, anthropic, estimateTokens } from "./anthropic";
+export { createOpenAIDriver, openaiDriver, openai } from "./openai";
+export { createOllamaDriver, ollamaDriver, ollama } from "./ollama";
+export { createClaudeAgentSDKDriver, claudeAgentSDK, getLastSessionId, clearSession } from "./claude-agent-sdk";

package/dist/drivers/ollama/index.d.ts

@@ -0,0 +1,93 @@
+import type { AIDriver, AIDriverConfig, AIMessage, AIResult, ChatCompletionOptions } from '../../types';
+/**
+ * Configure Ollama globally
+ */
+export declare function configure(config: OllamaDriverConfig): void;
+export declare function createOllamaDriver(config?: OllamaDriverConfig): AIDriver;
+/**
+ * Chat completion with full options
+ */
+export declare function chat(messages: AIMessage[], options?: ChatCompletionOptions): Promise<AIResult>;
+/**
+ * Stream chat completion
+ */
+export declare function streamChat(messages: AIMessage[], options?: ChatCompletionOptions): AsyncGenerator<string>;
+/**
+ * Generate text completion (non-chat)
+ */
+export declare function generate(prompt: string, options?: {
+    model?: string
+    system?: string
+    template?: string
+    context?: number[]
+    raw?: boolean
+    format?: 'json'
+    images?: string[]
+  }): Promise<AIResult>;
+/**
+ * Create embeddings
+ */
+export declare function embed(input: string | string[], model?: string): Promise<number[] | number[][]>;
+/**
+ * List available models
+ */
+export declare function listModels(): Promise<Array<{
+  name: string
+  modified_at: string
+  size: number
+  digest: string
+  details: {
+    format: string
+    family: string
+    families: string[]
+    parameter_size: string
+    quantization_level: string
+  }
+}>>;
+/**
+ * Pull a model from the library
+ */
+export declare function pullModel(name: string, onProgress?: (status: string, completed?: number, total?: number) => void): Promise<void>;
+/**
+ * Delete a model
+ */
+export declare function deleteModel(name: string): Promise<void>;
+/**
+ * Show model information
+ */
+export declare function showModel(_name: string): Promise<{
+  modelfile: string
+  parameters: string
+  template: string
+  details: {
+    format: string
+    family: string
+    families: string[]
+    parameter_size: string
+    quantization_level: string
+  }
+}>;
+/**
+ * Check if Ollama is running
+ */
+export declare function isRunning(): Promise<boolean>;
+export declare const ollamaDriver: { create: typeof createOllamaDriver };
+export declare const ollama: {
+  configure: typeof configure;
+  chat: typeof chat;
+  streamChat: typeof streamChat;
+  generate: typeof generate;
+  embed: typeof embed;
+  listModels: typeof listModels;
+  pullModel: typeof pullModel;
+  deleteModel: typeof deleteModel;
+  showModel: typeof showModel;
+  isRunning: typeof isRunning;
+  createDriver: unknown
+};
+export declare interface OllamaDriverConfig extends AIDriverConfig {
+  host?: string
+  model?: string
+  embeddingModel?: string
+}
+export default ollama;