@stacksjs/ai 0.70.86 → 0.70.88

package/dist/text.d.ts

@@ -1,10 +0,0 @@
-export declare function summarize(text: string, options?: SummarizeOptions): Promise<string>;
-export declare function ask(question: string, options?: AskOptions): Promise<string>;
-declare interface AiOptions {
-  maxTokenCount?: number
-  temperature?: number
-  topP?: number
-  modelId?: string
-}
-export declare interface SummarizeOptions extends AiOptions {}
-export declare interface AskOptions extends AiOptions {}

package/dist/types.d.ts

@@ -1,185 +0,0 @@
-/**
- * AI Module Types
- *
- * Shared type definitions for AI drivers and agents.
- */
-export declare interface AIMessage {
-  role: 'user' | 'assistant' | 'system'
-  content: string | AIMessageContent[]
-}
-export declare interface AIMessageContent {
-  type: 'text' | 'image_url' | 'image'
-  text?: string
-  image_url?: { url: string, detail?: 'auto' | 'low' | 'high' }
-  source?: { type: 'base64', media_type: string, data: string }
-}
-export declare interface AIDriver {
-  name: string
-  process: (command: string, context: string, history: AIMessage[]) => Promise<string>
-  stream?: (command: string, context: string, history: AIMessage[]) => AsyncGenerator<string>
-  embed?: (input: string | string[]) => Promise<number[] | number[][]>
-}
-export declare interface AIDriverConfig {
-  apiKey?: string
-  baseUrl?: string
-  model?: string
-  maxTokens?: number
-}
-export declare interface StreamingResult {
-  stream: ReadableStream<Uint8Array>
-  fullResponse: Promise<string>
-}
-export declare interface EmbeddingResult {
-  embedding: number[]
-  index: number
-  object: string
-}
-export declare interface EmbeddingsResponse {
-  data: EmbeddingResult[]
-  model: string
-  usage: {
-    prompt_tokens: number
-    total_tokens: number
-  }
-}
-/**
- * Tool / function definition that the model can call back into.
- * Cross-provider shape: OpenAI's `tools[]` and Anthropic's `tools[]`
- * map to this same structure via the JSON Schema for parameters.
- */
-export declare interface AITool {
-  name: string
-  description?: string
-  parameters?: Record<string, unknown>
-}
-export declare interface ChatCompletionOptions {
-  model?: string
-  maxTokens?: number
-  temperature?: number
-  topP?: number
-  stop?: string | string[]
-  stream?: boolean
-  tools?: AITool[]
-  toolChoice?: 'auto' | 'required' | 'none' | { name: string }
-  responseFormat?: AIResponseFormat
-}
-export declare interface AIResult {
-  content: string
-  model: string
-  usage?: {
-    promptTokens: number
-    completionTokens: number
-    totalTokens: number
-  }
-  finishReason?: string
-}
-export declare interface ClaudeAPIResponse {
-  content: Array<{ type: string, text: string }>
-}
-export declare interface OpenAIAPIResponse {
-  choices: Array<{ message: { content: string } }>
-}
-export declare interface OllamaAPIResponse {
-  message: { content: string }
-}
-export declare interface ClaudeStreamEvent {
-  type: string
-  subtype?: string
-  message?: {
-    content: Array<{
-      type: string
-      text?: string
-      name?: string
-      input?: Record<string, unknown>
-    }>
-  }
-  delta?: { text?: string }
-  result?: string
-  index?: number
-  content_block?: {
-    type: string
-    text?: string
-  }
-}
-// Buddy Types
-export declare interface RepoState {
-  path: string
-  name: string
-  branch: string
-  hasChanges: boolean
-  lastCommit?: string
-}
-export declare interface GitHubCredentials {
-  token: string
-  username: string
-  name: string
-  email: string
-}
-export declare interface BuddyState {
-  repo: RepoState | null
-  conversationHistory: AIMessage[]
-  currentDriver: string
-  github: GitHubCredentials | null
-}
-export declare interface BuddyConfig {
-  workDir: string
-  commitMessage: string
-  ollamaHost: string
-  ollamaModel: string
-}
-export declare interface BuddyApiKeys {
-  anthropic?: string
-  openai?: string
-  claudeCliHost?: string
-}
-// Image types
-export declare interface ImageGenerationConfig {
-  provider: 'openai'
-  model?: string
-  apiKey?: string
-}
-// Search/RAG types
-export declare interface SearchConfig {
-  embeddingProvider: 'openai' | 'ollama'
-  embeddingModel?: string
-  generationProvider?: 'anthropic' | 'openai' | 'ollama'
-  generationModel?: string
-}
-// MCP types
-export declare interface MCPConfig {
-  servers: Array<{
-    name: string
-    command?: string
-    args?: string[]
-    url?: string
-    env?: Record<string, string>
-  }>
-}
-// AI module config (used by @stacksjs/config)
-export declare interface AIConfig {
-  default?: string
-  models?: string[]
-  drivers?: {
-    anthropic?: AIDriverConfig & { anthropicVersion?: string }
-    openai?: AIDriverConfig & { embeddingModel?: string }
-    ollama?: AIDriverConfig & { host?: string; embeddingModel?: string }
-  }
-  image?: ImageGenerationConfig
-  search?: SearchConfig
-  mcp?: MCPConfig
-}
-/**
- * Structured-output / JSON-mode response format. Modeled after
- * OpenAI's `response_format` but the Anthropic driver maps it to
- * the tools-as-json pattern internally (stacksjs/stacks#1878 A-1).
- */
-export type AIResponseFormat = | { type: 'text' }
-  | { type: 'json_object' }
-  | {
-      type: 'json_schema'
-      json_schema: {
-        name: string
-        schema: Record<string, unknown>
-        strict?: boolean
-      }
-    }

package/dist/utils/client-bedrock-runtime.d.ts

@@ -1,16 +0,0 @@
-import type { InvokeModelCommandInput, InvokeModelCommandOutput, InvokeModelWithResponseStreamCommandInput, InvokeModelWithResponseStreamCommandOutput } from '@stacksjs/ts-cloud/aws';
-export type { InvokeModelCommandInput, InvokeModelWithResponseStreamCommandInput };
-/*
- * Invoke Model
- * @param {InvokeModelCommandInput} params
- * @returns {Promise<InvokeModelCommandOutput>}
- * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/BedrockRuntime.html#invokeModel-property
- */
-export declare function invokeModel(params: InvokeModelCommandInput): Promise<InvokeModelCommandOutput>;
-/*
- * Invoke Model With Response Stream
- * @param {InvokeModelWithResponseStreamCommandInput} params
- * @returns {Promise<InvokeModelWithResponseStreamCommandOutput>}
- * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/BedrockRuntime.html#invokeModelWithResponseStream-property
- */
-export declare function invokeModelWithResponseStream(params: InvokeModelWithResponseStreamCommandInput): Promise<InvokeModelWithResponseStreamCommandOutput>;

package/dist/utils/client-bedrock.d.ts

@@ -1,27 +0,0 @@
-import type { CreateModelCustomizationJobCommandInput, CreateModelCustomizationJobCommandOutput, GetModelCustomizationJobCommandInput, GetModelCustomizationJobCommandOutput, ListFoundationModelsCommandInput, ListFoundationModelsCommandOutput } from '@stacksjs/ts-cloud/aws';
-export type {
-  CreateModelCustomizationJobCommandInput,
-  GetModelCustomizationJobCommandInput,
-  ListFoundationModelsCommandInput,
-};
-/*
- * Create Model Customization Job
- * @param {CreateModelCustomizationJobCommandInput} params
- * @returns {Promise<CreateModelCustomizationJobCommandOutput>}
- * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Bedrock.html#CreateModelCustomizationJob-property
- */
-export declare function createModelCustomizationJob(param: CreateModelCustomizationJobCommandInput): Promise<CreateModelCustomizationJobCommandOutput>;
-/*
- * Get Model Customization Job
- * @param {GetModelCustomizationJobCommandInput} params
- * @returns {Promise<GetModelCustomizationJobCommandOutput>}
- * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Bedrock.html#getModelCustomizationJob-property
- */
-export declare function getModelCustomizationJob(params: GetModelCustomizationJobCommandInput): Promise<GetModelCustomizationJobCommandOutput>;
-/*
- * List Foundation Models
- * @param {ListFoundationModelsCommandInput} params
- * @returns {Promise<ListFoundationModelsCommandOutput>}
- * @see https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Bedrock.html#listFoundationModels-property
- */
-export declare function listFoundationModels(params: ListFoundationModelsCommandInput): Promise<ListFoundationModelsCommandOutput>;

package/dist/utils/model-access.d.ts

@@ -1 +0,0 @@
-export declare function requestModelAccess(): Promise<void>;

package/dist/utils/retry.d.ts

@@ -1,38 +0,0 @@
-/**
- * Fetch with automatic retry on 429 / 5xx. Returns the final
- * `Response` — the caller checks `.ok` and parses the body as usual.
- *
- * Does NOT retry network-level errors (connection reset, DNS
- * failure) — those throw synchronously and the caller's existing
- * try/catch handles them.
- */
-export declare function fetchWithRetry(input: RequestInfo | URL, init?: RequestInit, config?: RetryConfig): Promise<Response>;
-/**
- * Retry helper for AI driver HTTP calls (stacksjs/stacks#1878 A-5).
- *
- * Background: OpenAI / Anthropic / etc. routinely return 429 (rate
- * limit) and 5xx (capacity / overloaded) responses with a
- * `Retry-After` header indicating when the caller should try again.
- * The pre-fix AI drivers threw immediately on any non-2xx, surfacing
- * transient capacity issues as hard user-facing failures.
- *
- * This helper wraps `fetch()` with:
- *   - Honor `Retry-After` (seconds or HTTP-date) for 429 + 503
- *   - Exponential backoff + jitter for other 5xx
- *   - Cap at `maxRetries` attempts (default 3)
- *   - Surface the final non-recoverable response to the caller
- *
- * No retry on 4xx other than 429 — those are caller bugs (bad API
- * key, malformed request) that won't clear with more retries.
- */
-/**
- * Configurable retry policy. Defaults are tuned for the typical
- * "Anthropic returned 429, try again in 3s" case without being so
- * aggressive that a permanent outage hangs the request loop for
- * minutes.
- */
-export declare interface RetryConfig {
-  maxRetries?: number
-  baseDelayMs?: number
-  maxDelayMs?: number
-}

package/dist/utils/tokens.d.ts

@@ -1,50 +0,0 @@
-/**
- * Estimate the number of tokens in `text` for the given model.
- * Heuristic only — for exact counts, use the provider's tokenizer.
- *
- * @example
- * ```ts
- * if (estimateTokens(prompt, 'gpt-4o') > 100_000) {
- *   throw new Error('prompt too long; consider chunking')
- * }
- * ```
- */
-export declare function estimateTokens(text: string, model?: string): number;
-/**
- * Estimate total tokens for a chat-completion request: sum of
- * every message's content plus a fixed per-message overhead
- * (matches the rough "+4 per message + 2 for the conversation"
- * heuristic OpenAI's docs publish).
- */
-export declare function estimateMessageTokens(messages: Array<{ role: string, content: string | unknown }>, model?: string): number;
-/**
- * Inspect `text` for common prompt-injection patterns. Returns
- * `{ ok, matched, cleaned }`. Apps decide what to do with the
- * result — reject the request (`if (!result.ok) throw...`), pass
- * the cleaned text on (`useText(result.cleaned)`), or just log
- * for audit while letting the original through.
- *
- * **Limits:** this is heuristic. Adversarial inputs can paraphrase
- * around any specific pattern. Use as a cheap first filter; for
- * real defense, isolate the user input from the system prompt
- * structurally (different roles, JSON-mode for the system layer)
- * and guard the output side too.
- *
- * @example
- * ```ts
- * const check = sanitizePrompt(userInput)
- * if (!check.ok) {
- *   log.warn('possible injection attempt', { patterns: check.matched })
- *   // option A: reject
- *   throw new HttpError(400, 'invalid input')
- *   // option B: pass cleaned
- *   await chat([{ role: 'user', content: check.cleaned }])
- * }
- * ```
- */
-export declare function sanitizePrompt(text: string): SanitizeResult;
-export declare interface SanitizeResult {
-  ok: boolean
-  matched: string[]
-  cleaned: string
-}

package/dist/utils/usage.d.ts

@@ -1,56 +0,0 @@
-/**
- * Register a usage reporter. Returns an `unregister` callback for
- * apps that want to swap reporters at runtime (test setup/teardown,
- * tenant isolation, etc.).
- */
-export declare function onUsage(reporter: UsageReporter): () => void;
-/**
- * Drop every registered reporter. Useful for tests.
- */
-export declare function clearUsageReporters(): void;
-/**
- * Emit a usage record to every registered reporter. Called by
- * driver completion paths after the response lands. Reporter
- * errors are caught + logged so a misbehaving sink doesn't
- * propagate up to the caller.
- */
-export declare function recordUsage(record: UsageRecord): void;
-/**
- * Snapshot the currently-registered reporters. Useful for tests
- * to assert behavior without exposing the internal array.
- */
-export declare function listUsageReporters(): readonly UsageReporter[];
-/**
- * AI usage tracking (stacksjs/stacks#1878 A-6).
- *
- * Background: `AIResult.usage` returns token counts per-call but
- * nothing aggregates them. Apps that want "this user has spent
- * $X this month" build the aggregation themselves — wiring a
- * listener on every model invocation, persisting the running
- * total, etc.
- *
- * This module ships a singleton recorder that drivers emit to on
- * each completion. Apps install one or more `UsageReporter`
- * functions that get called with `{ provider, model, prompt_tokens,
- * completion_tokens, timestamp, durationMs }` and decide what to
- * do (store to DB, push to Datadog, etc.). Default behavior with
- * no reporter is a no-op — the framework doesn't impose a sink.
- */
-export declare interface UsageRecord {
-  provider: string
-  model: string
-  promptTokens: number
-  completionTokens: number
-  totalTokens: number
-  durationMs: number
-  timestamp: number
-  metadata?: Record<string, unknown>
-}
-/**
- * A reporter is called once per recorded completion. Multiple
- * reporters can be installed simultaneously; they fire in
- * registration order. Reporters MUST NOT throw — errors are
- * caught and logged but otherwise ignored so a flaky metrics
- * sink doesn't break the user's completion call.
- */
-export type UsageReporter = (record: UsageRecord) => void | Promise<void>;

package/dist/utils/vision.d.ts

@@ -1,22 +0,0 @@
-import type { AIMessage, AIMessageContent } from '../types';
-/**
- * Normalize an entire `messages` array for the requested provider.
- * Messages whose `content` is a plain string pass through unchanged.
- * Messages with a content array get each block translated.
- */
-export declare function normalizeMessagesForProvider(messages: AIMessage[], provider: 'openai' | 'anthropic'): AIMessage[];
-/**
- * Convenience: convert a single command + optional image inputs into
- * an `AIMessage` content array suitable for `chat()` calls. Used by
- * the higher-level `text()` / `chat()` helpers when a user passes
- * `{ command, images }` together.
- *
- * @example
- * ```ts
- * const content = buildMessageWithImages('What is in this image?', [
- *   { url: 'https://example.com/cat.jpg' },
- * ])
- * await chat([{ role: 'user', content }])
- * ```
- */
-export declare function buildMessageWithImages(command: string, images: Array<{ url?: string, dataBase64?: string, mediaType?: string, detail?: 'auto' | 'low' | 'high' }>): AIMessageContent[];