@wrenai/genbi 0.0.3 → 0.0.5

package/dist-server/harness/events/index.d.ts

@@ -1,4 +1,4 @@
 export { createAgentEventEmitter } from "./emitter.js";
 export type { AgentEventEmitter, AgentEventInput } from "./emitter.js";
 export { MalformedSseFrameError, parseAgentEvent, serializeAgentEvent } from "./sse.js";
-export type { AgentEvent, AgentEventBase, AgentEventKind, AnswerAgentEvent, ArtifactAgentEvent, ArtifactKind, ErrorAgentEvent, RefusalAgentEvent, RunFinishEvent, RunStartEvent, StepFinishEvent, StepStartEvent, StepTrace, TokenEvent, ToolCallEvent, ToolResultEvent, TraceStep, } from "./types.js";
+export type { AgentEvent, AgentEventBase, AgentEventKind, AnswerAgentEvent, ArtifactAgentEvent, ArtifactKind, ErrorAgentEvent, RefusalAgentEvent, RunFinishEvent, RunStartEvent, StepFinishEvent, StepStartEvent, PromptSurfaceRecord, StepTrace, TokenEvent, ToolCallEvent, ToolResultEvent, TraceStep, } from "./types.js";

package/dist-server/harness/events/types.d.ts

@@ -126,6 +126,58 @@ export interface TraceStep {
      */
     readonly detail?: string;
 }
+/**
+ * One model call's prompt surfaces, digested per surface and in total (the
+ * prompt-fingerprint contract): what the model was told, never the question.
+ * `context` names which host context the step received — the prepared
+ * snapshot (private zone) or the capability card (public zone) — so an audit
+ * can see the card went only where it was allowed to.
+ */
+export interface PromptSurfaceRecord {
+    readonly component: string;
+    readonly step: string;
+    readonly tier: string;
+    readonly zone: "private" | "public" | "unbound";
+    readonly context: "snapshot" | "card" | "none";
+    readonly algorithm: string;
+    readonly digest: string;
+    readonly surfaces: Readonly<Record<string, string>>;
+}
+/**
+ * One model call's provider-reported token counts, attributed to the step
+ * and the provider that served it. Counts only, never payloads. A provider
+ * that reports nothing is recorded as zeros, not omitted. `depth` is 0 for a
+ * root step and 1+ inside a child run; the egress judge is recorded under the
+ * callee it judged, as step `egress_judge` on the judge tier.
+ */
+export interface UsageRecord {
+    readonly component: string;
+    readonly step: string;
+    readonly tier: string;
+    readonly depth: number;
+    readonly zone: "private" | "public" | "unbound";
+    readonly adapter: string;
+    readonly model: string;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+}
+/** Usage summed per provider (zone, adapter, model); `calls` counts the records summed. */
+export interface ProviderUsage {
+    readonly zone: UsageRecord["zone"];
+    readonly adapter: string;
+    readonly model: string;
+    readonly calls: number;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+}
+export interface UsageTrace {
+    readonly steps: readonly UsageRecord[];
+    readonly providers: readonly ProviderUsage[];
+}
 export interface StepTrace {
     readonly steps: readonly TraceStep[];
+    /** Composed in-process runs only; absent elsewhere. */
+    readonly surfaces?: readonly PromptSurfaceRecord[];
+    /** Composed in-process runs only; absent elsewhere. */
+    readonly usage?: UsageTrace;
 }

package/dist-server/harness/index.d.ts

@@ -7,8 +7,15 @@ export type { Agent, Bundle, Capability, Guardrail, OutputSchema, Step, StepGuar
 export { createDefaultCapabilityRegistry, createRegistry, DEFAULT_CAPABILITIES, } from "./capability/registry.js";
 export type { CapabilityRegistry } from "./capability/registry.js";
 export { assertCapabilities, CapabilityGateError } from "./capability/gate.js";
-export { ANTHROPIC_ADAPTER_ID, createAnthropicAdapter, createDefaultProviderRegistry, createMockAdapter, createOpenAICompatibleAdapter, createProviderRegistry, MOCK_ADAPTER_ID, OPENAI_COMPATIBLE_ADAPTER_ID, resolveStepModel, resolveTierModel, UnknownAdapterError, UnknownTierError, } from "./providers/index.js";
-export type { AdapterFactory, AdapterSpec, AnthropicAdapterConfig, MockAdapterConfig, OpenAICompatibleAdapterConfig, ProviderRegistry, TierBinding, } from "./providers/index.js";
+export { ANTHROPIC_ADAPTER_ID, createAnthropicAdapter, createDefaultProviderRegistry, createMockAdapter, createOpenAIAdapter, createOpenAICompatibleAdapter, createProviderRegistry, isZoneAwareBinding, MOCK_ADAPTER_ID, OPENAI_ADAPTER_ID, OPENAI_COMPATIBLE_ADAPTER_ID, parseDisclosurePolicy, parseTierBindingDocument, readTierBindingFile, resolveStepModel, resolveTierModel, resolveTierSpec, tierBindingKey, TierBindingParseError, UnknownAdapterError, UnknownTierError, } from "./providers/index.js";
+export type { AdapterFactory, AdapterSpec, AnthropicAdapterConfig, AnswerShape, DisclosurePolicy, MockAdapterConfig, OpenAIAdapterConfig, OpenAICompatibleAdapterConfig, ProviderRegistry, TierBinding, TierBindingDocument, Zone, ZoneRoles, } from "./providers/index.js";
+export { assertZoneGate, evaluateZoneGate, reachableMounts, ZoneGateError } from "./components/zone-gate.js";
+export type { ZoneGateResult, ZoneGateViolation, ZoneStepReport } from "./components/zone-gate.js";
+export { describeZoneDryRun, formatZoneDryRun } from "./components/zone-dry-run.js";
+export { BUILT_IN_PII_PATTERNS, readSlots, slotDeclarationSchema, verifyEgress } from "./components/egress.js";
+export type { DisclosedAnswer, EgressDecision, EgressJudge, EgressJudgeInput, EgressOutcome, EgressProvenance, EgressReason, EgressStatus, SlotDeclaration } from "./components/egress.js";
+export { createModelJudge, EGRESS_JUDGE_INSTRUCTIONS } from "./components/egress-judge.js";
+export type { ZoneDryRun } from "./components/zone-dry-run.js";
 export { AgentScopeError, executeAgent, InvalidRepairFoldError, passthroughGuardEvaluator, RepairExhaustedError, } from "./loop/index.js";
 export type { DataflowArtifacts, ExecuteAgentContext, GuardEvaluator, StepGuardContext, ToolCallOutcome, ToolCallOutcomeListener, } from "./loop/index.js";
 export { createAgentEventEmitter, MalformedSseFrameError, parseAgentEvent, serializeAgentEvent, } from "./events/index.js";

package/dist-server/harness/index.js

@@ -3,7 +3,11 @@ export { bundleFormatVersion } from "./bundle/schema.js";
 export { assertCompat, BundleCompatError, HARNESS_SUPPORT } from "./bundle/version.js";
 export { createDefaultCapabilityRegistry, createRegistry, DEFAULT_CAPABILITIES, } from "./capability/registry.js";
 export { assertCapabilities, CapabilityGateError } from "./capability/gate.js";
-export { ANTHROPIC_ADAPTER_ID, createAnthropicAdapter, createDefaultProviderRegistry, createMockAdapter, createOpenAICompatibleAdapter, createProviderRegistry, MOCK_ADAPTER_ID, OPENAI_COMPATIBLE_ADAPTER_ID, resolveStepModel, resolveTierModel, UnknownAdapterError, UnknownTierError, } from "./providers/index.js";
+export { ANTHROPIC_ADAPTER_ID, createAnthropicAdapter, createDefaultProviderRegistry, createMockAdapter, createOpenAIAdapter, createOpenAICompatibleAdapter, createProviderRegistry, isZoneAwareBinding, MOCK_ADAPTER_ID, OPENAI_ADAPTER_ID, OPENAI_COMPATIBLE_ADAPTER_ID, parseDisclosurePolicy, parseTierBindingDocument, readTierBindingFile, resolveStepModel, resolveTierModel, resolveTierSpec, tierBindingKey, TierBindingParseError, UnknownAdapterError, UnknownTierError, } from "./providers/index.js";
+export { assertZoneGate, evaluateZoneGate, reachableMounts, ZoneGateError } from "./components/zone-gate.js";
+export { describeZoneDryRun, formatZoneDryRun } from "./components/zone-dry-run.js";
+export { BUILT_IN_PII_PATTERNS, readSlots, slotDeclarationSchema, verifyEgress } from "./components/egress.js";
+export { createModelJudge, EGRESS_JUDGE_INSTRUCTIONS } from "./components/egress-judge.js";
 export { AgentScopeError, executeAgent, InvalidRepairFoldError, passthroughGuardEvaluator, RepairExhaustedError, } from "./loop/index.js";
 export { createAgentEventEmitter, MalformedSseFrameError, parseAgentEvent, serializeAgentEvent, } from "./events/index.js";
 export { BUILD_DASHBOARD_TOOL_NAME, connectMcpServer, createDefaultNativeToolRegistry, createNativeToolRegistry, createWrenNativeToolRegistry, createWrenQueryTool, createWriteArtifactTool, McpServerNotConfiguredError, McpToolNotExposedError, parseToolSource, resolveTools, UnknownNativeToolError, UnsupportedToolSourceError, withResolvedTools, WREN_QUERY_TOOL_NAME, WrenQueryExecutionError, WRITE_ARTIFACT_TOOL_NAME, } from "./tools/index.js";

package/dist-server/harness/loop/executor.d.ts

@@ -42,6 +42,7 @@ export interface ToolCallOutcome {
 }
 export type ToolCallOutcomeListener = (outcome: ToolCallOutcome) => void;
 export interface ExecuteAgentContext {
+    readonly signal?: AbortSignal;
     /** Tier -> adapter binding; resolves each step's model. */
     readonly binding: TierBinding;
     readonly registry: ProviderRegistry;

package/dist-server/harness/loop/executor.js

@@ -31,6 +31,7 @@ const SUPPORTED_OUTCOME = "none";
  * (the two-stage structured-output envelope is built in `harness/render/`).
  */
 export async function executeAgent(agent, ctx) {
+    ctx.signal?.throwIfAborted();
     assertV1Scope(agent);
     const artifacts = new Map();
     const evaluateGuard = ctx.evaluateGuard ?? passthroughGuardEvaluator;
@@ -44,6 +45,9 @@ export async function executeAgent(agent, ctx) {
     // consumed by the fold-into-loop logic below, keyed by their fold_into
     // target's step name.
     const repairByTarget = buildRepairFoldMap(agent, hasTools);
+    // Component-level, not per-step: read once and thread the same value into
+    // every step's rendered prompt below.
+    const brief = agentBrief(agent);
     const pending = agent.steps.filter((step) => step.realization.kind !== "repair_fold");
     while (pending.length > 0) {
         const readyIndex = pending.findIndex((step) => isConsumesSatisfied(step, artifacts));
@@ -60,7 +64,7 @@ export async function executeAgent(agent, ctx) {
             // its `produces` artifact absent. The default guard used here never does this.
             continue;
         }
-        const prompt = renderStepPrompt(step, ctx.userInput, artifacts);
+        const prompt = renderStepPrompt(step, ctx.userInput, artifacts, brief);
         const model = resolveStepModel(step, ctx.binding, ctx.registry);
         const repairStep = repairByTarget.get(step.name);
         const stepId = step.name;
@@ -75,7 +79,7 @@ export async function executeAgent(agent, ctx) {
             if (repairStep) {
                 // Validated up front in buildRepairFoldMap: a repair_fold target is
                 // always a tools-bearing step, so hasTools is guaranteed true here.
-                const result = await runToolLoopStepWithRepair(model, ctx.tools, prompt, repairStep, ctx.binding, ctx.registry, stepId, ctx.onToolCallOutcome, ctx.onEvent, ctx.maxSteps);
+                const result = await runToolLoopStepWithRepair(model, ctx.tools, prompt, repairStep, ctx.binding, ctx.registry, stepId, ctx.onToolCallOutcome, ctx.onEvent, ctx.maxSteps, ctx.signal);
                 if (result.exhausted) {
                     throw new StepBudgetExhaustedError(stepId, ctx.maxSteps, artifacts.size);
                 }
@@ -83,14 +87,14 @@ export async function executeAgent(agent, ctx) {
                 repaired = result.repaired;
             }
             else if (hasTools) {
-                const result = await runToolLoopStep(model, ctx.tools, prompt, stepId, ctx.onToolCallOutcome, ctx.onEvent, ctx.maxSteps);
+                const result = await runToolLoopStep(model, ctx.tools, prompt, stepId, ctx.onToolCallOutcome, ctx.onEvent, ctx.maxSteps, ctx.signal);
                 if (result.exhausted) {
                     throw new StepBudgetExhaustedError(stepId, ctx.maxSteps, artifacts.size);
                 }
                 text = result.text;
             }
             else {
-                text = await runSingleGenerateStep(model, prompt);
+                text = await runSingleGenerateStep(model, prompt, ctx.signal);
             }
         }
         catch (error) {
@@ -162,20 +166,31 @@ function assertV1Scope(agent) {
         throw new AgentScopeError(agent.id, agent.component_type, agent.trigger, agent.outcome);
     }
 }
+/**
+ * `brief` is declared only on the available branch of the `Agent` union
+ * (see `bundle/schema.ts`), so a plain `agent.brief` doesn't type-check on
+ * the union itself. This is the one narrowing site for it: `executeAgent`
+ * only ever runs the available branch (the unavailable manifest variant has
+ * no executable steps to run), so this always resolves to the authored
+ * value when one exists.
+ */
+function agentBrief(agent) {
+    return "brief" in agent ? agent.brief : undefined;
+}
 function isConsumesSatisfied(step, artifacts) {
     return step.consumes.every((artifactName) => artifacts.has(artifactName));
 }
-async function runSingleGenerateStep(model, prompt) {
-    const result = await generateText({ model, prompt });
+async function runSingleGenerateStep(model, prompt, signal) {
+    const result = await generateText({ model, prompt, ...(signal ? { abortSignal: signal } : {}) });
     return result.text;
 }
-async function runToolLoopStep(model, tools, prompt, stepId, onToolCallOutcome, onEvent, maxSteps) {
+async function runToolLoopStep(model, tools, prompt, stepId, onToolCallOutcome, onEvent, maxSteps, signal) {
     const agentRunner = new ToolLoopAgent({
         model,
         tools,
         ...(maxSteps !== undefined ? { stopWhen: isStepCount(maxSteps) } : {}),
     });
-    const result = await agentRunner.generate({ prompt });
+    const result = await agentRunner.generate({ prompt, ...(signal ? { abortSignal: signal } : {}) });
     reportToolCallOutcomes(result.steps, stepId, onToolCallOutcome, onEvent);
     return { text: result.text, exhausted: isBudgetExhausted(result, maxSteps) };
 }
@@ -192,7 +207,7 @@ async function runToolLoopStep(model, tools, prompt, stepId, onToolCallOutcome,
  * (default 1); once exhausted, a further tool-error throws
  * {@link RepairExhaustedError} instead of retrying again.
  */
-async function runToolLoopStepWithRepair(model, tools, prompt, repairStep, binding, registry, stepId, onToolCallOutcome, onEvent, maxSteps) {
+async function runToolLoopStepWithRepair(model, tools, prompt, repairStep, binding, registry, stepId, onToolCallOutcome, onEvent, maxSteps, signal) {
     const maxAttempts = repairStep.realization.max_attempts ?? 1;
     const repairModel = resolveStepModel(repairStep, binding, registry);
     const foldTarget = repairStep.realization.fold_into ?? repairStep.name;
@@ -215,7 +230,7 @@ async function runToolLoopStepWithRepair(model, tools, prompt, repairStep, bindi
             return { model: repairModel, instructions: repairStep.prompt };
         },
     });
-    const result = await agentRunner.generate({ prompt });
+    const result = await agentRunner.generate({ prompt, ...(signal ? { abortSignal: signal } : {}) });
     reportToolCallOutcomes(result.steps, stepId, onToolCallOutcome, onEvent);
     return { text: result.text, repaired, exhausted: isBudgetExhausted(result, maxSteps) };
 }
@@ -361,12 +376,19 @@ function basenameOf(filePath) {
 }
 /**
  * Builds the message sent for a step: the user's question (always present,
- * so steps with `consumes: []` like `resolve_intent` can still see it),
- * the step's own prompt, and the resolved values of every artifact it
- * consumes.
+ * so steps with `consumes: []` like `resolve_intent` can still see it), the
+ * component's authored `brief` when the profile sets one (framing shared
+ * across every step — placed after the question, before the step's own
+ * prompt body, matching where every Warble back-end places it relative to
+ * its own preamble/context), the step's own prompt, and the resolved values
+ * of every artifact it consumes.
  */
-function renderStepPrompt(step, userInput, artifacts) {
-    const sections = [`User's question: ${userInput}`, step.prompt];
+function renderStepPrompt(step, userInput, artifacts, brief) {
+    const sections = [`User's question: ${userInput}`];
+    if (brief !== undefined) {
+        sections.push(brief);
+    }
+    sections.push(step.prompt);
     if (step.consumes.length > 0) {
         const consumedSection = step.consumes
             .map((name) => `${name}: ${formatArtifactValue(artifacts.get(name))}`)

package/dist-server/harness/npm-package-resolve.d.ts

@@ -17,6 +17,8 @@
  * next resolution tier.
  */
 export declare function resolveInstalledPackageBin(packageName: string, binName: string): string | undefined;
+/** Returns an installed package's canonical root through Node resolution, never by walking PATH. */
+export declare function resolveInstalledPackageRoot(packageName: string): string | undefined;
 /**
  * Named, explicit opt-in that re-enables the legacy "sibling `warble` git checkout"
  * development-mode resolution tier in `resolveWarbleBinary`, `resolveAgentSdkCli`, and

package/dist-server/harness/npm-package-resolve.js

@@ -21,19 +21,31 @@ import path from "node:path";
  */
 export function resolveInstalledPackageBin(packageName, binName) {
     try {
-        const require = createRequire(import.meta.url);
-        const pkgJsonPath = require.resolve(`${packageName}/package.json`);
-        const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+        const pkgJsonPath = resolveInstalledPackageRoot(packageName);
+        if (pkgJsonPath === undefined)
+            return undefined;
+        const manifestPath = path.join(pkgJsonPath, "package.json");
+        const pkg = JSON.parse(readFileSync(manifestPath, "utf8"));
         const binField = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.[binName];
         if (binField === undefined)
             return undefined;
-        const resolved = path.resolve(path.dirname(pkgJsonPath), binField);
+        const resolved = path.resolve(pkgJsonPath, binField);
         return existsSync(resolved) ? resolved : undefined;
     }
     catch {
         return undefined;
     }
 }
+/** Returns an installed package's canonical root through Node resolution, never by walking PATH. */
+export function resolveInstalledPackageRoot(packageName) {
+    try {
+        const require = createRequire(import.meta.url);
+        return path.dirname(require.resolve(`${packageName}/package.json`));
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Named, explicit opt-in that re-enables the legacy "sibling `warble` git checkout"
  * development-mode resolution tier in `resolveWarbleBinary`, `resolveAgentSdkCli`, and

package/dist-server/harness/providers/adapters/openai-compatible.d.ts

@@ -6,5 +6,18 @@ export interface OpenAICompatibleAdapterConfig {
     readonly apiKey?: string;
     /** Provider name reported in telemetry/errors. Defaults to the adapter id. */
     readonly name?: string;
+    /**
+     * Extra fields merged into every chat-completions request body, for serving
+     * runtimes whose switches live in the body rather than in a header or the
+     * model id — e.g. Nemotron's reasoning toggle
+     * `{ chat_template_kwargs: { enable_thinking: true } }` on NIM/vLLM. Merged
+     * deeply over the SDK-built body; a key the SDK also sets is overridden by
+     * the operator's value, since the operator declared it on purpose.
+     */
+    readonly extraBody?: Readonly<Record<string, unknown>>;
+    /** Test seam: a fetch replacement so the serialized request can be inspected offline. */
+    readonly fetch?: typeof fetch;
 }
+/** Deep-merges `extra` into `base`; arrays and scalars in `extra` replace, objects merge. */
+export declare function mergeRequestBody(base: Record<string, unknown>, extra: Readonly<Record<string, unknown>>): Record<string, unknown>;
 export declare function createOpenAICompatibleAdapter(config: OpenAICompatibleAdapterConfig): LanguageModel;

package/dist-server/harness/providers/adapters/openai-compatible.js

@@ -1,10 +1,27 @@
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 export const OPENAI_COMPATIBLE_ADAPTER_ID = "openai-compatible";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Deep-merges `extra` into `base`; arrays and scalars in `extra` replace, objects merge. */
+export function mergeRequestBody(base, extra) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(extra)) {
+        const existing = out[key];
+        out[key] = isPlainObject(existing) && isPlainObject(value) ? mergeRequestBody(existing, value) : value;
+    }
+    return out;
+}
 export function createOpenAICompatibleAdapter(config) {
+    const extraBody = config.extraBody;
     const provider = createOpenAICompatible({
         name: config.name ?? OPENAI_COMPATIBLE_ADAPTER_ID,
         baseURL: config.baseURL,
         ...(config.apiKey !== undefined ? { apiKey: config.apiKey } : {}),
+        ...(config.fetch !== undefined ? { fetch: config.fetch } : {}),
+        ...(extraBody !== undefined && Object.keys(extraBody).length > 0
+            ? { transformRequestBody: (body) => mergeRequestBody(body, extraBody) }
+            : {}),
     });
     return provider.languageModel(config.model);
 }

package/dist-server/harness/providers/adapters/openai.d.ts

@@ -0,0 +1,7 @@
+import type { LanguageModel } from "ai";
+export declare const OPENAI_ADAPTER_ID = "openai";
+export interface OpenAIAdapterConfig {
+    readonly model: string;
+    readonly apiKey?: string;
+}
+export declare function createOpenAIAdapter(config: OpenAIAdapterConfig): LanguageModel;

package/dist-server/harness/providers/adapters/openai.js

@@ -0,0 +1,6 @@
+import { createOpenAI } from "@ai-sdk/openai";
+export const OPENAI_ADAPTER_ID = "openai";
+export function createOpenAIAdapter(config) {
+    const provider = createOpenAI(config.apiKey !== undefined ? { apiKey: config.apiKey } : {});
+    return provider.languageModel(config.model);
+}

package/dist-server/harness/providers/adapters/pi-ai.d.ts

@@ -0,0 +1,48 @@
+import type { LanguageModelV4, LanguageModelV4CallOptions, LanguageModelV4FinishReason, LanguageModelV4Prompt, LanguageModelV4StreamPart, LanguageModelV4Usage, SharedV4Warning } from "@ai-sdk/provider";
+import type { Api, AssistantMessage, AssistantMessageEvent, Context, Model, StopReason, Usage } from "@earendil-works/pi-ai";
+export declare const PI_AI_ADAPTER_ID = "pi-ai";
+/**
+ * Config for the `pi-ai` adapter: one model behind pi-ai's unified client.
+ *
+ * - `provider` is a pi-ai built-in provider id (`openrouter`, `amazon-bedrock`,
+ *   `vercel-ai-gateway`, ...), or — together with `baseUrl` — the name given to
+ *   a custom endpoint.
+ * - `baseUrl` turns the binding into a custom provider speaking the OpenAI
+ *   chat-completions wire (`openai-completions`). Custom endpoints speaking the
+ *   Anthropic messages wire are not wired up here and are untested.
+ * - `apiKey` is passed on every request. Nothing else is consulted: no
+ *   environment variables, no `~/.pi` files, no stored or OAuth credentials.
+ */
+export interface PiAiAdapterConfig {
+    readonly provider: string;
+    readonly model: string;
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Test seam: a fetch replacement so requests can be scripted offline. */
+    readonly fetch?: typeof fetch;
+}
+type Warnings = SharedV4Warning[];
+/** Maps the AI SDK prompt and tools onto a pi-ai `Context`. */
+export declare function toPiContext(prompt: LanguageModelV4Prompt, options: Pick<LanguageModelV4CallOptions, "tools" | "toolChoice" | "responseFormat">, model: Pick<Model<Api>, "api" | "provider" | "id">, warnings: Warnings): Context;
+/** Maps pi-ai's stop reason onto the AI SDK's unified finish reason. */
+export declare function toFinishReason(stopReason: StopReason): LanguageModelV4FinishReason;
+/** Maps pi-ai usage (where `input` excludes cached tokens) onto AI SDK usage. */
+export declare function toUsage(usage: Usage): LanguageModelV4Usage;
+/** Maps one pi-ai stream event onto zero or more AI SDK stream parts. */
+export declare function toStreamParts(event: AssistantMessageEvent, toolInputIds: Map<number, string>, failure: (message: AssistantMessage) => Error): LanguageModelV4StreamPart[];
+/** pi-ai's built-in, offline catalog: API-key providers and one provider's chat models. */
+export interface PiAiCatalog {
+    readonly providers: readonly string[];
+    readonly models: readonly {
+        readonly id: string;
+        readonly name: string;
+    }[];
+}
+/**
+ * Lists the catalog that ships inside pi-ai — no network, no credentials.
+ * OAuth-only providers are left out because gateway mode cannot use them.
+ */
+export declare function listPiAiCatalog(provider?: string): Promise<PiAiCatalog>;
+export declare function createPiAiAdapter(config: PiAiAdapterConfig): LanguageModelV4;
+export {};