agent-accelerator 0.1.0 → 0.3.0

package/src/index.ts

@@ -9,21 +9,49 @@ export type { CreateToolOptions } from "./tools/tool.ts";
 export { zodToJsonSchema, cleanJsonSchema } from "./tools/schema.ts";
 export { executeToolCalls } from "./tools/executor.ts";
 
+// Client-side document conversion (optional anydoc peer — see utils/documents.ts)
+export {
+  convertDocumentToMarkdown,
+  convertDocumentInput,
+  convert_document_to_markdown,
+  isAnydocAvailable,
+  resolveDocumentFormat,
+  truncateMarkdown,
+  buildDocumentXml,
+  modelSupportsFileInput,
+  preprocessFilePartsForBypass,
+  DocumentConversionError,
+  DEFAULT_DOCUMENT_MAX_CHARS,
+  MAX_DOCUMENT_FETCH_BYTES,
+} from "./utils/documents.ts";
+export type { ConvertDocumentOptions, ConvertedDocument } from "./utils/documents.ts";
+
 // Multi-Agent Delegation & Tools
 export {
   buildAgentTools,
+  agentToTool,
   createSubagentSpawnTool,
+  createChildSessionId,
+  createFixedChildSessionId,
+  isSessionDescendant,
+  getSubAgentTrace,
+  listSubAgentTraceIds,
+  subscribeToSubAgent,
 } from "./agent/delegation.ts";
-export type { DynamicSubagentTask } from "./agent/delegation.ts";
+export type { DynamicSubagentTask, AgentAsToolTarget, SubAgentTrace } from "./agent/delegation.ts";
 
-// Providers & Registry — unified multi-provider layer powered by Vercel AI SDK
+// Providers & Registry — unified multi-provider layer, all native REST
 export {
   getProvider,
   resolveModel,
   ModelProvider,
   ensureCustomProvider,
   normalizeProviderPrefix,
-} from "./ai-sdk/registry.ts";
+} from "./providers/registry.ts";
+export type {
+  ModelProviderInstance,
+  ModelProviderConfig,
+} from "./providers/registry.ts";
 export {
   getModelFromCatalog,
   getModelThinkingInfo,
@@ -37,48 +65,78 @@ export {
   getCatalogTTL,
   getCacheDir,
   getCacheFilePath,
+  isValidCatalogPayload,
+  createGenericModelSpec,
   DEFAULT_CATALOG_TTL_MS,
   type CatalogStatus,
   type RefreshCatalogOptions,
 } from "./models/catalog.ts";
-export { AiSdkBaseProvider as BaseProvider } from "./ai-sdk/model-provider.ts";
+export { resolveEffectiveThinking } from "./agent/agent.ts";
+export { withRetries, isTransientError } from "./utils/retry.ts";
+export { toConciseProviderError, assertModalitiesSupported, assertNoVideoPartsOnResponses } from "./utils/errors.ts";
+// Native provider implementations. `openrouter-responses.ts` (discontinued
+// beta-Responses transport) stays importable directly but is wired nowhere.
 export {
-  mapThinkingToReasoning,
-  resolveEffectiveThinking,
-  mapToolChoice,
-  mapThinkingToProviderOptions,
-  mapServiceTierToProviderOptions,
-  mapCacheToProviderOptions,
-  buildAiSdkCallOptions,
-  withAiSdkRetries,
-  isTransientAiSdkError,
-} from "./ai-sdk/options.ts";
-export { toConciseProviderError, assertModalitiesSupported } from "./ai-sdk/errors.ts";
-
-// Provider Implementations powered by Vercel AI SDK
-export {
-  GoogleAIStudioProvider,
-  GoogleAiSdkProvider,
-  OpenCodeProvider,
-  OpenCodeAiSdkProvider,
-  OpenRouterProvider,
-  OpenRouterAiSdkProvider,
-  OpenAIProvider,
-  OpenAiAiSdkProvider,
-  OpenAICompatibleProvider,
-  CustomAiSdkProvider,
-  AiSdkBaseProvider,
+  OpenAICompatibleChatProvider,
+  OpenAICompatibleChatProvider as OpenAICompatibleProvider,
   createOpenAICompatibleProvider,
   createCustomProvider,
   CustomProvider,
-  createGenericModelSpec,
-} from "./ai-sdk/model-provider.ts";
-export type { CustomProviderOptions } from "./ai-sdk/model-provider.ts";
+} from "./providers/openai-compat.ts";
+export type { CustomProviderOptions } from "./providers/openai-compat.ts";
+
+// Canonical provider contract (provider-agnostic) + native adapters.
+export {
+  GoogleInteractionsProvider,
+  GoogleInteractionsProvider as GoogleAIStudioProvider,
+  clearInteractionChains,
+} from "./providers/google.ts";
+export {
+  OpenRouterChatCompletionsProvider,
+  OpenRouterChatCompletionsProvider as OpenRouterProvider,
+} from "./providers/openrouter.ts";
+// Discontinued beta-Responses transport, retained frozen as migration
+// evidence (importable via `./providers/openrouter-responses.ts`, not wired
+// anywhere): OpenRouterResponsesProvider.
+export {
+  OpenAIResponsesProvider,
+  OpenAIResponsesProvider as OpenAIProvider,
+} from "./providers/openai.ts";
+export {
+  emitProviderWarning,
+  clearEmittedWarnings,
+  noteProviderTurn,
+  lastProviderFor,
+  isMixedProviderSession,
+  clearSessionRouting,
+  mapThinkingLevelToGoogle,
+  mapServiceTierToGoogle,
+  applyCacheForGoogle,
+  mapThinkingLevelToOpenRouter,
+  mapServiceTierToOpenRouter,
+  applyCacheForOpenRouter,
+  mapToolChoiceToOpenRouter,
+  mapThinkingLevelToOpenRouterChat,
+  mapToolChoiceToOpenRouterChat,
+  mapThinkingLevelToOpenAI,
+  mapServiceTierToOpenAI,
+  applyCacheForOpenAI,
+  applyCacheForCustom,
+  mapToolChoiceToOpenAI,
+  normalizeToolChoice,
+  parseStreamedToolArguments,
+} from "./providers.ts";
+export type {
+  ProviderCapabilityStatus,
+  CanonicalToolChoiceMode,
+  OpenRouterToolChoice,
+  OpenRouterChatToolChoice,
+  OpenAIToolChoice,
+} from "./providers.ts";
 
 export {
   GOOGLE_MODELS,
   OPENAI_MODELS,
-  OPENCODE_MODELS,
   OPENROUTER_MODELS,
 } from "./models/catalog.ts";
 
@@ -101,14 +159,6 @@ export type {
   CachedContentMetadata,
 } from "./utils/cache.ts";
 
-
-export {
-  countTokens,
-  estimateTokensFromText,
-  estimateTokensFromMessage,
-  estimateTokensFromPart,
-} from "./tokens/counter.ts";
-
 // Streaming & Events
 export { AssistantMessageEventStream } from "./streaming/event-stream.ts";
 export { SSEParser } from "./streaming/sse-parser.ts";
@@ -116,13 +166,37 @@ export { SSEParser } from "./streaming/sse-parser.ts";
 // Responses
 export { AgentResponse } from "./types/response.ts";
 
+// Session persistence & telemetry (conversation history + cost rollup)
+export {
+  SessionTelemetry,
+  loadSessionFile,
+  saveSessionFile,
+  loadSessionDir,
+  saveSessionDir,
+  writeFileAtomic,
+  findLatestSessionDir,
+  sessionDirFor,
+  extractMediaToDir,
+  resolveMediaPaths,
+  buildSessionData,
+  serializeSession,
+  deserializeSession,
+  getSessionContextWindow,
+  computeSessionTurnCost,
+  formatSessionTokens,
+  formatSessionCost,
+  formatSessionBanner,
+  emptyTotals,
+} from "./session/store.ts";
+export type { PersistedAgentSession, SessionTotals, SessionAgentLike, LoadedSessionDir, PersistedSubAgentTrace } from "./session/store.ts";
+
 // Utilities
-export { createSessionId } from "./utils/session.ts";
+export { createSessionId, hashSessionPart, createTrackingId } from "./utils/session.ts";
 export { getApiKey, getEnv } from "./utils/env.ts";
 export { buildSessionHeaders } from "./utils/headers.ts";
 export { normalizeMediaInput, inferMimeType } from "./utils/media.ts";
 export { base64ToBytes, bytesToBase64 } from "./utils/base64.ts";
-export { toJsonSafe, safeStringify } from "./utils/serialization.ts";
+export { toJsonSafe, safeStringify, escapeXml } from "./utils/serialization.ts";
 
 // Re-export Zod
 export { z };
@@ -174,6 +248,7 @@ export type {
 export type {
   AgentResponseJSON,
   SubAgentExecutionMetadata,
+  SubAgentStep,
   StreamEvent,
   StreamEventType,
 } from "./types/response.ts";
@@ -181,10 +256,52 @@ export type {
 export type {
   AgentConfig,
   AgentRunOptions,
+  AgentTurnEvent,
   DynamicSubagentsConfig,
 } from "./types/agent.ts";
 
+ // Provider wire payload types (back-compat inspection of raw requests/responses,
+// e.g. `res.raw.request.body as OpenAIChatCompletionRequest`).
+// NOTE: wire `OpenAIToolChoice` intentionally omitted — it duplicates the
+// canonical `OpenAIToolChoice` exported above (same shape); use that one.
 export type {
-  ModelProviderInstance,
-  ModelProviderConfig,
-} from "./ai-sdk/registry.ts";
+  GoogleThinkingLevel,
+  GoogleThinkingConfig,
+  GoogleFunctionCallingMode,
+  GoogleFunctionCallingConfig,
+  GoogleToolConfig,
+  GoogleFunctionDeclaration,
+  GoogleTool,
+  GoogleBlob,
+  GooglePart,
+  GoogleContent,
+  GoogleGenerationConfig,
+  GoogleCandidate,
+  GoogleUsageMetadata,
+  GoogleGenerateContentRequest,
+  GoogleGenerateContentResponse,
+  OpenRouterProviderRouting,
+  OpenRouterReasoning,
+  OpenRouterParameters,
+  OpenRouterUsage,
+  OpenRouterChatRequest,
+  OpenRouterResponse,
+  OpenAIMessageRole,
+  OpenAIReasoningEffort,
+  OpenAIServiceTier,
+  OpenAITextPart,
+  OpenAIImageUrlPart,
+  OpenAIInputAudioPart,
+  OpenAIVideoUrlPart,
+  OpenAIContentPart,
+  OpenAIToolCall,
+  OpenAIMessage,
+  OpenAITool,
+  OpenAIUsage,
+  OpenAIChoice,
+  OpenAIDelta,
+  OpenAIChunkChoice,
+  OpenAIChatCompletionRequest,
+  OpenAIChatCompletionResponse,
+  OpenAIChatCompletionChunk,
+} from "./types/provider-payloads.ts";

package/src/models/catalog-cache.ts

@@ -1,5 +1,6 @@
 import * as path from "node:path";
 import * as fs from "node:fs";
+import { getEnv } from "../utils/env.ts";
 
 /** Default TTL: 12 Hours (in milliseconds). */
 export const DEFAULT_CATALOG_TTL_MS = 12 * 60 * 60 * 1000;
@@ -65,14 +66,20 @@ function notifyUpdateListeners(): void {
   }
 }
 
-/** Non-configurable cache directory: src/data */
+/**
+ * Catalog cache directory. Defaults to `src/data` (repo convention); override
+ * with `AGENT_CACHE_DIR` when embedding as a package or running on a
+ * read-only filesystem (serverless/containers).
+ */
 export function getCacheDir(): string {
+  const override = getEnv("AGENT_CACHE_DIR");
+  if (override && override.trim()) return path.resolve(override.trim());
   return path.resolve(process.cwd(), "src/data");
 }
 
-/** Non-configurable cache file path: src/data/models-cache.json */
+/** Non-configurable cache file path: src/data/models.dev.json */
 export function getCacheFilePath(): string {
-  return path.resolve(process.cwd(), "src/data/models-cache.json");
+  return path.resolve(process.cwd(), "src/data/models.dev.json");
 }
 
 function readJsonFileSync(filePath: string): any {
@@ -99,7 +106,7 @@ let activeFetchedAt: number | undefined = undefined;
 let activeTtlMs: number = globalCatalogTtlMs;
 let activeFromCache = false;
 
-// Synchronous bootstrap: load from src/data/models-cache.json if present
+// Synchronous bootstrap: load from src/data/models.dev.json if present
 function initializeCatalogSync(): void {
   const cachePath = getCacheFilePath();
   const cached = readJsonFileSync(cachePath);
@@ -165,9 +172,30 @@ export function getCatalogStatus(): CatalogStatus {
   };
 }
 
+/**
+ * Structural check for a models.dev catalog payload: a map of provider ids
+ * to entries that each carry a `models` map. Rejects chat-completion
+ * payloads, error envelopes, and other non-catalog JSON (e.g. from mocked
+ * `fetch` in tests) BEFORE they can overwrite the good on-disk cache.
+ */
+export function isValidCatalogPayload(data: unknown): data is Record<string, any> {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return false;
+  const entries = Object.entries(data as Record<string, unknown>);
+  if (entries.length < 3) return false;
+  let providersWithModels = 0;
+  for (const [, value] of entries) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+    const models = (value as Record<string, unknown>).models;
+    if (!models || typeof models !== "object" || Array.isArray(models)) return false;
+    if (Object.keys(models).length > 0) providersWithModels++;
+  }
+  // Guard against degenerate-but-shaped payloads (e.g. `{a:{models:{}}}`).
+  return providersWithModels >= 3;
+}
+
 /**
  * Refreshes the model catalog by downloading from models.dev
- * directly into src/data/models-cache.json with a 12-hour TTL.
+ * directly into src/data/models.dev.json with a 12-hour TTL.
  */
 export async function refreshModelCatalog(options: RefreshCatalogOptions = {}): Promise<CatalogStatus> {
   const effectiveTtl = options.ttlMs ?? globalCatalogTtlMs;
@@ -211,6 +239,21 @@ export async function refreshModelCatalog(options: RefreshCatalogOptions = {}):
     }
 
     freshData = (await res.json()) as Record<string, any>;
+
+    // Never let a non-catalog payload (mocked fetch, proxy error page,
+    // chat-completion stub) overwrite the good on-disk cache.
+    if (!isValidCatalogPayload(freshData)) {
+      clearTimeout(timer);
+      const existing = readJsonFileSync(cachePath);
+      if (existing && existing.data) {
+        activeCatalog = existing.data;
+        activeFetchedAt = existing.fetchedAt;
+        activeTtlMs = existing.ttlMs || effectiveTtl;
+        activeFromCache = true;
+        notifyUpdateListeners();
+      }
+      return getCatalogStatus();
+    }
   } catch (err: any) {
     clearTimeout(timer);
     // If download fails, retain disk cache if available
@@ -236,15 +279,23 @@ export async function refreshModelCatalog(options: RefreshCatalogOptions = {}):
     data: freshData,
   };
 
-  // Save to src/data/models-cache.json
-  writeJsonFileSync(cachePath, cachePayload);
-
-  // Update in-memory state
+  // Update in-memory state FIRST so a read-only filesystem still serves the
+  // fresh catalog for this process; disk persistence below is best-effort.
   activeCatalog = freshData;
   activeFetchedAt = fetchedAt;
   activeTtlMs = effectiveTtl;
   activeFromCache = true;
 
+  // Save to src/data/models.dev.json (or the AGENT_CACHE_DIR override)
+  try {
+    writeJsonFileSync(cachePath, cachePayload);
+  } catch (err) {
+    activeFromCache = false;
+    console.warn(
+      `[Agent Accelerator] Could not write model catalog cache to ${cachePath} (${err instanceof Error ? err.message : String(err)}). Continuing with the in-memory catalog.`
+    );
+  }
+
   notifyUpdateListeners();
   return getCatalogStatus();
 }

package/src/models/catalog.ts

@@ -22,12 +22,10 @@ import type { ThinkingLevel } from "../types/core.ts";
 
 // ---------------------------------------------------------------------------
 // Provider aliases — maps our internal ids to models.dev keys
-// battle-tested: opencode covers zen/go, google covers vertex variants
+// battle-tested: google covers vertex variants
 // ---------------------------------------------------------------------------
 const PROVIDER_ALIASES: Record<string, string[]> = {
   google: ["google", "google-vertex", "google-vertex-anthropic"],
-  opencode: ["opencode", "opencode-go"],
-  "opencode-go": ["opencode-go", "opencode"],
   openrouter: ["openrouter"],
   openai: ["openai"],
 };
@@ -42,6 +40,11 @@ const MODALITY_OVERRIDES: Record<string, { input?: string[]; output?: string[] }
   // verified end-to-end via examples/08. If routing changes, the runtime
   // 404 still surfaces as a one-line error.
   "openrouter/nvidia/nemotron-3.5-lightning:free": { input: ["text", "pdf"] },
+  // Live-verified 2026-09-24: `stealth/space-bunny-alpha` accepts PDF
+  // `input_file` over Responses and PDFs via the file-parser plugin over Chat
+  // Completions (Berkshire letter + sample-files PDF both completed), though
+  // models.dev lists text/image/video only.
+  "openrouter/stealth/space-bunny-alpha": { input: ["text", "image", "video", "pdf"] },
 };
 
 function applyModalityOverrides(provider: string, modelId: string, base: ModelModalities): ModelModalities {
@@ -241,7 +244,7 @@ export function getModelThinkingInfo(provider: string, modelId: string): ModelTh
   if (!spec) {
     return {
       supportsThinking: true,
-      allowedLevels: ["none", "minimal", "low", "medium", "high", "xhigh", "dynamic"],
+      allowedLevels: ["none", "minimal", "low", "medium", "high", "xhigh", "max", "dynamic"],
       supportsDisable: true,
       description: "Model not found in catalog; generic thinking levels allowed.",
     };
@@ -292,6 +295,7 @@ export function getModelThinkingInfo(provider: string, modelId: string): ModelTh
     allowed.add("medium");
     allowed.add("high");
     allowed.add("xhigh");
+    allowed.add("max");
   }
 
   // Fixed reasoning model (no reasoning_options) e.g. DeepSeek-R1, QwQ-32B
@@ -305,6 +309,11 @@ export function getModelThinkingInfo(provider: string, modelId: string): ModelTh
     };
   }
 
+  // "dynamic" means server default (the level is omitted from the request),
+  // so it is expressible on every configurable thinking model regardless of
+  // which concrete effort/toggle/budget options the catalog lists.
+  allowed.add("dynamic");
+
   const allowedLevels = Array.from(allowed);
   const supportsDisable = allowed.has("none") || !!toggleOpt || Boolean(budgetOpt && (budgetOpt.min === undefined || budgetOpt.min <= 0));
 
@@ -437,7 +446,7 @@ export function validateModelThinking(provider: string, modelId: string, request
 
 // ---------------------------------------------------------------------------
 // getModelsForProvider — battle-tested view for BaseProvider.models
-// Opencode total context length now comes from catalog, not stale hardcoded file.
+// Total context length now comes from catalog, not stale hardcoded file.
 // ---------------------------------------------------------------------------
 /**
  * Returns normalized catalog specs for a provider and its configured aliases.
@@ -466,7 +475,6 @@ export function getModelsForProvider(provider: string): ModelSpec[] {
 
 export const GOOGLE_MODELS: ModelSpec[] = [...getModelsForProvider("google")];
 export const OPENAI_MODELS: ModelSpec[] = [...getModelsForProvider("openai")];
-export const OPENCODE_MODELS: ModelSpec[] = [...getModelsForProvider("opencode")];
 export const OPENROUTER_MODELS: ModelSpec[] = [...getModelsForProvider("openrouter")];
 
 function refreshExportedModels(): void {
@@ -474,8 +482,6 @@ function refreshExportedModels(): void {
   GOOGLE_MODELS.push(...getModelsForProvider("google"));
   OPENAI_MODELS.length = 0;
   OPENAI_MODELS.push(...getModelsForProvider("openai"));
-  OPENCODE_MODELS.length = 0;
-  OPENCODE_MODELS.push(...getModelsForProvider("opencode"));
   OPENROUTER_MODELS.length = 0;
   OPENROUTER_MODELS.push(...getModelsForProvider("openrouter"));
 }
@@ -497,7 +503,48 @@ export {
   getCatalogTTL,
   getCacheDir,
   getCacheFilePath,
+  isValidCatalogPayload,
   DEFAULT_CATALOG_TTL_MS,
   type CatalogStatus,
   type RefreshCatalogOptions,
 } from "./catalog-cache.ts";
+
+/**
+ * Permissive placeholder so custom endpoints never fail preflight:
+ * allows every ThinkingLevel (none -> max + dynamic).
+ * @example `const spec = createGenericModelSpec("groq", "llama-3.3-70b-versatile");`
+ */
+export function createGenericModelSpec(provider: string, modelId: string): ModelSpec {
+  const clean = modelId.includes("/") ? modelId.split("/").slice(1).join("/") : modelId;
+  return {
+    id: clean,
+    provider: provider as ProviderId,
+    name: clean,
+    contextWindow: 128000,
+    maxOutputTokens: 8192,
+    limit: { context: 128000, output: 8192 },
+    cost: {},
+    modalities: { input: ["text"], output: ["text"] },
+    reasoning: true,
+    reasoning_options: [
+      { type: "toggle" },
+      { type: "effort", values: ["minimal", "low", "medium", "high", "xhigh", "max"] },
+      { type: "budget_tokens", min: 0, max: 128000 },
+    ],
+    tool_call: true,
+    capabilities: {
+      supportsThinking: true,
+      supportsThinkingLevel: true,
+      supportsThinkingBudget: true,
+      supportsReasoningToggle: true,
+      supportsReasoningEffort: true,
+      supportsImplicitCaching: true,
+      supportsExplicitCaching: false,
+      supportsLongCacheRetention: false,
+      supportsParallelToolCalls: true,
+      supportsStreaming: true,
+      modalities: ["text"],
+    },
+    pricing: {},
+  };
+}