@dudousxd/nestjs-agent-opencode 0.0.0-stage → 0.1.0

package/dist/durable/index.d.ts

@@ -0,0 +1,75 @@
+import { AgentEngine } from '@dudousxd/nestjs-agent';
+import { O as OpenCodeTurns, a as OpenCodeEngineSettings, b as OpenCodeHost, c as OpenCodeEngineOptions } from '../engine-C_WSZ0cZ.js';
+import { AgentRunner, AgentStore, AgentRunInput, AgentRunStartOptions, HumanReply } from '@dudousxd/nestjs-agent-core';
+import { WorkflowService } from '@dudousxd/nestjs-durable';
+import { RunGateway, WorkflowCtx } from '@dudousxd/nestjs-durable-core';
+import '@nestjs/common';
+import 'node:http';
+import '@modelcontextprotocol/sdk/server/index.js';
+
+/**
+ * Runs OpenCode turns as `@dudousxd/nestjs-durable` workflows ({@link OpenCodeRunWorkflow}): a
+ * person's decision is a durable signal, so a turn waiting on one survives restarts and is resumed
+ * by whichever process receives it. Needs a cross-process `TokenStreamSink` when more than one
+ * process serves the agent.
+ */
+declare class DurableOpenCodeAgentRunner implements AgentRunner {
+    private readonly workflows;
+    private readonly runs;
+    private readonly turns;
+    private readonly settings;
+    private readonly host;
+    private readonly store;
+    private readonly logger;
+    constructor(workflows: WorkflowService, runs: RunGateway, turns: OpenCodeTurns, settings: OpenCodeEngineSettings, host: OpenCodeHost, store: AgentStore);
+    runIdFor(input: AgentRunInput): string;
+    start(input: AgentRunInput, options?: AgentRunStartOptions): Promise<{
+        runId: string;
+    }>;
+    isRunActive(runId: string): Promise<boolean>;
+    /**
+     * Signal a person's reply into the run. Answers addressed at an approval (a call recorded with an
+     * approver; questions have none) are refused ({@link OpenCodeReplyMismatchError}, a 409) before
+     * they reach the workflow, which would otherwise spend its wait on them.
+     */
+    signal(runId: string, toolCallId: string, reply: HumanReply): Promise<void>;
+    /**
+     * Interrupt OpenCode, cancel the run in the runtime (a run parked on a person never runs its body
+     * again), and settle it here: the queue, the thread, the `cancelled` frame and the run row.
+     */
+    cancel(runId: string): Promise<void>;
+}
+
+declare const OPENCODE_RUN_WORKFLOW = "agent.opencode.run";
+/** The token a person's answer to `toolCallId` is signalled under — the library's own convention. */
+declare function decisionToken(runId: string, toolCallId: string): string;
+/**
+ * An OpenCode turn as a durable workflow:
+ *
+ *   begin → prompt → observe:0 → [ wait for a person (signal `tool:<run>:<call>`) → reply:n → observe:n+1 ]* → finish
+ *
+ * Every step is checkpointed. A turn parked on a person is a suspended run with a signal waiter: an
+ * API restart loses nothing, and the decision resumes it on whichever process takes it — replaying
+ * the steps from their checkpoints and replying to OpenCode from there (`OpenCodeTurns` rebuilds the
+ * live turn, and re-prompts a fresh session when OpenCode itself restarted meanwhile). A process
+ * that dies while OpenCode works re-runs that `observe` step, which catches up on what OpenCode
+ * asked while nobody listened.
+ */
+declare class OpenCodeRunWorkflow {
+    private readonly turns;
+    private readonly runs?;
+    constructor(turns: OpenCodeTurns, runs?: RunGateway | undefined);
+    run(ctx: WorkflowCtx, input: AgentRunInput): Promise<{
+        outcome: string;
+    }>;
+    private cancelled;
+}
+
+/**
+ * `openCode()` whose turns are durable workflows — `AgentModule.forRoot({ engine:
+ * openCodeDurable({ host }) })` next to a configured `DurableModule`. A turn waiting on a person
+ * survives restarts and is resumed by whichever process receives the decision.
+ */
+declare function openCodeDurable(options: OpenCodeEngineOptions): AgentEngine;
+
+export { DurableOpenCodeAgentRunner, OPENCODE_RUN_WORKFLOW, OpenCodeRunWorkflow, decisionToken, openCodeDurable };