@rivus/runtime 0.16.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PerfectPan
+
+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,5 @@
+# @rivus/runtime
+
+Standalone agent execution runtime for Rivus, including the Pi and ACP adapters, memory, tool execution, and run history.
+
+Use the root entrypoint for execution contracts, `@rivus/runtime/pi` for Pi assembly, and `@rivus/runtime/acp` for ACP.

package/dist/acp.d.ts

@@ -0,0 +1,179 @@
+import { C as AgentLoopInput, a as AgentLoopInput$1, b as AgentLoop, t as AgentLoop$1 } from "./chunks/agent-loop.js";
+import * as acp from "@agentclientprotocol/sdk";
+
+//#region src/adapters/acp/runtime/acp-agent-loop.d.ts
+type AcpToolCallStatus = "pending" | "in_progress" | "completed" | "failed";
+interface AcpSessionUpdate {
+  readonly content?: unknown;
+  readonly name?: string | null;
+  readonly rawInput?: unknown;
+  readonly rawOutput?: unknown;
+  readonly sessionUpdate: string;
+  readonly status?: AcpToolCallStatus | null;
+  readonly title?: string | null;
+  readonly toolCallId?: string;
+  readonly [key: string]: unknown;
+}
+interface AcpPromptResult {
+  readonly stopReason: string;
+}
+interface AcpAgentSession {
+  cancel(options?: {
+    readonly preserveSession?: boolean;
+  }): Promise<void> | void;
+  prompt(text: string, onUpdate: (update: AcpSessionUpdate) => void): Promise<AcpPromptResult>;
+  dispose?(): Promise<void> | void;
+  invalidate?(): Promise<void> | void;
+}
+interface AcpAgentLoopOptions {
+  readonly cancellationSettleTimeoutMs?: number;
+  readonly disposeSessionAfterRun?: boolean;
+  readonly resolveSession: (input: AgentLoopInput) => Promise<AcpAgentSession> | AcpAgentSession;
+}
+declare function createAcpAgentLoop(options: AcpAgentLoopOptions): AgentLoop;
+//#endregion
+//#region src/adapters/acp/runtime/acp-permission-policy.d.ts
+interface AcpPermissionOption {
+  readonly kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
+  readonly name: string;
+  readonly optionId: string;
+}
+interface AcpPermissionToolCall {
+  readonly toolCallId: string;
+  readonly title?: string;
+  readonly rawInput?: unknown;
+}
+interface AcpPermissionRequest {
+  readonly options: ReadonlyArray<AcpPermissionOption>;
+  readonly sessionId: string;
+  readonly toolCall: AcpPermissionToolCall;
+}
+interface AcpPermissionSelection {
+  readonly optionId: string;
+}
+type AcpPermissionDecision = {
+  readonly outcome: "cancelled";
+} | {
+  readonly optionId: string;
+  readonly outcome: "selected";
+};
+type AcpPermissionPolicy = (request: AcpPermissionRequest) => Promise<AcpPermissionSelection | undefined> | AcpPermissionSelection | undefined;
+interface AcpSessionPermissionContext {
+  readonly sessionKey: string;
+}
+type AcpSessionPermissionPolicy = (request: AcpPermissionRequest, context: AcpSessionPermissionContext) => Promise<AcpPermissionSelection | undefined> | AcpPermissionSelection | undefined;
+declare function decideAcpPermission(request: AcpPermissionRequest, policy?: AcpPermissionPolicy): Promise<AcpPermissionDecision>;
+//#endregion
+//#region src/adapters/acp/runtime/acp-permission-bridge.d.ts
+interface AcpPermissionBridge {
+  readonly policy: AcpSessionPermissionPolicy;
+  bind(sessionKey: string, policy: AcpPermissionPolicy): () => void;
+}
+declare function createAcpPermissionBridge(): AcpPermissionBridge;
+//#endregion
+//#region src/adapters/acp/runtime/acp-agent-server.d.ts
+interface AcpAgentServerOptions {
+  readonly agentName?: string;
+  readonly loop: AgentLoop;
+  readonly permissionBridge?: AcpPermissionBridge;
+  readonly workingDirectory: string;
+}
+declare function createAcpAgentServer(options: AcpAgentServerOptions): acp.AgentApp;
+declare function serveAcpAgentOnStdio(app: acp.AgentApp): Promise<void>;
+//#endregion
+//#region src/adapters/acp/runtime/acp-session-store.d.ts
+interface AcpSessionRecord {
+  readonly sessionId: string;
+}
+interface AcpSessionStore {
+  delete(sessionKey: string): Promise<void>;
+  load(sessionKey: string): Promise<AcpSessionRecord | undefined>;
+  save(sessionKey: string, record: AcpSessionRecord): Promise<void>;
+}
+interface JsonAcpSessionStoreOptions {
+  readonly filePath: string;
+}
+/**
+ * A small deployment-owned store for ACP provider session identities.
+ * The file contains no prompts or credentials, only session-key bindings.
+ */
+declare function createJsonAcpSessionStore(options: JsonAcpSessionStoreOptions): AcpSessionStore;
+//#endregion
+//#region src/adapters/acp/runtime/acp-stdio-agent-loop.d.ts
+interface AcpMcpServerEnvironmentVariable {
+  readonly name: string;
+  readonly value: string;
+}
+interface AcpMcpServer {
+  readonly args: ReadonlyArray<string>;
+  readonly command: string;
+  readonly env: ReadonlyArray<AcpMcpServerEnvironmentVariable>;
+  readonly name: string;
+}
+interface AcpStdioAgentLoopOptions {
+  readonly arguments?: ReadonlyArray<string>;
+  readonly clientName?: string;
+  readonly command: string;
+  readonly environment?: Readonly<Record<string, string>>;
+  readonly initializationTimeoutMs?: number;
+  readonly mcpServers?: (input: AgentLoopInput) => ReadonlyArray<AcpMcpServer>;
+  readonly onStderr?: (text: string) => void;
+  readonly permissionPolicy?: AcpSessionPermissionPolicy;
+  /** Persist provider session IDs so a restarted ACP child can load/resume them. */
+  readonly sessionStore?: AcpSessionStore;
+  readonly terminationTimeoutMs?: number;
+  readonly workingDirectory: string;
+}
+interface AcpStdioAgentLoopHandle {
+  readonly loop: AgentLoop;
+  dispose(): Promise<void>;
+}
+declare function createAcpStdioAgentLoop(options: AcpStdioAgentLoopOptions): AcpStdioAgentLoopHandle;
+declare class AcpSessionResumeUnavailable extends Error {
+  readonly sessionId: string;
+  readonly name = "AcpSessionResumeUnavailable";
+  constructor(sessionId: string);
+}
+declare class AcpSessionResumeFailed extends Error {
+  readonly sessionId: string;
+  readonly cause: unknown;
+  readonly name = "AcpSessionResumeFailed";
+  constructor(sessionId: string, cause: unknown);
+}
+//#endregion
+//#region src/adapters/compatibility/acp/acp-runtime.d.ts
+interface AcpAgentLoopOptions$1 {
+  readonly cancellationSettleTimeoutMs?: number;
+  readonly disposeSessionAfterRun?: boolean;
+  readonly resolveSession: (input: AgentLoopInput$1) => Promise<AcpAgentSession> | AcpAgentSession;
+}
+interface AcpAgentServerOptions$1 {
+  readonly loop: AgentLoop$1;
+  readonly workingDirectory: string;
+  readonly agentName?: string;
+  readonly permissionBridge?: AcpPermissionBridge;
+}
+interface AcpStdioAgentLoopOptions$1 {
+  readonly command: string;
+  readonly workingDirectory: string;
+  readonly mcpServers?: (input: AgentLoopInput$1) => ReadonlyArray<AcpMcpServer>;
+  /** Persist provider session IDs so a restarted ACP child can load/resume them. */
+  readonly sessionStore?: AcpSessionStore;
+  readonly permissionPolicy?: AcpSessionPermissionPolicy;
+  readonly environment?: Readonly<Record<string, string>>;
+  readonly arguments?: ReadonlyArray<string>;
+  readonly clientName?: string;
+  readonly initializationTimeoutMs?: number;
+  readonly terminationTimeoutMs?: number;
+  readonly onStderr?: (text: string) => void;
+}
+interface AcpStdioAgentLoopHandle$1 {
+  readonly loop: AgentLoop$1;
+  dispose(): Promise<void>;
+}
+declare function createAcpAgentLoop$1(options: AcpAgentLoopOptions$1): AgentLoop$1;
+declare function createAcpAgentServer$1(options: AcpAgentServerOptions$1): acp.AgentApp;
+declare function serveAcpAgentOnStdio$1(app: acp.AgentApp): Promise<void>;
+declare function createAcpStdioAgentLoop$1(options: AcpStdioAgentLoopOptions$1): AcpStdioAgentLoopHandle$1;
+//#endregion
+export { type AcpAgentLoopOptions, type AcpAgentServerOptions, type AcpAgentSession, type AcpMcpServer, type AcpMcpServerEnvironmentVariable, type AcpPermissionBridge, type AcpPermissionDecision, type AcpPermissionOption, type AcpPermissionPolicy, type AcpPermissionRequest, type AcpPermissionSelection, type AcpPermissionToolCall, type AcpPromptResult, type AcpSessionPermissionContext, type AcpSessionPermissionPolicy, type AcpSessionRecord, AcpSessionResumeFailed, AcpSessionResumeUnavailable, type AcpSessionStore, type AcpSessionUpdate, type AcpStdioAgentLoopHandle, type AcpStdioAgentLoopOptions, type AcpToolCallStatus, type JsonAcpSessionStoreOptions, type AcpAgentLoopOptions$1 as LegacyAcpAgentLoopOptions, type AcpAgentServerOptions$1 as LegacyAcpAgentServerOptions, type AcpStdioAgentLoopHandle$1 as LegacyAcpStdioAgentLoopHandle, type AcpStdioAgentLoopOptions$1 as LegacyAcpStdioAgentLoopOptions, createAcpAgentLoop, createAcpAgentServer, createAcpPermissionBridge, createAcpStdioAgentLoop, createJsonAcpSessionStore, createAcpAgentLoop$1 as createLegacyAcpAgentLoop, createAcpAgentServer$1 as createLegacyAcpAgentServer, createAcpStdioAgentLoop$1 as createLegacyAcpStdioAgentLoop, decideAcpPermission, serveAcpAgentOnStdio, serveAcpAgentOnStdio$1 as serveLegacyAcpAgentOnStdio };