@rivus/runtime 0.16.2

package/dist/pi.d.ts

@@ -0,0 +1,840 @@
+import { C as AgentLoopInput, Gt as SessionKey, a as AgentLoopInput$1, b as AgentLoop, t as AgentLoop$1 } from "./chunks/agent-loop.js";
+import { $ as RegisteredRivusSkill, A as AgentModelContentObserver, I as RivusMemoryScope, L as RivusResolvedToolDescriptor, O as NormalizedAgentInvocation, U as RivusToolGrantSet, X as RunAdmission, dt as ModelReference, it as ModelChangeBudgetReservation, lt as ModelChangeRuntimePort, nt as ModelBinding, ot as ModelChangePaidCallKind, p as ToolExecutionRequest, q as RivusToolRisk, r as RivusRuntimeToolId } from "./chunks/rivus-runtime-tool.js";
+import { Effect } from "effect";
+import { TSchema } from "typebox";
+
+//#region src/adapters/pi/config/pi-model-overrides.d.ts
+interface PiModelDefinitionBase {
+  readonly api: string;
+  readonly baseUrl: string;
+  readonly compat?: object;
+  readonly contextWindow: number;
+  readonly cost: Readonly<{
+    readonly cacheRead: number;
+    readonly cacheWrite: number;
+    readonly input: number;
+    readonly output: number;
+  }>;
+  readonly id: string;
+  readonly maxTokens: number;
+  readonly name: string;
+  readonly reasoning: boolean;
+  readonly samplingParams?: Readonly<Record<string, unknown>>;
+  readonly thinkingLevelMap?: Readonly<Partial<Record<string, string | null>>>;
+}
+interface PiDeclarativeModelDefinition extends PiModelDefinitionBase {
+  readonly input: ReadonlyArray<"image" | "text">;
+}
+interface MergePiProviderBaseUrlOverrideOptions {
+  readonly baseUrl: string;
+  readonly filePath: string;
+  readonly provider: string;
+}
+declare function mergePiProviderBaseUrlOverride(options: MergePiProviderBaseUrlOverrideOptions): Promise<void>;
+interface MergePiProviderModelDeclarationOptions {
+  readonly filePath: string;
+  readonly model: PiDeclarativeModelDefinition;
+  readonly provider: string;
+}
+/**
+ * Persist one complete custom model definition in models.json.
+ *
+ * Pi composes these definitions with its built-in provider metadata. Keeping the
+ * complete definition here is deliberate: a missing SDK catalog entry must be
+ * represented by its exact server id, never by a fuzzy or legacy alias.
+ */
+declare function mergePiProviderModelDeclaration(options: MergePiProviderModelDeclarationOptions): Promise<void>;
+//#endregion
+//#region src/adapters/pi/execution/pi-agent-loop.d.ts
+type PiAgentSessionEvent = PiMessageStartEvent | PiMessageUpdateEvent | PiMessageEndEvent | PiToolExecutionStartEvent | PiToolExecutionUpdateEvent | PiToolExecutionEndEvent | {
+  readonly type: string;
+  readonly [key: string]: unknown;
+};
+interface PiMessageUpdateEvent {
+  readonly type: "message_update";
+  readonly message: unknown;
+  readonly assistantMessageEvent: {
+    readonly type: "text_delta";
+    readonly contentIndex: number;
+    readonly delta: string;
+    readonly partial: unknown;
+  } | {
+    readonly type: "thinking_delta";
+    readonly contentIndex: number;
+    readonly delta: string;
+    readonly partial: unknown;
+  } | {
+    readonly type: string;
+    readonly [key: string]: unknown;
+  };
+}
+interface PiMessageStartEvent {
+  readonly type: "message_start";
+  readonly message: unknown;
+}
+interface PiMessageEndEvent {
+  readonly type: "message_end";
+  readonly message: unknown;
+}
+interface PiToolExecutionStartEvent {
+  readonly type: "tool_execution_start";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly args?: unknown;
+  readonly input?: unknown;
+}
+interface PiToolExecutionUpdateEvent {
+  readonly type: "tool_execution_update";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly args?: unknown;
+  readonly input?: unknown;
+  readonly partialResult: unknown;
+}
+interface PiToolExecutionEndEvent {
+  readonly type: "tool_execution_end";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly result: unknown;
+  readonly isError: boolean;
+}
+/** Public session context shape needed by model management and history checks. */
+interface PiSessionContext {
+  readonly messages: readonly unknown[];
+}
+/** Minimal session-manager capability exposed by the Pi adapter boundary. */
+interface PiSessionManager {
+  readonly buildSessionContext: () => PiSessionContext;
+}
+interface PiAgentSession {
+  abort?: () => Promise<void> | void;
+  /** Native queue operations required when the loop opts into steering. */
+  steer?(text: string): Promise<void> | void;
+  readonly isStreaming?: boolean;
+  clearQueue?(): unknown;
+  setModel?(model: unknown): Promise<void> | void;
+  setThinkingLevel?(level: string): void;
+  waitForIdle?(): Promise<void>;
+  reload?(): Promise<void> | void;
+  readonly sessionManager?: PiSessionManager;
+  prompt(text: string): Promise<void>;
+  readonly state?: unknown;
+  subscribe(listener: (event: PiAgentSessionEvent) => void): () => void;
+  dispose?: () => Promise<void> | void;
+}
+interface PiAgentSessionHandle$1 {
+  readonly activate?: (input: AgentLoopInput) => Promise<void> | void;
+  /** Revoke per-Run authority after the SDK prompt and cancellation have settled. */
+  readonly deactivate?: () => Promise<void> | void;
+  readonly dispose?: () => Promise<void> | void;
+  readonly preparePrompt?: (input: AgentLoopInput) => Promise<string> | string;
+  readonly refreshResources?: () => Promise<void> | void;
+  readonly resolveToolName?: (toolName: string) => string;
+  readonly session: PiAgentSession;
+}
+interface PiAgentLoopOptions$1 {
+  /** Enable only for sessions providing native steer, isStreaming and clearQueue. */
+  readonly supportsSteering?: boolean;
+  readonly disposeSessionAfterRun?: boolean;
+  readonly modelContentObserver?: AgentModelContentObserver;
+  /** Home-wide admission fence acquired before a session/model is resolved. */
+  readonly runBoundary?: Pick<RunAdmission, "acquireRun">;
+  readonly resolveSession: (input: AgentLoopInput) => Promise<PiAgentSessionHandle$1> | PiAgentSessionHandle$1;
+}
+interface PiCreateAgentSessionResult {
+  readonly session: PiAgentSession;
+}
+interface PiSdkAgentLoopOptions<TSessionOptions = unknown> {
+  readonly supportsSteering?: boolean;
+  readonly createAgentSession: (options: TSessionOptions | undefined) => Promise<PiCreateAgentSessionResult> | PiCreateAgentSessionResult;
+  readonly sessionOptions?: TSessionOptions;
+}
+declare function createPiAgentLoop$1(options: PiAgentLoopOptions$1): AgentLoop;
+declare function createPiSdkAgentLoop$1<TSessionOptions = unknown>(options: PiSdkAgentLoopOptions<TSessionOptions>): AgentLoop;
+//#endregion
+//#region src/adapters/pi/execution/pi-session-prompts.d.ts
+interface PiSessionPromptOptions {
+  readonly input: AgentLoopInput;
+  readonly handle: PiAgentSessionHandle$1;
+  readonly supportsSteering: boolean;
+  readonly abort: () => Promise<void>;
+}
+/** One ordinary prompt writer, with ordered native steering while that prompt is streaming. */
+declare function runPiSessionPrompts(options: PiSessionPromptOptions): Promise<void>;
+//#endregion
+//#region src/adapters/pi/execution/pi-session-registry.d.ts
+interface PiSessionRegistryOptions$1 {
+  readonly createSession: (input: AgentLoopInput) => Promise<PiAgentSessionHandle$1> | PiAgentSessionHandle$1;
+}
+interface PiSessionRegistry$1 {
+  list(): Promise<ReadonlyArray<PiAgentSessionHandle$1>>;
+  resolve(input: AgentLoopInput): Promise<PiAgentSessionHandle$1>;
+  size(): number;
+  dispose(sessionKey: SessionKey): Promise<void>;
+  disposeAll(): Promise<void>;
+}
+declare function createPiSessionRegistry$1(options: PiSessionRegistryOptions$1): PiSessionRegistry$1;
+//#endregion
+//#region src/adapters/pi/model-management/pi-model-resolution.d.ts
+/**
+ * Model metadata needed at the Runtime boundary. The provider SDK model is
+ * represented structurally so this public entrypoint does not expose its
+ * transitive provider declaration graph.
+ */
+interface PiModel extends PiModelDefinitionBase {
+  readonly input: Array<"image" | "text">;
+  readonly provider: string;
+}
+type PiModelTextContent = {
+  readonly type: "text";
+  readonly text: string;
+  readonly textSignature?: string;
+};
+type PiModelImageContent = {
+  readonly type: "image";
+  readonly data: string;
+  readonly mimeType: string;
+};
+type PiModelThinkingContent = {
+  readonly type: "thinking";
+  readonly thinking: string;
+  readonly thinkingSignature?: string;
+  readonly redacted?: boolean;
+};
+type PiModelToolCall = {
+  readonly type: "toolCall";
+  readonly id: string;
+  readonly name: string;
+  readonly arguments: Record<string, unknown>;
+  readonly thoughtSignature?: string;
+  readonly namespace?: string;
+};
+type PiModelUsage = {
+  readonly input: number;
+  readonly output: number;
+  readonly cacheRead: number;
+  readonly cacheWrite: number;
+  readonly totalTokens: number;
+  readonly cost: Readonly<{
+    readonly input: number;
+    readonly output: number;
+    readonly cacheRead: number;
+    readonly cacheWrite: number;
+    readonly total: number;
+  }>;
+};
+type PiModelUserMessage = {
+  readonly role: "user";
+  readonly content: string | Array<PiModelTextContent | PiModelImageContent>;
+  readonly timestamp: number;
+};
+type PiModelAssistantMessage = {
+  readonly role: "assistant";
+  readonly content: Array<PiModelTextContent | PiModelThinkingContent | PiModelToolCall>;
+  readonly api: string;
+  readonly provider: string;
+  readonly model: string;
+  readonly responseModel?: string;
+  readonly responseId?: string;
+  readonly usage: PiModelUsage;
+  readonly stopReason: "pending" | "stop" | "length" | "toolUse" | "error" | "aborted" | "deferred";
+  readonly errorMessage?: string;
+  readonly timestamp: number;
+};
+type PiModelToolResultMessage = {
+  readonly role: "toolResult";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly content: Array<PiModelTextContent | PiModelImageContent>;
+  readonly details?: unknown;
+  readonly usage?: PiModelUsage;
+  readonly addedToolNames?: string[];
+  readonly isError: boolean;
+  readonly timestamp: number;
+};
+type PiModelMessage = PiModelUserMessage | PiModelAssistantMessage | PiModelToolResultMessage;
+type PiModelTool = {
+  readonly name: string;
+  readonly description: string;
+  readonly parameters: TSchema;
+};
+/** Provider-neutral context accepted by the Runtime's bounded Pi model calls. */
+interface PiModelContext {
+  readonly systemPrompt?: string;
+  readonly messages: PiModelMessage[];
+  readonly tools?: PiModelTool[];
+}
+type PiModelReasoningLevel = "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+/** Only stream controls used by Runtime model probes are accepted at this boundary. */
+interface PiModelStreamOptions {
+  readonly signal?: AbortSignal;
+  readonly maxTokens?: number;
+  readonly maxRetries?: number;
+  readonly maxRetryDelayMs?: number;
+  readonly reasoning?: PiModelReasoningLevel;
+}
+interface PiModelRuntimePort {
+  getModels(providerId?: string): ReadonlyArray<PiModel>;
+  getProvider(providerId: string): unknown;
+  getModel(providerId: string, modelId: string): PiModel | undefined;
+  getRegisteredProviderIds(): ReadonlyArray<string>;
+  refresh(options?: {
+    readonly allowNetwork?: boolean;
+    readonly providers?: ReadonlyArray<string>;
+    readonly signal?: AbortSignal;
+  }): Promise<{
+    readonly errors: ReadonlyMap<string, Error>;
+  }>;
+  setRuntimeApiKey(providerId: string, apiKey: string): Promise<void>;
+  streamSimple(model: PiModel, context: PiModelContext, options?: PiModelStreamOptions): PiModelStream;
+}
+interface PiModelStream extends AsyncIterable<unknown> {
+  result(): Promise<unknown>;
+}
+interface ResolvePiModelOptions {
+  readonly modelRuntime: PiModelRuntimePort;
+  readonly target: ModelReference;
+}
+interface EnsurePiModelOptions extends ResolvePiModelOptions {
+  /** models.json path configured on the ModelRuntime. */
+  readonly modelsPath: string;
+  readonly signal?: AbortSignal;
+}
+interface ResolvedPiModel {
+  readonly binding: ModelBinding;
+  readonly model: PiModel;
+}
+declare class PiModelResolutionError extends Error {
+  readonly name = "PiModelResolutionError";
+  readonly code: "model_change_provider_unsupported" | "model_change_target_unsupported";
+  readonly resolutionCode: "invalid-reference" | "provider-unknown" | "model-unknown";
+  constructor(resolutionCode: PiModelResolutionError["resolutionCode"], message: string);
+}
+/**
+ * Resolve one exact provider/model pair from the installed Pi model runtime.
+ *
+ * Model aliases and fuzzy matches are intentionally excluded here. Natural-language
+ * interpretation belongs to the application/Agent; the activation boundary must bind
+ * to the exact model that the SDK can actually construct.
+ */
+declare function resolvePiModel(options: ResolvePiModelOptions): PiModel;
+/**
+ * Ensure metadata for an exact model id that is absent from the installed SDK
+ * catalog, then recompose the provider from models.json. Phase 1 only ships the
+ * verified DeepSeek declaration required by the management contract; all other
+ * unknown ids fail closed and must be supplied by a future explicit catalog path.
+ */
+declare function ensurePiModel(options: EnsurePiModelOptions): Promise<PiModel>;
+declare function resolvePiModelBinding(options: {
+  readonly bindingRevision: string;
+  readonly modelRuntime: PiModelRuntimePort;
+  readonly target: ModelReference;
+}): ResolvedPiModel;
+interface RefreshPiModelCatalogOptions {
+  readonly allowNetwork?: boolean;
+  readonly provider?: string;
+  readonly signal?: AbortSignal;
+}
+interface RefreshPiModelCatalogResult {
+  readonly errors: ReadonlyMap<string, Error>;
+  readonly refreshedProviders: ReadonlyArray<string>;
+}
+/** Refresh installed SDK metadata, retaining the SDK's persisted declarative catalog. */
+declare function refreshPiModelCatalog(modelRuntime: PiModelRuntimePort, options?: RefreshPiModelCatalogOptions): Promise<RefreshPiModelCatalogResult>;
+declare function samePiProvider(left: ModelReference, right: ModelReference): boolean;
+//#endregion
+//#region src/adapters/pi/model-management/pi-model-probe.d.ts
+declare const PI_MODEL_PROBE_TOOL_NAME = "rivus_model_management_probe";
+declare const PI_MODEL_PROBE_TOOL_RESULT = "RIVUS_MODEL_PROBE_TOOL_OK";
+declare const PI_MODEL_PROBE_FOLLOWUP_RESULT = "RIVUS_MODEL_PROBE_FOLLOWUP_OK";
+interface PiModelProbeBudget {
+  readonly deadlineAt: string;
+  readonly reservePaidCall: (input: {
+    readonly kind: ModelChangePaidCallKind;
+    readonly maxOutputTokens?: number;
+  }) => Effect.Effect<ModelChangeBudgetReservation, unknown>;
+  readonly settlePaidCall: (input: {
+    readonly outcome: "known" | "unknown";
+    readonly outputTokens: number;
+    readonly reservation: ModelChangeBudgetReservation;
+  }) => Effect.Effect<void, unknown>;
+}
+interface PiModelProbeOptions {
+  readonly budget: PiModelProbeBudget;
+  readonly model: PiModel;
+  readonly modelRuntime: PiModelRuntimePort;
+  readonly signal?: AbortSignal;
+  readonly thinkingLevel: PiThinkingLevel;
+}
+type PiThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+interface PiModelProbeTurn {
+  readonly assistant: {
+    readonly content: ReadonlyArray<unknown>;
+    readonly model: string;
+    readonly provider: string;
+    readonly stopReason: string;
+    readonly usage: Readonly<Record<string, unknown>>;
+  };
+  readonly kind: "initial" | "tool-result" | "follow-up";
+  readonly reservationId: string;
+  readonly toolResult?: {
+    readonly content: string;
+    readonly toolCallId: string;
+    readonly toolName: string;
+  };
+}
+interface PiModelProbeResult {
+  readonly assistantThinkingBlocks: number;
+  readonly followupText: string;
+  readonly model: {
+    readonly id: string;
+    readonly provider: string;
+  };
+  readonly outputTokens: number;
+  readonly passed: true;
+  readonly thinkingLevel: PiThinkingLevel;
+  readonly toolResultText: string;
+  readonly toolCallId: string;
+  readonly toolName: typeof PI_MODEL_PROBE_TOOL_NAME;
+  readonly transcript: ReadonlyArray<PiModelProbeTurn>;
+}
+interface PiModelCanaryOptions {
+  readonly budget: PiModelProbeBudget;
+  readonly kind: Extract<ModelChangePaidCallKind, "activation" | "restore">;
+  readonly model: PiModel;
+  readonly modelRuntime: PiModelRuntimePort;
+  readonly signal?: AbortSignal;
+  readonly thinkingLevel: PiThinkingLevel;
+}
+interface PiModelCanaryResult {
+  readonly assistant: PiModelProbeTurn["assistant"];
+  readonly outputTokens: number;
+}
+declare class PiModelProbeError extends Error {
+  readonly name = "PiModelProbeError";
+  readonly code: "model_change_deadline_exceeded" | "model_change_probe_failed";
+  readonly outcome: "known" | "unknown";
+  constructor(message: string, outcome: "known" | "unknown", options?: ErrorOptions, code?: PiModelProbeError["code"]);
+}
+/**
+ * Exercise a candidate through the same Pi model runtime used by business runs.
+ * The probe builds an in-memory synthetic context, performs an actual streamed
+ * tool call, feeds the real fixed tool result into a second streamed request, and
+ * then sends a separate follow-up request. It never loads a persisted transcript
+ * or exposes business tools.
+ */
+declare function probePiModel(options: PiModelProbeOptions): Effect.Effect<PiModelProbeResult, unknown>;
+/** Run one bounded, synthetic request for activation/recovery canaries. */
+declare function runPiModelCanary(options: PiModelCanaryOptions): Effect.Effect<PiModelCanaryResult, unknown>;
+//#endregion
+//#region src/adapters/pi/model-management/pi-model-runtime.d.ts
+/** Minimal session collection needed by model changes; compatibility registries can implement it directly. */
+interface PiModelSessionRegistry {
+  readonly list: () => Promise<ReadonlyArray<Pick<PiAgentSessionHandle$1, "refreshResources" | "session">>>;
+}
+interface CreatePiModelRuntimeOptions {
+  readonly initial?: {
+    readonly binding: ModelBinding;
+    readonly model: PiModel;
+    readonly thinkingLevel: PiThinkingLevel;
+  };
+  readonly modelCatalogPath?: string;
+  readonly modelRuntime: PiModelRuntimePort;
+  readonly sessionRegistries?: ReadonlyArray<PiModelSessionRegistry>;
+}
+interface PiModelRuntime extends ModelChangeRuntimePort {
+  /**
+   * Set the committed startup selection after Home state has been opened.
+   * This path resolves metadata only; paid probes belong to managed changes.
+   */
+  readonly initializeSelection: (input: {
+    readonly binding: ModelBinding;
+    readonly thinkingLevel: PiThinkingLevel;
+  }) => Effect.Effect<void, unknown>;
+  /** Read current authoritative Pi session options at creation time. */
+  readonly getSessionOptions: () => {
+    readonly model?: PiModel;
+    readonly thinkingLevel?: PiThinkingLevel;
+  };
+  readonly registerSessionRegistry: (registry: PiModelSessionRegistry) => () => void;
+  readonly refreshModelCatalog: (input?: {
+    readonly allowNetwork?: boolean;
+    readonly deadlineAt?: string;
+    readonly provider?: string;
+    readonly signal?: AbortSignal;
+  }) => Effect.Effect<void, unknown>;
+}
+declare class PiModelRuntimeMutationUnknownError extends Error {
+  readonly name = "PiModelRuntimeMutationUnknownError";
+  readonly outcome: "unknown";
+  constructor(message: string, options?: ErrorOptions);
+}
+declare class PiModelTargetCompatibilityError extends Error {
+  readonly name = "PiModelTargetCompatibilityError";
+  readonly code: "model_change_target_unsupported";
+}
+/**
+ * Adapter around Pi's live AgentSession instances.
+ *
+ * The application owns the safe Run boundary. Once that boundary is held, this
+ * adapter waits for every cached session, validates its persisted context, and
+ * calls AgentSession.setModel so the session manager and conversation history
+ * survive the switch. Disposing cached sessions would silently create a new
+ * transcript on the next Run and is therefore intentionally unsupported here.
+ */
+declare function createPiModelRuntime(options: CreatePiModelRuntimeOptions): PiModelRuntime;
+//#endregion
+//#region src/adapters/pi/model-management/pi-history-compatibility.d.ts
+interface PiHistoryCompatibility {
+  readonly assistantThinkingBlocks: number;
+  readonly assistantToolCalls: number;
+  readonly compatible: true;
+  readonly imageBlocks: number;
+  readonly messageCount: number;
+  readonly toolResults: number;
+}
+declare class PiHistoryCompatibilityError extends Error {
+  readonly name = "PiHistoryCompatibilityError";
+  readonly code: "model_change_history_incompatible";
+  readonly messageIndex: number;
+  constructor(message: string, messageIndex: number);
+}
+/**
+ * Check the structural parts of a persisted Pi transcript that providers need for
+ * the next request. The transcript is never returned or copied; only counts are
+ * exposed for diagnostics. This deliberately rejects orphaned tool calls/results
+ * instead of deleting or rewriting history during a model change.
+ */
+declare function inspectPiSessionHistory(sessionManager: PiSessionManager): PiHistoryCompatibility;
+declare function assertPiSessionHistoryCompatible(sessionManager: PiSessionManager): PiHistoryCompatibility;
+//#endregion
+//#region src/adapters/pi/runtime/pi-session-resources.d.ts
+interface CreatePiSessionResourcesOptions {
+  readonly agentDir: string;
+  readonly appendSystemPromptOverride?: (base: string[]) => string[];
+  readonly cwd: string;
+  readonly homeDirectory: string;
+  readonly projectSkillPaths?: ReadonlyArray<string>;
+  readonly settingsOverrides?: Readonly<Record<string, unknown>>;
+  readonly systemPromptOverride?: (base: string | undefined) => string | undefined;
+}
+interface PiSessionResources {
+  readonly bashToolOptions?: {
+    readonly commandPrefix?: string;
+    readonly shellPath?: string;
+  };
+  readonly skillNames: ReadonlySet<string>;
+  readonly skillPaths: ReadonlyArray<string>;
+  readonly refresh: () => Promise<void>;
+  readonly withSessionOptions: <Options extends object>(options: Options) => BoundPiSessionOptions<Options>;
+}
+type BoundPiSessionOptions<Options extends object> = Omit<Options, "agentDir" | "cwd" | "resourceLoader" | "settingsManager"> & {
+  readonly agentDir: string;
+  readonly cwd: string;
+};
+declare function createPiSessionResources(options: CreatePiSessionResourcesOptions): Promise<PiSessionResources>;
+//#endregion
+//#region src/adapters/pi/tool-execution/pi-tool-definition.d.ts
+type PiToolContent = {
+  readonly text: string;
+  readonly textSignature?: string;
+  readonly type: "text";
+} | {
+  readonly data: string;
+  readonly mimeType: string;
+  readonly type: "image";
+};
+interface PiToolResult<TDetails = unknown> {
+  readonly content: PiToolContent[];
+  readonly details: TDetails;
+  readonly terminate?: boolean;
+}
+interface PiToolDefinition<TDetails = unknown> {
+  readonly description: string;
+  readonly execute: (toolCallId: string, params: unknown, signal?: AbortSignal, onUpdate?: (result: PiToolResult<TDetails>) => void, context?: unknown) => Promise<PiToolResult<TDetails>>;
+  readonly executionMode?: "parallel" | "sequential";
+  readonly label: string;
+  readonly name: string;
+  readonly parameters: TSchema;
+  readonly promptGuidelines?: string[];
+  readonly promptSnippet?: string;
+}
+//#endregion
+//#region src/adapters/pi/runtime/pi-assembly.d.ts
+type PiAssemblySession = PiAgentSession & {
+  readonly dispose: () => void;
+};
+interface PiAssemblyOptions {
+  readonly cwd: string;
+  readonly agentDir: string;
+  readonly homeDirectory: string;
+  readonly authPath?: string;
+  readonly modelsPath?: string | null;
+  readonly allowModelNetwork?: boolean;
+  readonly defaultThinkingLevel?: PiThinkingLevel;
+  readonly settingsOverrides?: Readonly<Record<string, unknown>>;
+  readonly resourceOptions?: Omit<CreatePiSessionResourcesOptions, "cwd" | "agentDir" | "homeDirectory">;
+}
+interface PiAssemblySessionOptions {
+  readonly scopedModels?: ReadonlyArray<{
+    readonly model: PiModel;
+    readonly thinkingLevel?: PiThinkingLevel;
+  }>;
+  readonly noTools?: "all" | "builtin";
+  readonly tools?: ReadonlyArray<string>;
+  readonly excludeTools?: ReadonlyArray<string>;
+  readonly customTools?: ReadonlyArray<PiToolDefinition>;
+  readonly model?: PiModel;
+  /** Persist the session under this deployment-owned directory. */
+  readonly sessionDirectory?: string;
+  /** Keep the session header tied to the project workspace that owns the run. */
+  readonly sessionCwd?: string;
+  readonly thinkingLevel?: PiThinkingLevel;
+  readonly resources?: PiSessionResources;
+}
+interface PiAssemblySessionResult {
+  readonly session: PiAssemblySession;
+  readonly extensionsResult?: unknown;
+  readonly modelFallbackMessage?: string;
+  readonly dispose: () => void;
+  readonly refreshResources: () => Promise<void>;
+}
+interface PiAssembly {
+  readonly modelRuntime: PiModelRuntimePort;
+  readonly createSessionResources: () => Promise<PiSessionResources>;
+  readonly createSession: (options?: PiAssemblySessionOptions) => Promise<PiAssemblySessionResult>;
+  readonly resolveThinkingLevel: (provider?: string, modelId?: string) => PiThinkingLevel | undefined;
+  readonly dispose: () => Promise<void>;
+}
+declare function createPiAssembly(options: PiAssemblyOptions): Promise<PiAssembly>;
+//#endregion
+//#region src/adapters/pi/skills/pi-skill-catalog.d.ts
+interface PiSkillCatalogEntry {
+  readonly name: string;
+}
+interface PiSkillCatalogDiagnostic {
+  readonly message: string;
+  readonly path?: string;
+  readonly type: "warning" | "error" | "collision";
+}
+declare class InvalidPiSkillCatalog extends Error {
+  readonly name = "InvalidPiSkillCatalog";
+}
+declare function validatePiSkillCatalog(input: {
+  readonly diagnostics: ReadonlyArray<PiSkillCatalogDiagnostic>;
+  readonly skills: ReadonlyArray<PiSkillCatalogEntry>;
+}): ReadonlySet<string>;
+declare function validatePiSkillCommand(text: string, skillNames: ReadonlySet<string>): void;
+//#endregion
+//#region src/adapters/pi/skills/pi-skill-sources.d.ts
+declare class InvalidPiSkillSource extends Error {
+  readonly name = "InvalidPiSkillSource";
+}
+interface ResolvePiSkillSourcesOptions {
+  readonly agentDir: string;
+  readonly homeDirectory: string;
+  readonly projectSkillPaths?: ReadonlyArray<string>;
+}
+declare function resolvePiSkillSources(options: ResolvePiSkillSourcesOptions): Promise<ReadonlyArray<string>>;
+//#endregion
+//#region src/adapters/pi/skills/pi-skill-tool.d.ts
+declare const PI_SKILL_READER_TOOL_NAME = "rivus_read_skill";
+interface PiSkillReadDetails {
+  readonly contentLength: number;
+  readonly digest: string;
+  readonly skillId: string;
+  readonly title: string;
+  readonly version: string;
+}
+interface PiSkillRuntime {
+  readonly prompt: string;
+  readonly tool?: PiToolDefinition<PiSkillReadDetails>;
+}
+declare function createPiSkillRuntime(skills: ReadonlyArray<RegisteredRivusSkill>): PiSkillRuntime;
+//#endregion
+//#region src/adapters/pi/skills/pi-skill-read-tool.d.ts
+declare class ProjectSkillReadDenied extends Error {
+  readonly name = "ProjectSkillReadDenied";
+}
+declare function createPiSkillReadTool(options: {
+  readonly cwd: string;
+  readonly skillPaths: ReadonlyArray<string>;
+}): PiToolDefinition;
+declare const createPiProjectSkillReadTool: typeof createPiSkillReadTool;
+declare function createPiSkillReadTools(options: {
+  readonly cwd: string;
+  readonly runtimeToolIds: ReadonlyArray<RivusRuntimeToolId>;
+  readonly skillPaths: ReadonlyArray<string>;
+}): PiToolDefinition[];
+//#endregion
+//#region src/adapters/pi/skills/project-skill-catalog.d.ts
+interface ProjectSkillCatalogEntry {
+  readonly name: string;
+}
+interface ProjectSkillCatalogDiagnostic {
+  readonly message: string;
+  readonly path?: string;
+  readonly type: "warning" | "error" | "collision";
+}
+declare class InvalidProjectSkillCatalog extends Error {
+  readonly name = "InvalidProjectSkillCatalog";
+}
+declare function validateProjectSkillCatalog(input: {
+  readonly diagnostics: ReadonlyArray<ProjectSkillCatalogDiagnostic>;
+  readonly skills: ReadonlyArray<ProjectSkillCatalogEntry>;
+}): ReadonlySet<string>;
+declare function validateProjectSkillCommand(text: string, skillNames: ReadonlySet<string>): void;
+//#endregion
+//#region src/adapters/pi/tool-execution/pi-bash-tool-options.d.ts
+interface PiBashSpawnContext {
+  command: string;
+  cwd: string;
+  env: Record<string, string | undefined>;
+}
+/** Rivus's Bash configuration boundary, independent of provider UI/model types. */
+interface PiBashToolOptions {
+  commandPrefix?: string;
+  shellPath?: string;
+  spawnHook?: (context: PiBashSpawnContext) => PiBashSpawnContext;
+}
+//#endregion
+//#region src/adapters/pi/tool-execution/pi-bash-tool.d.ts
+/** Keep Pi's native execution, rendering and abort cleanup with a bounded default. */
+declare function createPiBashTool(cwd: string, options?: PiBashToolOptions): PiToolDefinition;
+//#endregion
+//#region src/adapters/pi/tool-execution/pi-tool-proxy.d.ts
+interface ToolBroker$1 {
+  execute(request: ToolExecutionRequest): Promise<unknown>;
+}
+interface PiToolApprovalRequest {
+  readonly agentId: string;
+  readonly allowedActorOpenIds: ReadonlyArray<string>;
+  readonly approvalId: string;
+  readonly callId: string;
+  readonly endpointId: string;
+  readonly inputDigest: string;
+  readonly instanceId: string;
+  readonly operationId: string;
+  readonly risk: RivusToolRisk;
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly signal?: AbortSignal;
+  readonly sourceMessageId: string;
+  readonly tenantKey: string;
+  readonly toolId: string;
+  readonly toolVersion: string;
+}
+interface PiToolApprovalGateway {
+  requestApproval(request: PiToolApprovalRequest): Promise<void>;
+}
+interface PiToolProxyOptions$1 {
+  readonly agentId: string;
+  readonly approvals: PiToolApprovalGateway;
+  readonly broker: ToolBroker$1;
+  readonly getActiveInput: () => AgentLoopInput | undefined;
+  readonly instanceId: string;
+  readonly memoryScopes?: ReadonlyArray<RivusMemoryScope>;
+  readonly toolGrantSet: RivusToolGrantSet;
+  readonly tools: ReadonlyArray<RivusResolvedToolDescriptor>;
+}
+declare function createPiToolProxyDefinitions$1(options: PiToolProxyOptions$1): PiToolDefinition[];
+declare function createPiToolNameResolver$1(tools: ReadonlyArray<Pick<RivusResolvedToolDescriptor, "id">>): (toolName: string) => string;
+//#endregion
+//#region src/adapters/pi/tool-execution/pi-session-tools.d.ts
+interface PiNamedTool {
+  readonly name: string;
+}
+declare function resolvePiSessionToolNames(runtimeToolIds: ReadonlyArray<RivusRuntimeToolId>, customTools: ReadonlyArray<PiNamedTool>): ReadonlyArray<string>;
+//#endregion
+//#region src/adapters/pi/tool-execution/pi-managed-run-binding.d.ts
+/**
+ * Policy-free Runtime binding for the per-Run managed Bash tool.
+ *
+ * The binding owns the single Bash tool cached per Pi Session and the mutable
+ * slot that holds the active Run's spawn hook and cleanup. It does not interpret
+ * invocation provenance, hold management references, or decide authorization;
+ * the injected Gateway provider supplies the active Run's hook.
+ */
+interface PiManagedRunInput {
+  readonly runId: string;
+  readonly sessionKey: string;
+  readonly abortSignal: AbortSignal;
+  /** Normalized invocation identity carried with the Run; provenance is decided by the Gateway provider. */
+  readonly invocation?: NormalizedAgentInvocation;
+}
+interface PiManagedRunProviderResult {
+  readonly spawnHook: NonNullable<PiBashToolOptions["spawnHook"]>;
+  readonly cleanup: () => void;
+}
+type PiManagedRunProvider = (run: PiManagedRunInput) => PiManagedRunProviderResult;
+interface PiManagedRunBindingOptions {
+  readonly bashToolOptions?: PiBashToolOptions;
+  readonly cwd: string;
+  readonly provider: PiManagedRunProvider;
+}
+declare function createPiManagedRunBinding(options: PiManagedRunBindingOptions): {
+  readonly activate: (run: PiManagedRunInput) => void;
+  readonly deactivate: () => void;
+  readonly tool: PiToolDefinition;
+};
+//#endregion
+//#region src/adapters/compatibility/agent-execution/pi/pi-agent-loop.d.ts
+interface PiAgentSessionHandle {
+  readonly session: PiAgentSession;
+  readonly resolveToolName?: (toolName: string) => string;
+  readonly preparePrompt?: (input: AgentLoopInput$1) => Promise<string> | string;
+  readonly dispose?: () => Promise<void> | void;
+  readonly activate?: (input: AgentLoopInput$1) => Promise<void> | void;
+  readonly deactivate?: () => Promise<void> | void;
+  readonly refreshResources?: () => Promise<void> | void;
+}
+interface PiAgentLoopOptions {
+  readonly supportsSteering?: boolean;
+  readonly resolveSession: (input: AgentLoopInput$1) => Promise<PiAgentSessionHandle> | PiAgentSessionHandle;
+  readonly modelContentObserver?: AgentModelContentObserver;
+  readonly disposeSessionAfterRun?: boolean;
+  readonly runBoundary?: {
+    readonly acquireRun: (input?: {
+      readonly deadlineAt?: string;
+      readonly signal?: AbortSignal;
+    }) => Effect.Effect<{
+      readonly release: () => void;
+    }, unknown>;
+  };
+}
+declare function createPiAgentLoop(options: PiAgentLoopOptions): AgentLoop$1;
+declare function createPiSdkAgentLoop<TSessionOptions = unknown>(options: PiSdkAgentLoopOptions<TSessionOptions>): AgentLoop$1;
+declare function toEffectPiAgentSessionHandle(handle: PiAgentSessionHandle): PiAgentSessionHandle$1;
+declare function fromEffectPiAgentSessionHandle(handle: PiAgentSessionHandle$1): PiAgentSessionHandle;
+//#endregion
+//#region src/adapters/compatibility/agent-execution/pi/pi-session-registry.d.ts
+interface PiSessionRegistryOptions {
+  readonly createSession: (input: AgentLoopInput$1) => Promise<PiAgentSessionHandle> | PiAgentSessionHandle;
+}
+interface PiSessionRegistry {
+  disposeAll(): Promise<void>;
+  dispose(sessionKey: SessionKey): Promise<void>;
+  list(): Promise<ReadonlyArray<PiAgentSessionHandle>>;
+  size(): number;
+  resolve(input: AgentLoopInput$1): Promise<PiAgentSessionHandle>;
+}
+declare function createPiSessionRegistry(options: PiSessionRegistryOptions): PiSessionRegistry;
+//#endregion
+//#region src/adapters/compatibility/agent-execution/pi/pi-tool-proxy.d.ts
+interface ToolBroker {
+  execute(request: ToolExecutionRequest): Promise<unknown>;
+}
+interface PiToolProxyOptions {
+  readonly agentId: string;
+  readonly instanceId: string;
+  readonly tools: ReadonlyArray<RivusResolvedToolDescriptor>;
+  readonly toolGrantSet: RivusToolGrantSet;
+  readonly broker: ToolBroker;
+  readonly approvals: PiToolApprovalGateway;
+  readonly getActiveInput: () => AgentLoopInput$1 | undefined;
+  readonly memoryScopes?: ReadonlyArray<RivusMemoryScope>;
+}
+declare function createPiToolProxyDefinitions(options: PiToolProxyOptions): PiToolDefinition[];
+declare function createPiToolNameResolver(tools: ReadonlyArray<Pick<RivusResolvedToolDescriptor, "id">>): (toolName: string) => string;
+//#endregion
+export { type CreatePiModelRuntimeOptions, type CreatePiSessionResourcesOptions, type EnsurePiModelOptions, InvalidPiSkillCatalog, InvalidPiSkillSource, InvalidProjectSkillCatalog, type PiAgentLoopOptions as LegacyPiAgentLoopOptions, type PiAgentSessionHandle as LegacyPiAgentSessionHandle, type PiSdkAgentLoopOptions as LegacyPiSdkAgentLoopOptions, type PiSdkAgentLoopOptions, type PiSessionRegistry as LegacyPiSessionRegistry, type PiSessionRegistryOptions as LegacyPiSessionRegistryOptions, type PiToolApprovalGateway as LegacyPiToolApprovalGateway, type PiToolApprovalGateway, type PiToolApprovalRequest as LegacyPiToolApprovalRequest, type PiToolApprovalRequest, type PiToolProxyOptions as LegacyPiToolProxyOptions, type MergePiProviderBaseUrlOverrideOptions, type MergePiProviderModelDeclarationOptions, PI_MODEL_PROBE_FOLLOWUP_RESULT, PI_MODEL_PROBE_TOOL_NAME, PI_MODEL_PROBE_TOOL_RESULT, PI_SKILL_READER_TOOL_NAME, type PiAgentLoopOptions$1 as PiAgentLoopOptions, type PiAgentSession, type PiAgentSessionEvent, type PiAgentSessionHandle$1 as PiAgentSessionHandle, type PiAssembly, type PiAssemblyOptions, type PiAssemblySessionOptions, type PiAssemblySessionResult, type PiBashToolOptions, type PiCreateAgentSessionResult, type PiDeclarativeModelDefinition, type PiHistoryCompatibility, PiHistoryCompatibilityError, type PiManagedRunBindingOptions, type PiManagedRunInput, type PiManagedRunProvider, type PiManagedRunProviderResult, type PiMessageEndEvent, type PiMessageStartEvent, type PiMessageUpdateEvent, type PiModel, type PiModelCanaryOptions, type PiModelCanaryResult, type PiModelContext, type PiModelProbeBudget, PiModelProbeError, type PiModelProbeOptions, type PiModelProbeResult, type PiModelProbeTurn, PiModelResolutionError, type PiModelRuntime, PiModelRuntimeMutationUnknownError, type PiModelRuntimePort, type PiModelSessionRegistry, type PiModelStream, type PiModelStreamOptions, PiModelTargetCompatibilityError, type PiNamedTool, type PiSessionContext, type PiSessionManager, type PiSessionRegistry$1 as PiSessionRegistry, type PiSessionRegistryOptions$1 as PiSessionRegistryOptions, type PiSessionResources, type PiSkillCatalogDiagnostic, type PiSkillCatalogEntry, type PiSkillReadDetails, type PiSkillRuntime, type PiThinkingLevel, type PiToolContent, type PiToolDefinition, type PiToolExecutionEndEvent, type PiToolExecutionStartEvent, type PiToolExecutionUpdateEvent, type PiToolProxyOptions$1 as PiToolProxyOptions, type PiToolResult, type ProjectSkillCatalogDiagnostic, type ProjectSkillCatalogEntry, ProjectSkillReadDenied, type RefreshPiModelCatalogOptions, type RefreshPiModelCatalogResult, type ResolvePiModelOptions, type ResolvePiSkillSourcesOptions, type ResolvedPiModel, assertPiSessionHistoryCompatible, createPiAgentLoop as createLegacyPiAgentLoop, createPiSdkAgentLoop as createLegacyPiSdkAgentLoop, createPiSessionRegistry as createLegacyPiSessionRegistry, createPiToolNameResolver as createLegacyPiToolNameResolver, createPiToolProxyDefinitions as createLegacyPiToolProxyDefinitions, createPiAgentLoop$1 as createPiAgentLoop, createPiAssembly, createPiBashTool, createPiManagedRunBinding, createPiModelRuntime, createPiProjectSkillReadTool, createPiSdkAgentLoop$1 as createPiSdkAgentLoop, createPiSessionRegistry$1 as createPiSessionRegistry, createPiSessionResources, createPiSkillReadTool, createPiSkillReadTools, createPiSkillRuntime, createPiToolNameResolver$1 as createPiToolNameResolver, createPiToolProxyDefinitions$1 as createPiToolProxyDefinitions, ensurePiModel, fromEffectPiAgentSessionHandle as fromEffectLegacyPiAgentSessionHandle, inspectPiSessionHistory, mergePiProviderBaseUrlOverride, mergePiProviderModelDeclaration, probePiModel, refreshPiModelCatalog, resolvePiModel, resolvePiModelBinding, resolvePiSessionToolNames, resolvePiSkillSources, runPiModelCanary, runPiSessionPrompts, samePiProvider, toEffectPiAgentSessionHandle as toEffectLegacyPiAgentSessionHandle, validatePiSkillCatalog, validatePiSkillCommand, validateProjectSkillCatalog, validateProjectSkillCommand };