@dudousxd/nestjs-agent-opencode 0.4.0 → 0.5.0

package/dist/{engine-BNNxQAFV.d.cts → engine-BX6MLzxs.d.cts}

@@ -18,6 +18,10 @@ interface OpenCodeClient {
             sessionID: string;
             text: string;
             files?: OpenCodePromptFile[];
+            /** Kept on the user message OpenCode records (the engine puts the run id there). */
+            metadata?: {
+                readonly [key: string]: OpenCodeJson;
+            };
         }): Promise<unknown>;
         /** Stops the running execution; OpenCode answers with `session.execution.interrupted`. */
         interrupt(args: {
@@ -87,17 +91,22 @@ interface OpenCodeClient {
             message?: string;
         }): Promise<unknown>;
     };
-    /** The session's messages, newest first with `order: 'desc'`. Optional (regenerate). */
+    /**
+     * The session's messages, newest first with `order: 'desc'`, a page at a time (`cursor.next`).
+     * Optional: rewinds a session (regenerate), and lets a turn resumed after a restart recover what
+     * the session said while nobody listened.
+     */
     message?: {
         list(args: {
             sessionID: string;
             order?: 'asc' | 'desc';
             limit?: number;
+            cursor?: string;
         }): Promise<{
-            data: Array<{
-                id: string;
-                type: string;
-            }>;
+            data: OpenCodeMessage[];
+            cursor?: {
+                next?: string | null;
+            };
         }>;
     };
     /** Register an MCP server at a location. Optional (exposing the module's tools). */
@@ -217,6 +226,39 @@ interface OpenCodeTokens {
         write: number;
     };
 }
+/**
+ * One of a session's messages, as `message.list` returns them — the fields the engine reads. A
+ * `user` message carries the prompt (`text`, `metadata`); an `assistant` message is one model step
+ * (`content`, `model`, `tokens`, `cost`, `error`); `idle` marks where an execution ended (`outcome`).
+ */
+interface OpenCodeMessage {
+    id: string;
+    type: string;
+    metadata?: {
+        readonly [key: string]: OpenCodeJson;
+    };
+    text?: string;
+    content?: OpenCodeMessagePart[];
+    model?: {
+        providerID: string;
+        id: string;
+    };
+    cost?: number;
+    tokens?: OpenCodeTokens;
+    error?: {
+        message?: string;
+    };
+    outcome?: string;
+}
+/** A part of an assistant message: its text, its reasoning, or a tool call and how it went. */
+interface OpenCodeMessagePart {
+    type: string;
+    text?: string;
+    id?: string;
+    name?: string;
+    /** A tool call's `{ status, input, error }` (a text part's is the provider's own: ignored). */
+    state?: unknown;
+}
 
 /** How an OpenCode execution ended. */
 type TurnOutcome = {
@@ -263,6 +305,24 @@ interface OpenCodeUsage {
 declare function emptyUsage(): OpenCodeUsage;
 /** `a + b`; a missing side (a milestone journaled before usage travelled) counts as nothing. */
 declare function addUsage(a: OpenCodeUsage | undefined, b: OpenCodeUsage | undefined): OpenCodeUsage;
+/**
+ * What a turn took from the session's assistant messages (by OpenCode message id), so a turn rebuilt
+ * after a restart takes only the rest. Journaled with every `ask` milestone: what was taken up to
+ * there is persisted (the message the ask hangs on) and its usage reported.
+ */
+interface TurnProgress {
+    /** Characters of text taken, per assistant message. */
+    text: Record<string, number>;
+    /** Characters of reasoning taken, per assistant message. */
+    reasoning: Record<string, number>;
+    /** Tool calls taken (OpenCode's call ids), and those whose result was taken too. */
+    called: string[];
+    settled: string[];
+    /** Assistant messages whose step's usage was counted. */
+    steps: string[];
+}
+/** What a turn says when it was rebuilt after a restart and the session left no answer for it. */
+declare const LOST_ANSWER_ERROR = "The answer was lost while the agent restarted; ask again.";
 /** The model a step ran on, as OpenCode names it (`session.step.started`). */
 interface StepModel {
     providerID: string;
@@ -283,6 +343,7 @@ type Milestone = {
     ask: PendingAsk;
     timeoutMs?: number;
     usage?: OpenCodeUsage;
+    progress?: TurnProgress;
 } | {
     kind: 'finished';
     outcome: TurnOutcome;
@@ -319,6 +380,14 @@ interface OpenCodeTurnArgs {
     }) => Promise<StepCost>;
     /** What the run spent before this turn object existed (an earlier process, an earlier session). */
     carried?: OpenCodeUsage;
+    /** What the turn took before this turn object existed (the last `ask` milestone's progress). */
+    progress?: TurnProgress;
+    /**
+     * Rebuilt in a process that was not listening while the session ran (a durable `observe` re-run
+     * after a restart): when the execution ends, what the session said in between is read back from
+     * its messages.
+     */
+    resumed?: boolean;
     logger: Logger;
     /**
      * An action OpenCode was allowed to run (a person approved it, or the policy did): the approval
@@ -377,6 +446,8 @@ declare class OpenCodeTurn {
     private wroteMessage;
     private ended;
     private stepError;
+    /** What this turn object took from the session's assistant messages (see {@link TurnProgress}). */
+    private readonly took;
     constructor(a: OpenCodeTurnArgs);
     /**
      * What the session had spent before this turn prompted it (`session.get`). When the execution
@@ -388,6 +459,8 @@ declare class OpenCodeTurn {
         cost?: number;
         tokens?: OpenCodeTokens;
     } | undefined): void;
+    /** What the turn took so far: carried from before this turn object, plus what it took. */
+    progress(): TurnProgress;
     /** What the run spent so far: carried from before this turn object, plus what it saw. */
     totalUsage(): OpenCodeUsage;
     get sessionId(): string;
@@ -431,6 +504,8 @@ declare class OpenCodeTurn {
     private setInput;
     private innerCalls;
     private onEvent;
+    /** Characters taken from an assistant message's text or reasoning. */
+    private count;
     private settleTool;
     private modelId;
     /** One model call's usage and cost, into the ledger and the run's total. */
@@ -456,6 +531,23 @@ declare class OpenCodeTurn {
     private addResult;
     /** What the session spent since the baseline that no event of this turn reported. */
     private unreported;
+    /**
+     * The session's messages since this turn's prompt, oldest first: everything after its newest user
+     * message. `undefined` when they cannot be read (no `message.list`, no prompt within reach); empty
+     * when the newest prompt is another run's (this turn's never reached the session).
+     */
+    private messagesSincePrompt;
+    /**
+     * A turn rebuilt after a restart heard only what the session said once it re-attached: what it
+     * said in between — read back from the session's messages since the prompt, less what an earlier
+     * process already took ({@link TurnProgress}) and what this one heard — is taken now, as its
+     * events would have been: text, reasoning, tool calls and results, each step's usage. A session
+     * that left nothing for the turn fails it ({@link LOST_ANSWER_ERROR}) rather than reading as an
+     * empty answer.
+     */
+    private recover;
+    /** A tool part of a message the turn did not hear: its call, its result, whichever it lacks. */
+    private missedTool;
     private end;
 }
 /**
@@ -928,14 +1020,16 @@ declare class OpenCodeTurns implements OnApplicationShutdown {
      *
      * `spent` is what the run spent before (the sum of the `usage` of its earlier milestones): a turn
      * rebuilt here starts from it, so the answer it persists carries the whole run's usage.
+     * `progress` is what the turn took before (its last `ask` milestone's): a turn rebuilt here reads
+     * back from the session's messages, when the execution ends, what nobody heard after that.
      */
-    observe(runId: string, input: AgentRunInput, handle: SessionHandle, spent?: OpenCodeUsage): Promise<Milestone>;
+    observe(runId: string, input: AgentRunInput, handle: SessionHandle, spent?: OpenCodeUsage, progress?: TurnProgress): Promise<Milestone>;
     /**
      * Hand a person's answer back to OpenCode. When the server restarted while the turn waited, the
      * request is gone with it: a new session is opened, told what the person decided, and prompted
      * to go on.
      */
-    reply(runId: string, input: AgentRunInput, handle: SessionHandle, ask: PendingAsk, reply: HumanReply, spent?: OpenCodeUsage): Promise<SessionHandle>;
+    reply(runId: string, input: AgentRunInput, handle: SessionHandle, ask: PendingAsk, reply: HumanReply, spent?: OpenCodeUsage, progress?: TurnProgress): Promise<SessionHandle>;
     private continueAfterRestart;
     /** What a session spent so far (`session.get`), or nothing when OpenCode does not say. */
     private sessionUsage;
@@ -1000,4 +1094,4 @@ declare function openCodeControllers(options: OpenCodeEngineSettings): Type<obje
 /** The providers every OpenCode engine needs: host, session store, settings and the turn steps. */
 declare function openCodeProviders(options: OpenCodeEngineOptions): Provider[];
 
-export { OpenCodeTurn as A, type OpenCodeTurnContext as B, type OpenCodeUsage as C, type StepCost as D, type StepModel as E, addUsage as F, emptyUsage as G, keyValueOpenCodeSessionStore as H, InMemoryOpenCodeSessionStore as I, openCode as J, openCodeControllers as K, openCodeProviders as L, type Milestone as M, usageOf as N, OpenCodeTurns as O, type PendingAsk as P, type SessionHandle as S, type TurnOutcome as T, type OpenCodeEngineSettings as a, type OpenCodeHost as b, type OpenCodeEngineOptions as c, type OpenCodeClient as d, type OpenCodeEvent as e, type OpenCodeForm as f, type OpenCodeFormValue as g, type OpenCodeFormField as h, OpenCodeMcpEndpoint as i, type OpenCodeAmendment as j, type OpenCodeCallContext as k, type OpenCodeKeyValue as l, type OpenCodeModelRef as m, type OpenCodePermissionRequest as n, type OpenCodePermissionRule as o, OpenCodeReplyMismatchError as p, type OpenCodeRunResult as q, type OpenCodeServer as r, type OpenCodeSessionCreate as s, type OpenCodeSessionRef as t, type OpenCodeSessionStore as u, type OpenCodeToolCall as v, OpenCodeToolRefusedError as w, type OpenCodeToolsClaims as x, type OpenCodeToolsOptions as y, OpenCodeToolsTokens as z };
+export { type OpenCodeToolsOptions as A, OpenCodeToolsTokens as B, OpenCodeTurn as C, type OpenCodeTurnContext as D, type OpenCodeUsage as E, type StepCost as F, type StepModel as G, type TurnProgress as H, InMemoryOpenCodeSessionStore as I, addUsage as J, emptyUsage as K, LOST_ANSWER_ERROR as L, type Milestone as M, keyValueOpenCodeSessionStore as N, OpenCodeTurns as O, type PendingAsk as P, openCode as Q, openCodeControllers as R, type SessionHandle as S, type TurnOutcome as T, openCodeProviders as U, usageOf as V, type OpenCodeEngineSettings as a, type OpenCodeHost as b, type OpenCodeEngineOptions as c, type OpenCodeClient as d, type OpenCodeEvent as e, type OpenCodeForm as f, type OpenCodeFormValue as g, type OpenCodeFormField as h, OpenCodeMcpEndpoint as i, type OpenCodeAmendment as j, type OpenCodeCallContext as k, type OpenCodeKeyValue as l, type OpenCodeMessage as m, type OpenCodeMessagePart as n, type OpenCodeModelRef as o, type OpenCodePermissionRequest as p, type OpenCodePermissionRule as q, OpenCodeReplyMismatchError as r, type OpenCodeRunResult as s, type OpenCodeServer as t, type OpenCodeSessionCreate as u, type OpenCodeSessionRef as v, type OpenCodeSessionStore as w, type OpenCodeToolCall as x, OpenCodeToolRefusedError as y, type OpenCodeToolsClaims as z };

package/dist/{engine-BNNxQAFV.d.ts → engine-BX6MLzxs.d.ts}

@@ -18,6 +18,10 @@ interface OpenCodeClient {
             sessionID: string;
             text: string;
             files?: OpenCodePromptFile[];
+            /** Kept on the user message OpenCode records (the engine puts the run id there). */
+            metadata?: {
+                readonly [key: string]: OpenCodeJson;
+            };
         }): Promise<unknown>;
         /** Stops the running execution; OpenCode answers with `session.execution.interrupted`. */
         interrupt(args: {
@@ -87,17 +91,22 @@ interface OpenCodeClient {
             message?: string;
         }): Promise<unknown>;
     };
-    /** The session's messages, newest first with `order: 'desc'`. Optional (regenerate). */
+    /**
+     * The session's messages, newest first with `order: 'desc'`, a page at a time (`cursor.next`).
+     * Optional: rewinds a session (regenerate), and lets a turn resumed after a restart recover what
+     * the session said while nobody listened.
+     */
     message?: {
         list(args: {
             sessionID: string;
             order?: 'asc' | 'desc';
             limit?: number;
+            cursor?: string;
         }): Promise<{
-            data: Array<{
-                id: string;
-                type: string;
-            }>;
+            data: OpenCodeMessage[];
+            cursor?: {
+                next?: string | null;
+            };
         }>;
     };
     /** Register an MCP server at a location. Optional (exposing the module's tools). */
@@ -217,6 +226,39 @@ interface OpenCodeTokens {
         write: number;
     };
 }
+/**
+ * One of a session's messages, as `message.list` returns them — the fields the engine reads. A
+ * `user` message carries the prompt (`text`, `metadata`); an `assistant` message is one model step
+ * (`content`, `model`, `tokens`, `cost`, `error`); `idle` marks where an execution ended (`outcome`).
+ */
+interface OpenCodeMessage {
+    id: string;
+    type: string;
+    metadata?: {
+        readonly [key: string]: OpenCodeJson;
+    };
+    text?: string;
+    content?: OpenCodeMessagePart[];
+    model?: {
+        providerID: string;
+        id: string;
+    };
+    cost?: number;
+    tokens?: OpenCodeTokens;
+    error?: {
+        message?: string;
+    };
+    outcome?: string;
+}
+/** A part of an assistant message: its text, its reasoning, or a tool call and how it went. */
+interface OpenCodeMessagePart {
+    type: string;
+    text?: string;
+    id?: string;
+    name?: string;
+    /** A tool call's `{ status, input, error }` (a text part's is the provider's own: ignored). */
+    state?: unknown;
+}
 
 /** How an OpenCode execution ended. */
 type TurnOutcome = {
@@ -263,6 +305,24 @@ interface OpenCodeUsage {
 declare function emptyUsage(): OpenCodeUsage;
 /** `a + b`; a missing side (a milestone journaled before usage travelled) counts as nothing. */
 declare function addUsage(a: OpenCodeUsage | undefined, b: OpenCodeUsage | undefined): OpenCodeUsage;
+/**
+ * What a turn took from the session's assistant messages (by OpenCode message id), so a turn rebuilt
+ * after a restart takes only the rest. Journaled with every `ask` milestone: what was taken up to
+ * there is persisted (the message the ask hangs on) and its usage reported.
+ */
+interface TurnProgress {
+    /** Characters of text taken, per assistant message. */
+    text: Record<string, number>;
+    /** Characters of reasoning taken, per assistant message. */
+    reasoning: Record<string, number>;
+    /** Tool calls taken (OpenCode's call ids), and those whose result was taken too. */
+    called: string[];
+    settled: string[];
+    /** Assistant messages whose step's usage was counted. */
+    steps: string[];
+}
+/** What a turn says when it was rebuilt after a restart and the session left no answer for it. */
+declare const LOST_ANSWER_ERROR = "The answer was lost while the agent restarted; ask again.";
 /** The model a step ran on, as OpenCode names it (`session.step.started`). */
 interface StepModel {
     providerID: string;
@@ -283,6 +343,7 @@ type Milestone = {
     ask: PendingAsk;
     timeoutMs?: number;
     usage?: OpenCodeUsage;
+    progress?: TurnProgress;
 } | {
     kind: 'finished';
     outcome: TurnOutcome;
@@ -319,6 +380,14 @@ interface OpenCodeTurnArgs {
     }) => Promise<StepCost>;
     /** What the run spent before this turn object existed (an earlier process, an earlier session). */
     carried?: OpenCodeUsage;
+    /** What the turn took before this turn object existed (the last `ask` milestone's progress). */
+    progress?: TurnProgress;
+    /**
+     * Rebuilt in a process that was not listening while the session ran (a durable `observe` re-run
+     * after a restart): when the execution ends, what the session said in between is read back from
+     * its messages.
+     */
+    resumed?: boolean;
     logger: Logger;
     /**
      * An action OpenCode was allowed to run (a person approved it, or the policy did): the approval
@@ -377,6 +446,8 @@ declare class OpenCodeTurn {
     private wroteMessage;
     private ended;
     private stepError;
+    /** What this turn object took from the session's assistant messages (see {@link TurnProgress}). */
+    private readonly took;
     constructor(a: OpenCodeTurnArgs);
     /**
      * What the session had spent before this turn prompted it (`session.get`). When the execution
@@ -388,6 +459,8 @@ declare class OpenCodeTurn {
         cost?: number;
         tokens?: OpenCodeTokens;
     } | undefined): void;
+    /** What the turn took so far: carried from before this turn object, plus what it took. */
+    progress(): TurnProgress;
     /** What the run spent so far: carried from before this turn object, plus what it saw. */
     totalUsage(): OpenCodeUsage;
     get sessionId(): string;
@@ -431,6 +504,8 @@ declare class OpenCodeTurn {
     private setInput;
     private innerCalls;
     private onEvent;
+    /** Characters taken from an assistant message's text or reasoning. */
+    private count;
     private settleTool;
     private modelId;
     /** One model call's usage and cost, into the ledger and the run's total. */
@@ -456,6 +531,23 @@ declare class OpenCodeTurn {
     private addResult;
     /** What the session spent since the baseline that no event of this turn reported. */
     private unreported;
+    /**
+     * The session's messages since this turn's prompt, oldest first: everything after its newest user
+     * message. `undefined` when they cannot be read (no `message.list`, no prompt within reach); empty
+     * when the newest prompt is another run's (this turn's never reached the session).
+     */
+    private messagesSincePrompt;
+    /**
+     * A turn rebuilt after a restart heard only what the session said once it re-attached: what it
+     * said in between — read back from the session's messages since the prompt, less what an earlier
+     * process already took ({@link TurnProgress}) and what this one heard — is taken now, as its
+     * events would have been: text, reasoning, tool calls and results, each step's usage. A session
+     * that left nothing for the turn fails it ({@link LOST_ANSWER_ERROR}) rather than reading as an
+     * empty answer.
+     */
+    private recover;
+    /** A tool part of a message the turn did not hear: its call, its result, whichever it lacks. */
+    private missedTool;
     private end;
 }
 /**
@@ -928,14 +1020,16 @@ declare class OpenCodeTurns implements OnApplicationShutdown {
      *
      * `spent` is what the run spent before (the sum of the `usage` of its earlier milestones): a turn
      * rebuilt here starts from it, so the answer it persists carries the whole run's usage.
+     * `progress` is what the turn took before (its last `ask` milestone's): a turn rebuilt here reads
+     * back from the session's messages, when the execution ends, what nobody heard after that.
      */
-    observe(runId: string, input: AgentRunInput, handle: SessionHandle, spent?: OpenCodeUsage): Promise<Milestone>;
+    observe(runId: string, input: AgentRunInput, handle: SessionHandle, spent?: OpenCodeUsage, progress?: TurnProgress): Promise<Milestone>;
     /**
      * Hand a person's answer back to OpenCode. When the server restarted while the turn waited, the
      * request is gone with it: a new session is opened, told what the person decided, and prompted
      * to go on.
      */
-    reply(runId: string, input: AgentRunInput, handle: SessionHandle, ask: PendingAsk, reply: HumanReply, spent?: OpenCodeUsage): Promise<SessionHandle>;
+    reply(runId: string, input: AgentRunInput, handle: SessionHandle, ask: PendingAsk, reply: HumanReply, spent?: OpenCodeUsage, progress?: TurnProgress): Promise<SessionHandle>;
     private continueAfterRestart;
     /** What a session spent so far (`session.get`), or nothing when OpenCode does not say. */
     private sessionUsage;
@@ -1000,4 +1094,4 @@ declare function openCodeControllers(options: OpenCodeEngineSettings): Type<obje
 /** The providers every OpenCode engine needs: host, session store, settings and the turn steps. */
 declare function openCodeProviders(options: OpenCodeEngineOptions): Provider[];
 
-export { OpenCodeTurn as A, type OpenCodeTurnContext as B, type OpenCodeUsage as C, type StepCost as D, type StepModel as E, addUsage as F, emptyUsage as G, keyValueOpenCodeSessionStore as H, InMemoryOpenCodeSessionStore as I, openCode as J, openCodeControllers as K, openCodeProviders as L, type Milestone as M, usageOf as N, OpenCodeTurns as O, type PendingAsk as P, type SessionHandle as S, type TurnOutcome as T, type OpenCodeEngineSettings as a, type OpenCodeHost as b, type OpenCodeEngineOptions as c, type OpenCodeClient as d, type OpenCodeEvent as e, type OpenCodeForm as f, type OpenCodeFormValue as g, type OpenCodeFormField as h, OpenCodeMcpEndpoint as i, type OpenCodeAmendment as j, type OpenCodeCallContext as k, type OpenCodeKeyValue as l, type OpenCodeModelRef as m, type OpenCodePermissionRequest as n, type OpenCodePermissionRule as o, OpenCodeReplyMismatchError as p, type OpenCodeRunResult as q, type OpenCodeServer as r, type OpenCodeSessionCreate as s, type OpenCodeSessionRef as t, type OpenCodeSessionStore as u, type OpenCodeToolCall as v, OpenCodeToolRefusedError as w, type OpenCodeToolsClaims as x, type OpenCodeToolsOptions as y, OpenCodeToolsTokens as z };
+export { type OpenCodeToolsOptions as A, OpenCodeToolsTokens as B, OpenCodeTurn as C, type OpenCodeTurnContext as D, type OpenCodeUsage as E, type StepCost as F, type StepModel as G, type TurnProgress as H, InMemoryOpenCodeSessionStore as I, addUsage as J, emptyUsage as K, LOST_ANSWER_ERROR as L, type Milestone as M, keyValueOpenCodeSessionStore as N, OpenCodeTurns as O, type PendingAsk as P, openCode as Q, openCodeControllers as R, type SessionHandle as S, type TurnOutcome as T, openCodeProviders as U, usageOf as V, type OpenCodeEngineSettings as a, type OpenCodeHost as b, type OpenCodeEngineOptions as c, type OpenCodeClient as d, type OpenCodeEvent as e, type OpenCodeForm as f, type OpenCodeFormValue as g, type OpenCodeFormField as h, OpenCodeMcpEndpoint as i, type OpenCodeAmendment as j, type OpenCodeCallContext as k, type OpenCodeKeyValue as l, type OpenCodeMessage as m, type OpenCodeMessagePart as n, type OpenCodeModelRef as o, type OpenCodePermissionRequest as p, type OpenCodePermissionRule as q, OpenCodeReplyMismatchError as r, type OpenCodeRunResult as s, type OpenCodeServer as t, type OpenCodeSessionCreate as u, type OpenCodeSessionRef as v, type OpenCodeSessionStore as w, type OpenCodeToolCall as x, OpenCodeToolRefusedError as y, type OpenCodeToolsClaims as z };