@loompad/cli 0.1.0 → 1.1.1

package/dist/adapters/opencode.d.ts

@@ -9,29 +9,82 @@
  *   live events    : GET  /event   (SSE)
  *
  * Surface verified against opencode 1.17.20 — see docs/integration-notes.md.
+ *
+ * Native continuity (see core/continuity): a continuity turn runs on the
+ * session its binding names, or a new one it reports as `turn_started`; a
+ * bound session the server no longer has is NativeSessionMissing, before
+ * anything is sent. The prompt's admission is the acceptance evidence
+ * (`native_turn_accepted`), and the turn is over — and quiescent — when
+ * `/api/session/active` no longer lists the session. Verified against
+ * opencode 1.18.31 (`/api/session/{id}/model` switches the model in place,
+ * `session.next.compaction.*` reports compaction).
  */
 import type { SendInput } from "../types.js";
-import { AdapterBase } from "./base.js";
+import { AdapterBase, type AgentCheck } from "./base.js";
 /** "providerID/modelID" → ModelRef body for session create ({providerID, id}). */
 export declare function parseModelRef(model: string): {
     providerID: string;
     id: string;
 } | null;
+/**
+ * The model to use when the project pins none: opencode's free house model if
+ * the server offers it, else any free opencode-hosted model, else nothing
+ * (opencode's own default — the old behaviour).
+ */
+export declare function pickDefaultModel(ids: string[]): string | undefined;
+/**
+ * Permissions (core/permissions.ts) for the spawned server, via opencode's
+ * inline-config variable — the user's own opencode.json is never touched.
+ */
+export declare function opencodePermissionEnv(options: object): Record<string, string>;
 export declare class OpenCodeAdapter extends AdapterBase {
     private child;
     private baseUrl;
     private sseAbort;
     private options;
     private started;
+    /** npm builds expose /session + /global/health; newer builds use /api. */
+    private modernApi;
+    /**
+     * Before a turn: whatever a previous turn left in flight (an interrupted
+     * reply's parts, a prompt's echo) is never coming back, and the dedupe sets
+     * only need recent ids — so they're trimmed, not kept for the agent's life.
+     */
+    private trimTurnState;
+    /** Stops an idle server Loom started (see idleMinutes). */
+    private idleTimer;
+    private cancelIdle;
+    /**
+     * After a turn: stop the server we spawned once nothing has used it for a
+     * while. Never one we were pointed at (baseUrl), never mid-turn, and never
+     * while a question it asked is still waiting for an answer.
+     */
+    private armIdle;
+    /** Stop the idle server quietly: not a failure, and not the agent stopping. */
+    private sleep;
+    private api;
+    private promptBody;
+    private messageDetail;
+    private lastUsage;
+    private lastModel;
     /** text parts per in-flight assistant message */
     private textParts;
     private roles;
     /** assistant messages whose text already went to the log (SSE path) */
     private emittedText;
+    /** The session a continuity turn is running on; the agent's own otherwise. */
+    private activeSid;
+    /** interrupt() was asked for during this turn. */
+    private interrupted;
+    /** Tools opencode started this turn, by call id (1.18 reports name and result separately). */
+    private toolCalls;
+    /** A compaction was already reported as done (both the step event and the session event can say so). */
+    private compactionReported;
     constructor(id: string, projectDir: string, options?: Record<string, unknown>);
     private get sessionId();
     private set sessionId(value);
     available(): Promise<boolean>;
+    selfCheck(): Promise<AgentCheck[]>;
     /** Kill a serve child left behind by a previous daemon (verified by cmdline). */
     private reapOrphanServe;
     private recordServePid;
@@ -48,6 +101,29 @@ export declare class OpenCodeAdapter extends AdapterBase {
     private ensureSession;
     private startSse;
     private handleSse;
+    private reasoningParts;
+    private toolsDone;
+    /** An image a tool returned (a file: URI, or data: base64 filed under .loom/attachments), as a path the thread can show. */
+    private keepImage;
+    /** opencode's todos as Loom's plan checklist. */
+    private emitPlan;
+    /** Open questions by Loom request id → opencode's request, so an answer can find its way back. */
+    private questions;
+    /**
+     * opencode's question tool: one or more questions, each with labelled
+     * options, maybe several picks, maybe your own words. The card in the thread
+     * answers it through respondToUserInput.
+     */
+    private askQuestion;
+    /** Answer an open opencode question. answers: { [questionIndex]: label | labels }; none at all dismisses it. */
+    respondToUserInput(_chat: string, requestId: string, answers: Record<string, unknown>): Promise<void>;
+    /**
+     * opencode asking to run a command, edit a file, fetch a URL: the same
+     * approval card Loom shows for any agent, and opencode hears once / always / no.
+     */
+    private askPermission;
+    /** opencode 1.18's tool and compaction events, for a session already known to be ours. */
+    private handleSessionNext;
     /** All messages in the session, oldest first (info objects). */
     private listMessages;
     /**
@@ -57,8 +133,32 @@ export declare class OpenCodeAdapter extends AdapterBase {
      * fact holds across two consecutive polls (nothing new started).
      * `/wait` is tried first but returns 503 on 1.17.
      */
+    /** Is opencode still running this session? Null when this opencode can't say (older builds). */
+    private sessionActive;
     private waitForTurn;
     send(input: SendInput): Promise<void>;
+    /**
+     * A continuity turn (see the header): the binding's session, the admission as
+     * acceptance, and the session leaving `/api/session/active` as the end.
+     * Failures before the prompt is admitted are NativeDispatchRejected — nothing
+     * reached opencode — and a lost acknowledgement is never retried.
+     */
+    private sendContinuity;
+    private turnTimeoutMs;
+    /** The session a continuity turn runs on: its binding's, or a new one. Nothing is sent yet. */
+    private continuitySession;
+    /**
+     * Wait until opencode no longer lists the session as active. Before it has
+     * been seen running, an idle session only counts as done once a new
+     * completed assistant message exists — the prompt may not have started yet.
+     */
+    private waitIdle;
+    /**
+     * Emit a finished assistant message's text (unless the stream already did),
+     * its cost, and stash its usage and model for run_complete. Returns the
+     * error message when opencode says the turn failed.
+     */
+    private reportTurn;
     interrupt(): Promise<void>;
     stop(): Promise<void>;
 }