@vraxis/agent-v 0.4.0

package/AGENTS.md

@@ -0,0 +1,61 @@
+# Working on agent-v
+
+`agent-v` is a provider-neutral execution engine. Preserve the boundary between reusable execution mechanics and product-owned meaning.
+
+## Start here
+
+Read these files before changing behavior:
+
+1. `README.md` for the supported consumer surface.
+2. `ARCHITECTURE.md` for dependency and safety boundaries.
+3. `compatibility.json` for adapter strategies and dependency ranges.
+4. The relevant executable example under `examples/`.
+
+Use current local dependency documentation and source when editing an adapter. In particular, inspect `node_modules/ai/docs` and `node_modules/ai/src` before changing AI SDK integration code.
+
+## Package routing
+
+- `@vraxis/agent-v`: provider-neutral contracts, registries, policies, and composition.
+- `@vraxis/agent-v/ai-sdk`: AI SDK structured generation and tool agents.
+- `@vraxis/agent-v/local-cli`: bounded Codex, OpenCode, Claude Code, and Cursor runtime integration.
+- `@vraxis/agent-v/ollama`: optional Ollama model runtime support.
+- `@vraxis/agent-v/node`: filesystem persistence, diagnostics, and Agent Skills loading.
+- `@vraxis/agent-v/testing`: deterministic fakes and approval policies.
+
+Do not import adapter or Node types into `src/core`. Optional provider dependencies must remain isolated behind their package subpath.
+
+## Non-negotiable invariants
+
+- Every execution requires an explicit `ExecutionScope`.
+- Tool input and output are both validated.
+- External-side-effect and privileged tools require approval.
+- Skill tool allowlists fail closed; tools are never silently dropped.
+- Requested workspace access must be enforceable by the selected runtime.
+- Never retry by weakening sandbox, approval, permission, schema, or isolation requirements.
+- Every run records an adapter strategy. Local executables and model runtimes record detected versions when available.
+- Credentials remain host-resolved values; config, events, and sessions store references only.
+- Product evidence policy, prompts, ranking, retrieval, billing, and UX stay outside this package.
+
+## Public API changes
+
+There are no legacy consumers to preserve by default, but public changes must still be deliberate and internally consistent:
+
+1. Update types and runtime behavior together.
+2. Add a behavioral test, not only a type assertion.
+3. Update the relevant example and `compatibility.json`.
+4. Update `README.md`, `ARCHITECTURE.md`, or `CHANGELOG.md` when the consumer contract changes.
+5. Keep package exports and the built-package smoke test synchronized.
+
+Do not advertise a capability until an adapter can enforce it and a test demonstrates it.
+
+## Verification
+
+Run the complete release gate:
+
+```bash
+npm run check
+```
+
+This must typecheck source and tests, run behavioral tests, build declarations and JavaScript, compile and execute consumer examples, verify package imports and CLI help, and perform an npm package dry run.
+
+Live probes are evidence beyond unit tests. They may use credentials, local services, or paid models, so run them only when the task authorizes that external action. Never download an Ollama model or start a background service merely to make a test pass.

package/ARCHITECTURE.md

@@ -0,0 +1,148 @@
+# Architecture
+
+## Objective
+
+`agent-v` is the stable application-facing contract over changing AI providers, orchestration frameworks, and local agent runtimes. It optimizes for substitution, auditability, client isolation, local ownership, and narrowly scoped capabilities.
+
+There are no current consumers to preserve. Version 0.2 intentionally chooses explicit, fail-closed contracts over compatibility with the 0.1 prototype.
+
+## Dependency rule
+
+```text
+products  ───────────────►  agent-v core  ◄──────────────  adapters
+domain policy + UX          contracts + policy ports       AI SDK / local CLI / future engines
+                                  ▲
+                                  │
+                         host persistence, identity,
+                         credentials, and telemetry
+```
+
+The core imports no provider SDK and no Node-only module. Adapters translate framework behavior into normalized contracts and events. Products do not expose provider result objects to their domain layer.
+
+## Engine contracts
+
+The engine types remain separate because they have different safety semantics:
+
+1. `StructuredModelEngine` performs one schema-bound model operation.
+2. `ToolAgentEngine` runs a bounded model/tool loop and can stream normalized events.
+3. `CodingRuntimeEngine` invokes an installed coding agent against an explicitly scoped workspace.
+
+`EngineRegistry` resolves by id, kind, and capabilities. It does not silently substitute a weaker engine.
+
+## Mandatory execution scope
+
+Every run supplies `ExecutionScope`:
+
+- tenant, project, principal, and optional engagement isolate persisted state and event queries;
+- principal, roles, and permissions drive host and tool policy;
+- optional engagement id supports consulting/client work without inventing a separate runtime;
+- data classification gives middleware and adapters a stable privacy signal.
+
+The same scope is attached to approval requests, sessions, run events, tool contexts, and model resolution. This prevents a universal engine from relying on ambient application identity.
+
+## Tools and authority
+
+An `AgentTool` declares a stable name/version, JSON-schema input and output contracts, risk, side-effect behavior, required permissions, approval requirement, and timeout. Execution follows this order:
+
+```text
+model tool call
+  → validate input
+  → verify scoped permissions
+  → request and record approval when required
+  → execute with cancellation and timeout
+  → validate output
+  → return normalized result to the model
+```
+
+External-side-effect and privileged tools must require approval. A host approval policy remains authoritative; skill metadata can never bypass it. Tool failures emitted as events use safe normalized messages.
+
+The shared repository should contain broadly reusable, well-tested tool contracts and adapters. Product-specific tools stay with the product until their semantics are genuinely shared. This avoids turning `agent-v` into an ungoverned catalog with ambient authority.
+
+## Skills and agents
+
+- An **agent blueprint** selects exactly one engine or profile, instructions, skills, tools, required capabilities, and a step bound.
+- A **skill** is portable domain guidance plus a tool allowlist and optional evidence artifacts.
+- An **extension** packages tools, skills, and middleware but gains no authority merely by registration.
+- **Middleware** handles cross-cutting policy, telemetry, redaction, and budget enforcement supplied by a host.
+
+When an agent selects skills, every requested tool must appear in their combined allowlist. A mismatch rejects preparation rather than silently reducing capability.
+
+The Node adapter loads the open Agent Skills directory format: `SKILL.md` with optional scripts, references, and assets. Loading only validates and indexes content. Script execution requires a separate explicit tool or sandbox owned by the host.
+
+## Models, profiles, and credentials
+
+The AI SDK adapter resolves a model per run. Resolution can use a static model, a model registry, or a host function receiving model id, run id, execution scope, metadata, and credential reference. Provenance describes what was actually selected; a request cannot relabel a static model as something else.
+
+Every provenance record includes an adapter strategy identifier. Local CLI adapters additionally detect and record the executable version before invocation. Model resolvers may return authoritative runtime provenance with their model; the Ollama resolver uses this to record its live daemon version. These fields are evidence for compatibility diagnosis, not promises that an unverified version is supported.
+
+Profiles are configuration, not engines. They bind a blueprint to an engine id, model id, and opaque credential reference. The host resolves secrets at execution time; configuration and events contain references, never credential values.
+
+This keeps the core compatible with direct provider clients, the Vercel AI SDK, LangGraph, durable workflow runtimes, local models, and future harnesses without adopting their types.
+
+## Events, sessions, and persistence
+
+Adapters normalize execution into:
+
+```text
+run.started
+  model.started / model.completed
+  text.delta*
+  tool.requested
+    approval.requested → approval.resolved
+    tool.completed | tool.failed
+run.completed | run.failed
+```
+
+Events are UI-neutral and scope-carrying. `AgentMessage` uses typed parts for text, JSON, artifacts, files, and images rather than overloading one string.
+
+Persistence is port-based:
+
+- `ConfigStore` stores profiles and safe defaults.
+- `SessionStore` stores host-approved conversational state by scope.
+- `RunEventStore` stores normalized execution history by scope.
+- `CredentialResolver` is a host port for resolving opaque references.
+
+The Node implementation uses private atomic JSON files and a serialized append-only JSONL ledger. Products can replace these with SQLite, Postgres, object storage, encrypted stores, or consulting-specific infrastructure without changing agent definitions.
+
+## Local runtime control plane
+
+Local coding agents are fallible external systems:
+
+- installed, authenticated/verified, and runnable are distinct states;
+- readiness belongs to an executable version and expires when that version changes;
+- execution has time and output bounds and closes stdin immediately;
+- schema/output files are private and temporary;
+- workspace access defaults to read-only and must match an advertised enforceable capability;
+- unstructured or schema-invalid output is rejected and can receive one bounded repair attempt;
+- safe failure categories are emitted without persisting raw diagnostics.
+
+Codex supports enforced read-only and workspace-write modes. OpenCode currently advertises workspace-write only. Claude Code advertises read-only only. Cursor remains discoverable but does not advertise structured output, so the engine refuses to run it through the structured contract.
+
+Ollama is a model runtime rather than a coding CLI and therefore lives in its own optional adapter. It verifies the native version and tags endpoints, confirms the requested model is installed, and delegates model/tool protocol behavior to the AI SDK 7-compatible `ai-sdk-ollama` provider. Products that do not use Ollama do not load or require that dependency.
+
+## Product boundary
+
+Keep meaning and judgment in the product:
+
+- Distribution OS: evidence scoring, opportunity ranking, founder voice, channel policy, approval UX, and outcome learning.
+- Aperta: proof graphs, patch verification, repository policy, and ownership claims.
+- Reader products: document ingestion, layout, highlights, search/retrieval, pedagogy, and citation presentation.
+- Consulting: client-specific prompts, data connectors, deliverables, retention rules, and contractual policy.
+
+Centralize execution mechanisms only when their semantics and safety rules are reusable.
+
+## Verification standard
+
+A release must pass strict TypeScript checking, deterministic unit/integration tests, a production build, compiled and executed consumer examples, imports from the built package subpaths, CLI help execution, and `npm pack --dry-run`. CI runs this suite on the minimum Node version and the current release line.
+
+## Agent accuracy surface
+
+Coding-agent guidance is part of the release contract rather than informal prose:
+
+- `AGENTS.md` governs repository changes and dependency direction.
+- `skills/agent-v` routes consuming agents to the correct engine and safety contract.
+- `examples/` are executable documentation compiled against package exports after every build.
+- `compatibility.json` is checked against runtime strategy identifiers and capabilities.
+- `agent-v doctor` exposes dependency and readiness evidence without making inference calls by default.
+
+These artifacts must change with the implementation they describe. Documentation that cannot be compiled or mechanically compared is supporting explanation, not authoritative API evidence.

package/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+## 0.4.0
+
+- Add a packaged `agent-v` Agent Skill and repository guidance for coding agents.
+- Add executable consumer examples compiled against the built package exports.
+- Add `agent-v doctor` with safe dependency, CLI, authentication-probe, and Ollama readiness reporting.
+- Add machine-readable compatibility metadata synchronized with executable runtime strategies.
+- Add the package version constant and strengthen public API guidance for automated consumers.
+
+## 0.3.0
+
+- Record an adapter strategy on every run and the detected executable version on local CLI runs.
+- Add a first-class optional Ollama adapter for AI SDK 7 with daemon readiness, installed-model checks, structured generation, tool agents, and runtime-aware provenance.
+- Allow AI SDK model resolvers to return authoritative provenance alongside the resolved model.
+
+## 0.2.0
+
+- Require tenant, project, principal, role, permission, and data-classification scope on every execution.
+- Make tool input and output contracts, risk, side effects, permissions, approval, version, and timeout explicit.
+- Resolve AI SDK models per run, including scoped credential references supplied by the host.
+- Add scoped memory and filesystem session stores plus scoped run-event ledgers.
+- Load portable Agent Skills packages from `SKILL.md` without executing bundled resources.
+- Refuse local runtime access modes the selected CLI cannot enforce.
+- Add typed multimodal message parts, session continuation, event persistence, CI, and package-surface smoke tests.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,237 @@
+# agent-v
+
+`agent-v` is a provider-neutral TypeScript engine for building inspectable agentic products. It centralizes the mechanics that should be shared across products—runtime selection, scoped execution, tools, approvals, skills, sessions, events, artifacts, and testing—while leaving domain truth and user experience in each application.
+
+It is an engine, not a chatbot framework and not a repository of every product-specific tool. Distribution OS can own evidence and channel policy, Aperta can own proof graphs, a reader can own PDF/EPUB ingestion and pedagogy, and consulting products can own client-specific workflows while all use the same execution contract.
+
+## What works in 0.4
+
+- Vercel AI SDK 7 structured generation, tool loops, streaming, and per-run model resolution.
+- Codex CLI, OpenCode, and Claude Code runtime adapters with honest access-mode capabilities and bounded schema output. Cursor is discoverable but rejected for structured execution until its adapter can guarantee the contract.
+- Local Ollama models through an optional AI SDK 7-compatible adapter with daemon and installed-model readiness checks.
+- Typed tools with input and output validation, version, risk, side-effect, permission, approval, and timeout declarations.
+- Portable skills defined in code or loaded from standard `SKILL.md` packages.
+- Tenant/project/principal execution scope on every run, approval, event, session, and model-resolution request.
+- Memory and local JSON/JSONL persistence with tenant/project isolation.
+- Deterministic fakes, provider-free tests, built-package smoke testing, and CI on Node 22 and 24.
+- Packaged guidance for coding agents, executable consumer examples, compatibility metadata, and a safe readiness doctor.
+
+## Install
+
+```bash
+npm install @vraxis/agent-v
+```
+
+The optional AI SDK adapter requires a compatible peer:
+
+```bash
+npm install ai
+```
+
+Ollama support uses the tool-capable AI SDK community provider and is installed only by products that need it:
+
+```bash
+npm install ai ai-sdk-ollama
+```
+
+Node and local CLI adapters require Node.js 22.12 or newer. The core has no provider SDK dependency.
+
+## Define a tool, skill, and agent
+
+```ts
+import {
+  AgentV,
+  EngineRegistry,
+  ExtensionRegistry,
+  defineAgent,
+  defineExtension,
+  defineOutput,
+  defineSkill,
+  defineTool,
+  localExecutionScope,
+} from "@vraxis/agent-v";
+
+const lookupSelection = defineTool({
+  name: "lookup-selection",
+  version: "1.0.0",
+  description: "Find supporting material for a selected passage.",
+  input: defineOutput({
+    name: "selection-query",
+    jsonSchema: {
+      type: "object",
+      properties: { query: { type: "string" } },
+      required: ["query"],
+      additionalProperties: false,
+    },
+    parse(value) {
+      const query = (value as { query?: unknown }).query;
+      if (typeof query !== "string") throw new Error("query is required");
+      return { query };
+    },
+  }),
+  output: defineOutput({
+    name: "selection-results",
+    jsonSchema: { type: "object" },
+    parse(value) {
+      const matches = (value as { matches?: unknown }).matches;
+      if (!Array.isArray(matches) || !matches.every(item => typeof item === "string")) throw new Error("matches are required");
+      return { matches };
+    },
+  }),
+  risk: "read",
+  sideEffect: "none",
+  requiredPermissions: ["sources:read"],
+  requiresApproval: false,
+  timeoutMs: 5_000,
+  async execute({ query }) {
+    return { matches: [`Host search result for: ${query}`] };
+  },
+});
+
+const closeReading = defineSkill({
+  id: "close-reading",
+  name: "Close reading",
+  version: "1.0.0",
+  description: "Ground explanations in supplied source material.",
+  instructions: "Distinguish source claims from interpretation and cite anchors.",
+  tools: [lookupSelection.name],
+});
+
+const reader = defineAgent({
+  id: "engineering-reader",
+  name: "Engineering reader",
+  engineId: "primary-agent",
+  instructions: "Help the reader understand and question the material.",
+  skills: [closeReading.id],
+  tools: [lookupSelection.name],
+  requiredCapabilities: ["tools", "streaming", "artifacts"],
+  maxSteps: 12,
+});
+
+const engines = new EngineRegistry(); // register an adapter with id "primary-agent"
+const extensions = new ExtensionRegistry().use(defineExtension({
+  id: "reader-kit",
+  version: "1.0.0",
+  skills: [closeReading],
+  tools: [lookupSelection],
+}));
+const agentV = new AgentV({ engines, extensions });
+
+const scope = {
+  ...localExecutionScope("engineering-reader"),
+  permissions: ["sources:read"],
+};
+// await agentV.run(reader, { scope, sessionId: "chapter-4", input: { prompt, artifacts } });
+```
+
+Every tool requested by an agent using skills must be allowed by those skills. Missing grants fail before provider execution; they are never silently filtered.
+
+## Model and credential resolution
+
+`AiSdkToolAgentEngine` accepts a static model, a named model registry, or a `resolveModel(selection)` function. The resolver receives the requested model id, execution scope, run id, metadata, and an opaque `credentialRef`. The host resolves that reference and constructs the provider model; `agent-v` never stores credential values.
+
+Engine profiles can select an engine/model/credential reference without changing an agent blueprint. A blueprint chooses either `engineId` or `profileId`, never both.
+
+Model resolvers can return authoritative provider/runtime provenance with the model. Every run records an `adapterStrategy`; local runtimes and Ollama also record the detected runtime version. This makes upstream protocol changes diagnosable from persisted run events.
+
+## Ollama
+
+```ts
+import { OllamaRuntime } from "@vraxis/agent-v/ollama";
+
+const ollama = new OllamaRuntime({
+  defaultModel: "your-installed-model",
+  // baseURL defaults to http://127.0.0.1:11434
+});
+
+const readiness = await ollama.inspect();
+if (readiness.availability === "ready") {
+  engines.register(ollama.agent);
+  engines.register(ollama.structured);
+}
+```
+
+Resolution checks the live daemon version and installed model list before creating the AI SDK model. Missing daemons, rejected credentials, unexpected readiness responses, and absent models fail closed. Remote Ollama servers can provide `baseURL`, headers, and an API key when the host has resolved its credential reference.
+
+## Skills
+
+`@vraxis/agent-v/node` exports `loadSkillPackage()` and `discoverSkillPackages()`. A package is a directory containing a standard `SKILL.md` plus optional `scripts/`, `references/`, and `assets/` directories. Discovery validates and indexes these resources but never executes scripts.
+
+The standard `allowed-tools` field is preserved as `preapprovedTools`, but it does not bypass host policy. It also seeds the skill's tool allowlist. Tools marked `requiresApproval` still require an `ApprovalPolicy` at execution time.
+
+## Adapters
+
+- `@vraxis/agent-v/ai-sdk`: AI SDK structured and tool-agent engines.
+- `@vraxis/agent-v/local-cli`: bounded local coding runtimes and readiness probes.
+- `@vraxis/agent-v/ollama`: optional local/remote Ollama structured and tool-agent engines.
+- `@vraxis/agent-v/node`: JSON config/session stores, JSONL event ledger, and filesystem skills.
+- `@vraxis/agent-v/testing`: deterministic engines and approval policies.
+
+Local CLI discovery and readiness are separate. An executable is `installed`; only a bounded, authenticated, schema-valid probe is `ready`. OpenCode advertises workspace-write only, so a default read-only request fails closed instead of weakening the requested policy.
+
+## Agent-readable integration guidance
+
+The package ships four synchronized sources for coding agents:
+
+- `AGENTS.md` explains repository boundaries and contribution invariants.
+- `skills/agent-v/SKILL.md` is a portable integration skill with precise subpath routing.
+- `examples/` contains consumer programs compiled and executed against the built package exports.
+- `compatibility.json` records dependency ranges, adapter strategies, runtime capabilities, and version policies.
+- `llms.txt` gives documentation crawlers a short map to the canonical sources.
+
+Agents should start with the closest executable example and verify against installed type declarations. They should not infer `agent-v` methods from LangChain, the AI SDK, or older examples.
+
+Locate the packaged portable skill from an installed dependency with:
+
+```bash
+npx @vraxis/agent-v skill-path
+```
+
+The consuming harness can copy or link that directory into its configured Agent Skills location; discovery locations are owned by the harness, not guessed by `agent-v`.
+
+## Doctor
+
+Run safe discovery without provider inference:
+
+```bash
+npx @vraxis/agent-v doctor
+npx @vraxis/agent-v doctor --json
+```
+
+Run an authenticated CLI probe only by naming the runtime explicitly:
+
+```bash
+npx @vraxis/agent-v doctor --runtime codex --probe
+```
+
+Require an Ollama server and model:
+
+```bash
+npx @vraxis/agent-v doctor --ollama-url http://127.0.0.1:11434 --ollama-model <installed-model>
+```
+
+The default command does not start services, download models, or make model inference calls. Live CLI probing may use configured credentials, so `--probe` requires an explicit `--runtime`.
+
+## Design commitments
+
+- The host owns identity, approval decisions, credentials, and real side effects.
+- Every run carries explicit tenant, project, principal, role, permission, and data-classification scope.
+- Tools validate both model-supplied input and application-supplied output.
+- Workspace access defaults to read-only and must be enforceable by the selected runtime.
+- Normalized events and sessions are scope-isolated; raw provider objects do not leak into core contracts.
+- Product evidence, prompts, retrieval, ranking, billing, and UX stay outside the engine.
+
+See [ARCHITECTURE.md](./ARCHITECTURE.md) for boundaries and extension rules.
+
+## Development
+
+```bash
+npm ci
+npm run check
+```
+
+`check` runs strict typechecking, all tests, the production build, consumer example compilation and execution, built-package and CLI smoke tests, and an npm package dry run.
+
+## License
+
+MIT

package/compatibility.json

@@ -0,0 +1,41 @@
+{
+  "schemaVersion": 1,
+  "packageVersion": "0.4.0",
+  "node": ">=22.12",
+  "adapters": {
+    "ai-sdk": {
+      "packageRange": ">=7.0.0 <8",
+      "strategies": [
+        "ai-sdk-v7-structured-model",
+        "ai-sdk-v7-tool-agent"
+      ]
+    },
+    "ollama": {
+      "aiSdkOllamaRange": ">=4.2.0 <5",
+      "aiSdkRange": ">=7.0.0 <8",
+      "strategy": "ai-sdk-ollama-v4-native-chat",
+      "versionPolicy": "inspect-daemon-and-models-before-each-resolution"
+    },
+    "local-cli": {
+      "versionPolicy": "detect-before-each-run-and-invalidate-readiness-on-change",
+      "runtimes": {
+        "codex": {
+          "strategy": "codex-exec-json-v1",
+          "capabilities": ["structured-output", "local-workspace", "read-only-workspace", "workspace-write", "artifacts"]
+        },
+        "opencode": {
+          "strategy": "opencode-run-json-v1",
+          "capabilities": ["structured-output", "local-workspace", "workspace-write", "artifacts"]
+        },
+        "claude-code": {
+          "strategy": "claude-print-json-v1",
+          "capabilities": ["structured-output", "local-workspace", "read-only-workspace", "artifacts"]
+        },
+        "cursor": {
+          "strategy": "cursor-print-json-v1",
+          "capabilities": ["local-workspace", "workspace-write", "artifacts"]
+        }
+      }
+    }
+  }
+}

package/dist/adapters/ai-sdk/index.d.ts

@@ -0,0 +1,46 @@
+import { type LanguageModel } from "ai";
+import { type AgentRunStream, type EngineDescriptor, type EventSink, type RunProvenance, type StructuredGenerationRequest, type StructuredGenerationResult, type ToolAgentEngine, type ToolAgentRequest, type ToolAgentResult } from "../../core/index.js";
+/** Provider/model sources and provenance defaults for an AI SDK engine. */
+export interface AiSdkEngineOptions {
+    id: string;
+    name?: string;
+    model?: LanguageModel;
+    models?: Readonly<Record<string, LanguageModel>>;
+    resolveModel?: AiSdkModelResolver;
+    provider?: string;
+    modelId?: string;
+    adapterStrategy?: string;
+    runtime?: string;
+    runtimeVersion?: string;
+}
+/** Host context supplied whenever an AI SDK model is resolved for a run. */
+export interface AiSdkModelSelection {
+    modelId?: string;
+    runId: string;
+    metadata?: import("../../core/index.js").JsonObject;
+    scope: import("../../core/index.js").ExecutionScope;
+    credentialRef?: string;
+    options?: import("../../core/index.js").JsonObject;
+}
+/** Model plus authoritative provenance discovered during resolution. */
+export interface AiSdkResolvedModel {
+    model: LanguageModel;
+    provenance?: Partial<Omit<RunProvenance, "engineId">>;
+}
+/** Per-run model resolver used for provider, tenant, or credential selection. */
+export type AiSdkModelResolver = (selection: AiSdkModelSelection) => LanguageModel | AiSdkResolvedModel | Promise<LanguageModel | AiSdkResolvedModel>;
+export declare class AiSdkStructuredModelEngine {
+    readonly descriptor: EngineDescriptor;
+    private readonly options;
+    constructor(options: AiSdkEngineOptions);
+    generate<T>(request: StructuredGenerationRequest<T>, sink?: EventSink): Promise<StructuredGenerationResult<T>>;
+}
+export declare class AiSdkToolAgentEngine implements ToolAgentEngine {
+    readonly descriptor: EngineDescriptor;
+    private readonly options;
+    constructor(options: AiSdkEngineOptions);
+    private generate;
+    run<T = string>(request: ToolAgentRequest<T>, sink?: EventSink): Promise<ToolAgentResult<T>>;
+    stream<T = string>(request: ToolAgentRequest<T>, sink?: EventSink): Promise<AgentRunStream<T>>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/ai-sdk/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/ai-sdk/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,aAAa,EAEnB,MAAM,IAAI,CAAC;AACZ,OAAO,EAQL,KAAK,cAAc,EAEnB,KAAK,gBAAgB,EAErB,KAAK,SAAS,EAGd,KAAK,aAAa,EAClB,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAC/B,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EAErB,MAAM,qBAAqB,CAAC;AAE7B,2EAA2E;AAC3E,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IACjD,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,4EAA4E;AAC5E,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,qBAAqB,EAAE,UAAU,CAAC;IACpD,KAAK,EAAE,OAAO,qBAAqB,EAAE,cAAc,CAAC;IACpD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,qBAAqB,EAAE,UAAU,CAAC;CACpD;AAED,wEAAwE;AACxE,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC,CAAC;CACvD;AAED,iFAAiF;AACjF,MAAM,MAAM,kBAAkB,GAAG,CAAC,SAAS,EAAE,mBAAmB,KAAK,aAAa,GAAG,kBAAkB,GAAG,OAAO,CAAC,aAAa,GAAG,kBAAkB,CAAC,CAAC;AAuGtJ,qBAAa,0BAA0B;IACrC,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;gBAEjC,OAAO,EAAE,kBAAkB;IAMjC,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,2BAA2B,CAAC,CAAC,CAAC,EAAE,IAAI,GAAE,SAAyB,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC;CAyCpI;AAmFD,qBAAa,oBAAqB,YAAW,eAAe;IAC1D,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;gBAEjC,OAAO,EAAE,kBAAkB;YAMzB,QAAQ;IAuBhB,GAAG,CAAC,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,IAAI,GAAE,SAAyB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;IA4B3G,MAAM,CAAC,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,IAAI,GAAE,SAAyB,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;CAwDpH"}