@moikapy/origen 0.4.1 → 0.5.0

package/README.md

@@ -2,18 +2,28 @@
 
 > Multi-Provider Agent Engine — an agent harness, not a chatbot.
 
-Named after **Origen of Alexandria** (c. 185–254 AD) — the early church's greatest scholar. This package is the **generic** agent harness that wraps any LLM provider with tool calling, streaming, and Soul.md personas.
+Named after **Origen of Alexandria** (c. 185–254 AD) — the early church's greatest scholar. This package is a **generic** agent harness that wraps any LLM provider with tool calling, streaming, Soul.md personas, and Cloudflare D1 integration.
 
 **Domain-specific tools live in separate packages.** For Bible study, see `@moikapy/scholar-tools`.
 
-## Providers
+## Features
+
+- **Multi-provider**: OpenRouter, Ollama, Anthropic, Google, OpenAI, DeepSeek, Groq, xAI via `@mariozechner/pi-ai`
+- **Streaming first**: `streamOrigen()` yields typed events (reasoning, tool calls, text deltas, citations)
+- **Parallel tool execution**: Tools run concurrently by default; sequential mode available
+- **Soul.md personas**: Declarative persona definitions with profiles, moods, and voice tuning
+- **D1 integration**: Tools receive a `D1Provider` for Cloudflare D1 database access
+- **Provider-aware auth**: `getApiKey(provider)` resolves keys per-provider (OAuth PKCE, local Ollama, etc.)
+- **Abort support**: Pass `signal: AbortSignal` to cancel streaming mid-flight
+- **Citation extraction**: Pluggable `extractCitations` for domain-specific parsing
+- **Thinking models**: Automatic extended reasoning for DeepSeek R1, Claude Sonnet 4, Gemini 2.5 Flash
 
-Origen supports multiple LLM providers via `@mariozechner/pi-ai`:
+## Providers
 
 | Provider | Models | Auth |
 |---|---|---|
 | **OpenRouter** | 275+ models, free tier available | OAuth PKCE / API key |
-| **Ollama** | Llama 3, Gemma 3, Mistral, Qwen 3, DeepSeek R1 | Local (no key needed) |
+| **Ollama** | Llama 3, Gemma 3, Mistral, Qwen 3, DeepSeek R1, + any custom model | Local (no key needed) |
 | **Anthropic** | Claude Sonnet 4, etc. | API key |
 | **Google** | Gemini 2.5 Flash, etc. | API key |
 | **OpenAI** | GPT-4o, etc. | API key |
@@ -52,7 +62,6 @@ const config: AgentConfig = {
   tools: [myTool],
   getD1: async () => myD1Database,
   model: "openrouter/free",
-  // Provider-aware key resolution
   getApiKey: async (provider) => {
     if (provider === "ollama") return "ollama";
     return getOpenRouterKey();
@@ -73,14 +82,44 @@ for await (const event of streamOrigen(messages, context, config)) {
 
 ## Ollama Support
 
+### Static Model List
+
+Origen ships with hardcoded entries for popular Ollama models (Llama 3, Gemma 3, DeepSeek R1, etc.). These serve as fallbacks when Ollama isn't running.
+
+### Dynamic Discovery
+
+When Ollama is running, Origen can pull the full list of available models — including cloud models (`:cloud` suffix) — via `fetchOllamaModels()`:
+
+```typescript
+import { discoverOllamaModels, getModelsForUI } from "@moikapy/origen/models";
+
+// Fetch from Ollama, merge into MODELS registry, return combined map
+const allModels = await discoverOllamaModels("http://localhost:11434");
+console.log(allModels["ollama/llama3.2"]); // { name: "llama3.2 (3.2B)", description: "Local — 3.2B (Q4_K_M) requires Ollama", free: true }
+
+// Or do it in two steps for more control:
+import { fetchOllamaModels, mergeOllamaModels } from "@moikapy/origen/models";
+
+const discovered = await fetchOllamaModels("http://localhost:11434");
+// Filter, transform, or inspect before merging
+mergeOllamaModels(discovered);
+```
+
+**Key behaviors:**
+- Embedding models (e.g., `nomic-embed-text`) are automatically filtered out
+- Cloud models (tagged `:cloud`) are tagged as "Cloud" in their description
+- Reasoning model families (DeepSeek R1, Qwen3, etc.) are auto-detected
+- Network errors return empty results — no crash, just static fallbacks
+- 5-second timeout — won't block startup if Ollama is slow
+
+### Custom Models
+
+Use `ollama/<model-name>` and Origen constructs a generic OpenAI-compatible config pointing at your Ollama server:
+
 ```typescript
 const config: AgentConfig = {
-  model: "ollama/llama3",
+  model: "ollama/my-custom-finetune",
   ollamaBaseUrl: "http://localhost:11434/v1",
-  getApiKey: async (provider) => {
-    if (provider === "ollama") return "ollama"; // Ollama doesn't need a real key
-    return undefined;
-  },
   // ...
 };
 ```
@@ -100,21 +139,24 @@ console.log(concise.buildPrompt());            // Concise version
 
 ### Supported Soul.md Fields
 
-- **identity**: role, archetype, domain_focus, non_goals
-- **relationship**: stance, user_model_default, trust_baseline
-- **voice**: formality, warmth, verbosity, jargon, formatting, banned_phrases, preferred_phrases, emoji_policy
-- **interaction**: clarifying_questions, uncertainty, disagreement, confirmations
-- **cognition**: mode, depth, verification (fact_checking, cross_validation)
-- **safety**: refusal_style, privacy, speculation, no_fabrication, no_false_certainty
-- **actions**: when_to_use_tools, explain_actions, failover
-- **state**: dynamic moods with trigger-based transitions
-- **profiles**: named overlays (concise, scholarly, friendly, etc.)
-
-## API
+| Section | Fields |
+|---|---|
+| **identity** | role, archetype, domain_focus, non_goals |
+| **relationship** | stance, user_model_default, trust_baseline |
+| **voice** | formality, warmth, verbosity, jargon, formatting, banned_phrases, preferred_phrases, emoji_policy |
+| **interaction** | clarifying_questions, uncertainty, disagreement, confirmations |
+| **cognition** | mode, depth, verification (fact_checking, cross_validation) |
+| **safety** | refusal_style, privacy, speculation, no_fabrication, no_false_certainty |
+| **actions** | when_to_use_tools, explain_actions, failover |
+| **state** | dynamic moods with trigger-based transitions |
+| **profiles** | named overlays (concise, scholarly, friendly, etc.) |
+| **composition** | extends, mixins, merge_policy |
+
+## API Reference
 
 ### `streamOrigen(messages, context, config, apiKey?)`
 
-Async generator yielding `StreamEvent`s. Handles the full agent loop with parallel tool execution.
+Async generator yielding `StreamEvent`s. Handles the full agent loop with parallel tool execution. Events: `reasoning`, `tool_call`, `tool_result`, `text`, `done`, `error`.
 
 ### `callOrigen(messages, context, config, apiKey?)`
 
@@ -122,12 +164,20 @@ Non-streaming wrapper. Returns `{ message, citations, usage }`.
 
 ### `checkAuth(getApiKey)`
 
-Provider-aware auth check. Returns `{ authenticated, apiKey, provider, error? }`.
+Provider-aware auth check. Tries OpenRouter → Ollama → Anthropic. Returns `{ authenticated, apiKey, provider, error? }`.
 
 ### `checkOpenRouterAuth(getApiKey)`
 
 OpenRouter-only auth check (backward compat).
 
+### `resolveModel(modelId, options?)`
+
+Resolves a model ID string to a pi-ai `Model` object. Handles Ollama models, pi-ai registry lookups, and generic fallbacks.
+
+### `createEventStream(agent, extractCitations?)`
+
+Eagerly subscribes to an Agent and returns `{ stream, unsubscribe }`. Subscribes synchronously before `prompt()` to avoid race conditions.
+
 ## Configuration
 
 ```typescript
@@ -150,16 +200,111 @@ interface AgentConfig {
 ## Models
 
 ```typescript
-import { MODELS, DEFAULT_MODEL, THINKING_MODELS, supportsThinking, isOllamaModel } from "@moikapy/origen/models";
+import {
+  MODELS, DEFAULT_MODEL, THINKING_MODELS,
+  supportsThinking, isOllamaModel,
+  getModelsByProvider, getModelsForUI,
+  fetchOllamaModels, mergeOllamaModels, discoverOllamaModels,
+} from "@moikapy/origen/models";
 ```
 
-## What Changed (v0.3)
+### Built-in Model IDs
+
+| ID | Name | Free? |
+|---|---|---|
+| `openrouter/free` | Free (Auto) | ✅ |
+| `google/gemma-4-31b-it:free` | Gemma 4 31B | ✅ |
+| `nvidia/nemotron-3-super-120b-a12b:free` | Nemotron 3 Super | ✅ |
+| `deepseek/deepseek-r1:free` | DeepSeek R1 (Free) | ✅ |
+| `qwen/qwen3-coder:free` | Qwen3 Coder | ✅ |
+| `ollama/llama3` | Llama 3 (Ollama) | ✅ |
+| `ollama/llama3.1` | Llama 3.1 8B (Ollama) | ✅ |
+| `ollama/gemma3` | Gemma 3 (Ollama) | ✅ |
+| `ollama/mistral` | Mistral 7B (Ollama) | ✅ |
+| `ollama/qwen3` | Qwen 3 (Ollama) | ✅ |
+| `ollama/deepseek-r1` | DeepSeek R1 (Ollama) | ✅ |
+| `ollama/codellama` | Code Llama (Ollama) | ✅ |
+| `ollama/phi3` | Phi-3 (Ollama) | ✅ |
+| `openrouter/auto` | Auto (All) | ❌ |
+| `anthropic/claude-sonnet-4` | Claude Sonnet 4 | ❌ |
+| `google/gemini-2.5-flash-preview` | Gemini 2.5 Flash | ❌ |
+
+### Thinking Models
+
+Extended reasoning support for: `anthropic/claude-sonnet-4`, `deepseek/deepseek-r1:free`, `google/gemini-2.5-flash-preview`, `ollama/deepseek-r1`.
+
+### Dynamic Ollama Discovery
+
+Ollama models can be discovered at runtime from a running server:
+
+| Function | Description |
+|---|---|
+| `fetchOllamaModels(baseUrl?)` | Query Ollama `/api/tags`, return `Record<string, ModelConfig>` |
+| `mergeOllamaModels(models)` | Merge discovered models into the static `MODELS` registry |
+| `discoverOllamaModels(baseUrl?)` | One-shot: fetch + merge + return combined map |
+
+## Exports Map
+
+```json
+{
+  ".":           "Main entry — streamOrigen, callOrigen, checkAuth, MODELS, Soul, etc.",
+  "./models":    "MODELS registry, supportsThinking, isOllamaModel, getModelsByProvider",
+  "./soul":      "Soul class, loadSoul, SoulConfig types",
+  "./adapter":   "resolveModel, createEventStream, adaptTools, convertMessages"
+}
+```
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────┐
+│                    Your App                          │
+│  streamOrigen(messages, context, config)            │
+└────────┬──────────────┬─────────────────────────────┘
+         │              │
+    ┌────▼────┐    ┌─────▼──────┐
+    │ agent.ts│    │ adapter.ts │
+    │ Agent   │    │ Tool adapt │
+    │ loop    │    │ Model res. │
+    │ Auth    │    │ Event xlate│
+    └────┬────┘    └─────┬──────┘
+         │              │
+    ┌────▼──────────────▼────┐
+    │  pi-ai + pi-agent-core│
+    │  (LLM providers,     │
+    │   streaming, tools)   │
+    └───────────────────────┘
+```
 
+- **agent.ts** — Agent loop, auth checks, event types. Orchestrates `Agent` from pi-agent-core.
+- **adapter.ts** — Bridges Origen's simple types to pi-ai/pi-agent-core. Tool adaptation, model resolution, event translation, eager event stream.
+- **models.ts** — Model registry with UI-safe configs, thinking model detection, provider filtering.
+- **soul.ts** — Soul.md RFC-1 parser with YAML front matter, profile overlays, prompt generation.
+- **types.ts** — Zero-dependency types (D1Like, Citation, UsageInfo, ReadingContext).
+
+## Changelog
+
+### v0.5 (current)
+- **Dynamic Ollama discovery**: `fetchOllamaModels()`, `mergeOllamaModels()`, `discoverOllamaModels()` pull live models from Ollama's `/api/tags` endpoint
+- **Improved Ollama model catalog**: Added Llama 3.1, Mistral Nemo, Code Llama, Phi-3; updated context windows
+- **Ollama provider in resolveModel**: Now tries `ollama` in the pi-ai registry loop
+- **Exported `defaultCitationExtractor`**: Now importable for custom citation pipelines
+- **Reduced `as any` casts**: Replaced with documented type assertions where pi-ai generics are too narrow
+
+### v0.4
+- **Zod validation**: Optional `inputSchema` on `OrigenTool` for runtime parameter validation
+- **Qwen3 Coder**: Added `qwen/qwen3-coder:free` to model registry
+- **getModelsForUI()**: UI-safe model configs without internal fields
+- **getModelsByProvider()**: Filter models by provider prefix
+- **UIModelConfig type**: Stripped model config safe for client-side use
+
+### v0.3
 - **Multi-provider**: OpenRouter, Ollama, Anthropic, Google, DeepSeek, Groq, xAI via pi-ai
 - **Parallel tool execution**: Tools run concurrently by default
 - **Abort support**: Pass `signal: AbortSignal` to cancel streaming
 - **Soul.md personas**: Declarative persona definitions with profiles and moods
 - **Provider-aware auth**: `getApiKey(provider)` resolves keys per-provider
+- **Eager event stream**: `createEventStream()` subscribes before prompt to avoid race conditions
 - **No more hardcoded SSE parser**: Delegate to pi-ai + pi-agent-core
 
 ## License

package/dist/adapter-DXIT3O2f.d.ts

@@ -0,0 +1,209 @@
+import { Model, Api, Message, Context } from '@mariozechner/pi-ai';
+import { AgentTool, AgentEvent } from '@mariozechner/pi-agent-core';
+import { z } from 'zod';
+import { ModelId } from './models.js';
+
+/**
+ * Origen types — no runtime deps, safe for client + server.
+ */
+/** D1-compatible database interface for tool execution */
+interface D1Like {
+    prepare(sql: string): {
+        bind(...params: unknown[]): {
+            all(): Promise<{
+                results?: Record<string, unknown>[];
+            }>;
+            first(): Promise<Record<string, unknown> | null>;
+            run(): Promise<{
+                meta?: {
+                    changes: number;
+                    last_row_id: number;
+                };
+            }>;
+        };
+    };
+}
+/** Function that provides a D1 instance to tool executors */
+type D1Provider = () => Promise<D1Like>;
+/** Chat context passed from the UI (what the user is reading) */
+interface ReadingContext {
+    translation: string;
+    bookCode: string;
+    chapter: number;
+    selectedVerses?: number[];
+}
+interface Citation {
+    book: string;
+    chapter: number;
+    verse: number;
+}
+interface UsageInfo {
+    promptTokens?: number;
+    completionTokens?: number;
+    totalCost?: number;
+}
+/** Model configuration entry */
+interface ModelConfig {
+    name: string;
+    description: string;
+    free: boolean;
+}
+
+/**
+ * Origen — Agent Engine (v0.3)
+ *
+ * Multi-provider agent harness built on pi-ai + pi-agent-core.
+ * Supports OpenRouter, Ollama, Anthropic, Google, and any OpenAI-compatible API.
+ * Soul.md personas, streaming, parallel tool execution, abort support.
+ */
+
+/**
+ * A tool that the host app registers with Origen.
+ * Simple interface: name, description, JSON schema, and an execute function
+ * that receives (args, getD1). The adapter wraps this into pi-agent-core's AgentTool.
+ */
+interface OrigenTool {
+    name: string;
+    description: string;
+    /** OpenAI function-calling parameter schema (JSON) */
+    parameters: Record<string, unknown>;
+    /** Zod schema for runtime validation (optional) */
+    inputSchema?: z.ZodType;
+    execute: (args: Record<string, unknown>, getD1: D1Provider) => Promise<string>;
+}
+interface AgentConfig {
+    appName?: string;
+    systemPrompt?: string;
+    tools: OrigenTool[];
+    getD1: D1Provider;
+    model?: ModelId;
+    maxSteps?: number;
+    /** Custom citation extractor */
+    extractCitations?: (text: string) => Citation[];
+    /** Dynamic API key resolution per provider (e.g., for expiring OAuth tokens) */
+    getApiKey?: (provider: string) => Promise<string | undefined>;
+    /** Ollama base URL override (default: http://localhost:11434/v1) */
+    ollamaBaseUrl?: string;
+    /** Tool execution mode: "parallel" (default) or "sequential" */
+    toolExecution?: "sequential" | "parallel";
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+    /** Reasoning/thinking level for models that support it */
+    thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high";
+}
+interface AuthCheckResult {
+    authenticated: boolean;
+    apiKey: string | null;
+    provider?: string;
+    error?: string;
+}
+/**
+ * Provider-aware auth check. Tests key availability for each provider.
+ * If no provider argument, checks OpenRouter + Ollama availability.
+ */
+declare function checkAuth(getApiKey: ((provider: string) => Promise<string | undefined>) | (() => Promise<string | null>)): Promise<AuthCheckResult>;
+/** Convenience: check OpenRouter auth only (backward compat). */
+declare function checkOpenRouterAuth(getApiKey: () => Promise<string | null>): Promise<AuthCheckResult>;
+type StreamEvent = {
+    type: "reasoning";
+    content: string;
+} | {
+    type: "tool_call";
+    name: string;
+    args: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    name: string;
+    result: string;
+} | {
+    type: "text";
+    content: string;
+} | {
+    type: "done";
+    message: string;
+    citations: Citation[];
+    usage?: UsageInfo;
+} | {
+    type: "error";
+    message: string;
+};
+declare function streamOrigen(messages: Array<{
+    role: "user" | "assistant";
+    content: string;
+}>, context: Record<string, unknown> | undefined, config: AgentConfig, apiKey?: string): AsyncGenerator<StreamEvent>;
+interface AgentResponse {
+    message: string;
+    citations: Citation[];
+    usage?: UsageInfo;
+}
+declare function callOrigen(messages: Array<{
+    role: "user" | "assistant";
+    content: string;
+}>, context: Record<string, unknown> | undefined, config: AgentConfig, apiKey?: string): Promise<AgentResponse>;
+
+/**
+ * Adapter: bridges Origen's simple types to pi-agent-core/pi-ai types.
+ *
+ * - OrigenTool → AgentTool (injects D1Provider)
+ * - pi-ai Model resolution (OpenRouter, Ollama, Anthropic, Google)
+ * - StreamEvent translation (AgentEvent → Origen's StreamEvent)
+ */
+
+/**
+ * Convert an OrigenTool into a pi-agent-core AgentTool.
+ * The D1Provider is captured in closure so the tool's execute gets it.
+ */
+declare function adaptTool(tool: OrigenTool, getD1: D1Provider): AgentTool;
+/** Adapt all OrigenTools for an Agent instance. */
+declare function adaptTools(tools: OrigenTool[], getD1: D1Provider): AgentTool[];
+interface ModelResolutionOptions {
+    /** Ollama base URL, e.g. "http://localhost:11434/v1" */
+    ollamaBaseUrl?: string;
+}
+/**
+ * Resolve a model ID string to a pi-ai Model object.
+ * Tries pi-ai's registry first, then falls back to built-in Ollama definitions.
+ */
+declare function resolveModel(modelId: string, options?: ModelResolutionOptions): Model<Api>;
+/** Convert Origen's simple messages to pi-ai Message format. */
+declare function convertMessages(messages: Array<{
+    role: "user" | "assistant";
+    content: string;
+}>): Message[];
+/** Build a pi-ai Context from Origen's config. */
+declare function buildContext(systemPrompt: string, messages: Message[], adaptedTools: AgentTool[]): Context;
+/** Default citation extractor — [BOOK CHAPTER:VERSE] patterns (e.g., [GEN 1:1]).
+ *  Bible-specific pattern. Consumers should provide their own extractCitations
+ *  for non-biblical citation formats. Exported for reuse and testing.
+ */
+declare function defaultCitationExtractor(text: string): Citation[];
+/** Translate a pi-agent-core AgentEvent into an Origen StreamEvent. */
+declare function translateEvent(event: AgentEvent, extractCitations?: (text: string) => Citation[]): StreamEvent | null;
+/**
+ * Eagerly subscribe to an Agent and return an async iterable of Origen StreamEvents.
+ *
+ * CRITICAL: The subscription is created synchronously when this function is called,
+ * BEFORE agent.prompt() starts. This avoids the race condition where events
+ * emitted during prompt() are missed if subscription happens after.
+ *
+ * Usage:
+ *   const { stream, unsubscribe } = createEventStream(agent, extractCitations);
+ *   agent.prompt(messages); // events flow into stream via active subscription
+ *   for await (const event of stream) { ... }
+ */
+declare function createEventStream(agent: any, // Agent from pi-agent-core
+extractCitations?: (text: string) => Citation[]): {
+    stream: AsyncGenerator<StreamEvent>;
+    unsubscribe: () => void;
+};
+/**
+ * Subscribe to an Agent and yield Origen StreamEvents.
+ * Handles the full lifecycle from agent_start to agent_end.
+ *
+ * @deprecated Use createEventStream() instead to avoid race conditions.
+ * This function subscribes lazily (on first iteration) which can miss events
+ * if the agent has already started emitting.
+ */
+declare function agentToStreamEvents(agent: any, extractCitations?: (text: string) => Citation[]): AsyncGenerator<StreamEvent>;
+
+export { type AgentConfig as A, type Citation as C, type D1Like as D, type ModelResolutionOptions as M, type OrigenTool as O, type ReadingContext as R, type StreamEvent as S, type UsageInfo as U, type AgentResponse as a, type AuthCheckResult as b, type D1Provider as c, type ModelConfig as d, callOrigen as e, checkAuth as f, checkOpenRouterAuth as g, createEventStream as h, defaultCitationExtractor as i, adaptTool as j, adaptTools as k, agentToStreamEvents as l, buildContext as m, convertMessages as n, resolveModel as r, streamOrigen as s, translateEvent as t };

package/dist/adapter.d.ts

@@ -1,204 +1,5 @@
-import { ModelId } from './models.js';
-import { z } from 'zod';
-import { Model, Api, Message, Context } from '@mariozechner/pi-ai';
-import { AgentTool, AgentEvent } from '@mariozechner/pi-agent-core';
-
-/**
- * Origen types — no runtime deps, safe for client + server.
- */
-/** D1-compatible database interface for tool execution */
-interface D1Like {
-    prepare(sql: string): {
-        bind(...params: unknown[]): {
-            all(): Promise<{
-                results?: Record<string, unknown>[];
-            }>;
-            first(): Promise<Record<string, unknown> | null>;
-            run(): Promise<{
-                meta?: {
-                    changes: number;
-                    last_row_id: number;
-                };
-            }>;
-        };
-    };
-}
-/** Function that provides a D1 instance to tool executors */
-type D1Provider = () => Promise<D1Like>;
-/** Chat context passed from the UI (what the user is reading) */
-interface ReadingContext {
-    translation: string;
-    bookCode: string;
-    chapter: number;
-    selectedVerses?: number[];
-}
-interface Citation {
-    book: string;
-    chapter: number;
-    verse: number;
-}
-interface UsageInfo {
-    promptTokens?: number;
-    completionTokens?: number;
-    totalCost?: number;
-}
-/** Model configuration entry */
-interface ModelConfig {
-    name: string;
-    description: string;
-    free: boolean;
-}
-
-/**
- * Origen — Agent Engine (v0.3)
- *
- * Multi-provider agent harness built on pi-ai + pi-agent-core.
- * Supports OpenRouter, Ollama, Anthropic, Google, and any OpenAI-compatible API.
- * Soul.md personas, streaming, parallel tool execution, abort support.
- */
-
-/**
- * A tool that the host app registers with Origen.
- * Simple interface: name, description, JSON schema, and an execute function
- * that receives (args, getD1). The adapter wraps this into pi-agent-core's AgentTool.
- */
-interface OrigenTool {
-    name: string;
-    description: string;
-    /** OpenAI function-calling parameter schema (JSON) */
-    parameters: Record<string, unknown>;
-    /** Zod schema for runtime validation (optional) */
-    inputSchema?: z.ZodType;
-    execute: (args: Record<string, unknown>, getD1: D1Provider) => Promise<string>;
-}
-interface AgentConfig {
-    appName?: string;
-    systemPrompt?: string;
-    tools: OrigenTool[];
-    getD1: D1Provider;
-    model?: ModelId;
-    maxSteps?: number;
-    /** Custom citation extractor */
-    extractCitations?: (text: string) => Citation[];
-    /** Dynamic API key resolution per provider (e.g., for expiring OAuth tokens) */
-    getApiKey?: (provider: string) => Promise<string | undefined>;
-    /** Ollama base URL override (default: http://localhost:11434/v1) */
-    ollamaBaseUrl?: string;
-    /** Tool execution mode: "parallel" (default) or "sequential" */
-    toolExecution?: "sequential" | "parallel";
-    /** Abort signal for cancellation */
-    signal?: AbortSignal;
-    /** Reasoning/thinking level for models that support it */
-    thinkingLevel?: "off" | "minimal" | "low" | "medium" | "high";
-}
-interface AuthCheckResult {
-    authenticated: boolean;
-    apiKey: string | null;
-    provider?: string;
-    error?: string;
-}
-/**
- * Provider-aware auth check. Tests key availability for each provider.
- * If no provider argument, checks OpenRouter + Ollama availability.
- */
-declare function checkAuth(getApiKey: ((provider: string) => Promise<string | undefined>) | (() => Promise<string | null>)): Promise<AuthCheckResult>;
-/** Convenience: check OpenRouter auth only (backward compat). */
-declare function checkOpenRouterAuth(getApiKey: () => Promise<string | null>): Promise<AuthCheckResult>;
-type StreamEvent = {
-    type: "reasoning";
-    content: string;
-} | {
-    type: "tool_call";
-    name: string;
-    args: Record<string, unknown>;
-} | {
-    type: "tool_result";
-    name: string;
-    result: string;
-} | {
-    type: "text";
-    content: string;
-} | {
-    type: "done";
-    message: string;
-    citations: Citation[];
-    usage?: UsageInfo;
-} | {
-    type: "error";
-    message: string;
-};
-declare function streamOrigen(messages: Array<{
-    role: "user" | "assistant";
-    content: string;
-}>, context: Record<string, unknown> | undefined, config: AgentConfig, apiKey?: string): AsyncGenerator<StreamEvent>;
-interface AgentResponse {
-    message: string;
-    citations: Citation[];
-    usage?: UsageInfo;
-}
-declare function callOrigen(messages: Array<{
-    role: "user" | "assistant";
-    content: string;
-}>, context: Record<string, unknown> | undefined, config: AgentConfig, apiKey?: string): Promise<AgentResponse>;
-
-/**
- * Adapter: bridges Origen's simple types to pi-agent-core/pi-ai types.
- *
- * - OrigenTool → AgentTool (injects D1Provider)
- * - pi-ai Model resolution (OpenRouter, Ollama, Anthropic, Google)
- * - StreamEvent translation (AgentEvent → Origen's StreamEvent)
- */
-
-/**
- * Convert an OrigenTool into a pi-agent-core AgentTool.
- * The D1Provider is captured in closure so the tool's execute gets it.
- */
-declare function adaptTool(tool: OrigenTool, getD1: D1Provider): AgentTool;
-/** Adapt all OrigenTools for an Agent instance. */
-declare function adaptTools(tools: OrigenTool[], getD1: D1Provider): AgentTool[];
-interface ModelResolutionOptions {
-    /** Ollama base URL, e.g. "http://localhost:11434/v1" */
-    ollamaBaseUrl?: string;
-}
-/**
- * Resolve a model ID string to a pi-ai Model object.
- * Tries pi-ai's registry first, then falls back to built-in Ollama definitions.
- */
-declare function resolveModel(modelId: string, options?: ModelResolutionOptions): Model<Api>;
-/** Convert Origen's simple messages to pi-ai Message format. */
-declare function convertMessages(messages: Array<{
-    role: "user" | "assistant";
-    content: string;
-}>): Message[];
-/** Build a pi-ai Context from Origen's config. */
-declare function buildContext(systemPrompt: string, messages: Message[], adaptedTools: AgentTool[]): Context;
-/** Translate a pi-agent-core AgentEvent into an Origen StreamEvent. */
-declare function translateEvent(event: AgentEvent, extractCitations?: (text: string) => Citation[]): StreamEvent | null;
-/**
- * Eagerly subscribe to an Agent and return an async iterable of Origen StreamEvents.
- *
- * CRITICAL: The subscription is created synchronously when this function is called,
- * BEFORE agent.prompt() starts. This avoids the race condition where events
- * emitted during prompt() are missed if subscription happens after.
- *
- * Usage:
- *   const { stream, unsubscribe } = createEventStream(agent, extractCitations);
- *   agent.prompt(messages); // events flow into stream via active subscription
- *   for await (const event of stream) { ... }
- */
-declare function createEventStream(agent: any, // Agent from pi-agent-core
-extractCitations?: (text: string) => Citation[]): {
-    stream: AsyncGenerator<StreamEvent>;
-    unsubscribe: () => void;
-};
-/**
- * Subscribe to an Agent and yield Origen StreamEvents.
- * Handles the full lifecycle from agent_start to agent_end.
- *
- * @deprecated Use createEventStream() instead to avoid race conditions.
- * This function subscribes lazily (on first iteration) which can miss events
- * if the agent has already started emitting.
- */
-declare function agentToStreamEvents(agent: any, extractCitations?: (text: string) => Citation[]): AsyncGenerator<StreamEvent>;
-
-export { type AgentConfig as A, type Citation as C, type D1Like as D, type ModelConfig as M, type ModelResolutionOptions, type OrigenTool as O, type ReadingContext as R, type StreamEvent as S, type UsageInfo as U, type AgentResponse as a, adaptTool, adaptTools, agentToStreamEvents, type AuthCheckResult as b, buildContext, type D1Provider as c, convertMessages, createEventStream, callOrigen as d, checkAuth as e, checkOpenRouterAuth as f, resolveModel, streamOrigen as s, translateEvent };
+import '@mariozechner/pi-ai';
+import '@mariozechner/pi-agent-core';
+export { M as ModelResolutionOptions, j as adaptTool, k as adaptTools, l as agentToStreamEvents, m as buildContext, n as convertMessages, h as createEventStream, i as defaultCitationExtractor, r as resolveModel, t as translateEvent } from './adapter-DXIT3O2f.js';
+import 'zod';
+import './models.js';