opencode-gateway 0.2.8 → 0.2.10

package/README.md

@@ -28,10 +28,22 @@ Check what it resolved:
 npx opencode-gateway doctor
 ```
 
-Then start OpenCode normally:
+Recommended:
+
+```bash
+opencode-gateway serve
+```
+
+This wraps `opencode serve` and warms the gateway plugin worker immediately, so
+Telegram polling and scheduled jobs do not stay idle until the first
+project-scoped request.
+
+If you still prefer the raw OpenCode command, warm the gateway explicitly after
+startup:
 
 ```bash
 opencode serve
+opencode-gateway warm
 ```
 
 If you want a separate managed config tree instead of editing your existing
@@ -39,9 +51,7 @@ OpenCode config:
 
 ```bash
 npx opencode-gateway init --managed
-export OPENCODE_CONFIG="$HOME/.config/opencode-gateway/opencode/opencode.json"
-export OPENCODE_CONFIG_DIR="$HOME/.config/opencode-gateway/opencode"
-opencode serve
+opencode-gateway serve --managed
 ```
 
 ## Example gateway config
@@ -51,6 +61,17 @@ opencode serve
 state_db = "/home/you/.local/share/opencode-gateway/state.db"
 # log_level = "warn"
 
+# Optional mailbox batching and route overrides.
+# [gateway.mailbox]
+# batch_replies = false
+# batch_window_ms = 1500
+#
+# [[gateway.mailbox.routes]]
+# channel = "telegram"
+# target = "6212645712"
+# topic = "12345"
+# mailbox_key = "shared:telegram:dev"
+
 [cron]
 enabled = true
 tick_seconds = 5
@@ -60,9 +81,15 @@ max_concurrent_runs = 1
 enabled = false
 bot_token_env = "TELEGRAM_BOT_TOKEN"
 poll_timeout_seconds = 25
+# Configure at least one allowlist when Telegram is enabled.
 allowed_chats = []
 allowed_users = []
 
+[[memory.entries]]
+path = "USER.md"
+description = "Persistent user profile and preference memory. Keep this file accurate and concise. Record stable preferences, communication style, workflow habits, project conventions, tool constraints, review expectations, and other recurring facts that should shape future assistance. Update it proactively when you learn something durable about the user. Do not store one-off task details or transient context here."
+inject_content = true
+
 [[memory.entries]]
 path = "memory/project.md"
 description = "Project conventions and long-lived context"
@@ -85,6 +112,13 @@ export TELEGRAM_BOT_TOKEN="..."
 Gateway plugin logs are off by default. Set `gateway.log_level` to `error`,
 `warn`, `info`, or `debug` to emit that level and anything above it.
 
+Mailbox rules:
+
+- `gateway.mailbox.batch_replies` defaults to `false`
+- `gateway.mailbox.batch_window_ms` defaults to `1500`
+- `gateway.mailbox.routes` lets multiple ingress targets share one logical mailbox/session
+- each route needs `channel`, `target`, optional `topic`, and a `mailbox_key`
+
 Memory rules:
 
 - all entries inject their configured path and description
@@ -95,4 +129,6 @@ Memory rules:
   text files
 - relative paths are resolved from `opencode-gateway-workspace`
 - absolute paths are still allowed
+- missing files and directories are created automatically on load
+- the default template includes `USER.md` as persistent user-profile memory
 - memory is injected only into gateway-managed sessions

package/dist/cli/args.d.ts

@@ -1,7 +1,7 @@
 export type CliCommand = {
     kind: "help";
 } | {
-    kind: "init" | "doctor";
+    kind: "init" | "doctor" | "serve" | "warm";
     managed: boolean;
     configDir: string | null;
 };

package/dist/cli/opencode-server.d.ts

@@ -0,0 +1,19 @@
+type CliOptions = {
+    managed: boolean;
+    configDir: string | null;
+};
+export type ResolvedServeTarget = {
+    configDir: string;
+    gatewayConfigPath: string;
+    workspaceDirPath: string;
+    opencodeConfigPath: string;
+    serverOrigin: string;
+    env: Record<string, string>;
+};
+export declare function resolveServeTarget(options: CliOptions, env: Record<string, string | undefined>): Promise<ResolvedServeTarget>;
+export declare function warmGatewayProject(target: ResolvedServeTarget, options?: {
+    deadlineMs?: number;
+    intervalMs?: number;
+}): Promise<void>;
+export declare function resolveServerOriginFromDocument(document: Record<string, unknown>): string;
+export {};

package/dist/cli/serve.d.ts

@@ -0,0 +1,6 @@
+type ServeOptions = {
+    managed: boolean;
+    configDir: string | null;
+};
+export declare function runServe(options: ServeOptions, env: Record<string, string | undefined>): Promise<void>;
+export {};

package/dist/cli/warm.d.ts

@@ -0,0 +1,6 @@
+type WarmOptions = {
+    managed: boolean;
+    configDir: string | null;
+};
+export declare function runWarm(options: WarmOptions, env: Record<string, string | undefined>): Promise<void>;
+export {};

package/dist/cli.js

@@ -7,7 +7,7 @@ function parseCliCommand(argv) {
   if (!command || command === "help" || command === "--help" || command === "-h") {
     return { kind: "help" };
   }
-  if (command !== "init" && command !== "doctor") {
+  if (command !== "init" && command !== "doctor" && command !== "serve" && command !== "warm") {
     throw new Error(`unknown command: ${command}`);
   }
   let managed = false;
@@ -48,6 +48,8 @@ function formatCliHelp() {
     "Commands:",
     "  opencode-gateway init [--managed] [--config-dir <path>]",
     "  opencode-gateway doctor [--managed] [--config-dir <path>]",
+    "  opencode-gateway warm [--managed] [--config-dir <path>]",
+    "  opencode-gateway serve [--managed] [--config-dir <path>]",
     "",
     "Defaults:",
     "  init/doctor use OPENCODE_CONFIG_DIR when set, otherwise ~/.config/opencode",
@@ -57,42 +59,7 @@ function formatCliHelp() {
 }
 
 // src/cli/doctor.ts
-import { readFile } from "node:fs/promises";
-import { join as join3 } from "node:path";
-
-// src/config/paths.ts
-import { homedir } from "node:os";
-import { dirname, join, resolve as resolve2 } from "node:path";
-var GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
-var OPENCODE_CONFIG_FILE = "opencode.json";
-var OPENCODE_CONFIG_FILE_JSONC = "opencode.jsonc";
-var OPENCODE_CONFIG_FILE_CANDIDATES = [OPENCODE_CONFIG_FILE_JSONC, OPENCODE_CONFIG_FILE];
-var GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
-function resolveOpencodeConfigDir(env) {
-  const explicit = env.OPENCODE_CONFIG_DIR;
-  if (explicit && explicit.trim().length > 0) {
-    return resolve2(explicit);
-  }
-  return defaultOpencodeConfigDir(env);
-}
-function resolveManagedOpencodeConfigDir(env) {
-  return join(resolveConfigHome(env), "opencode-gateway", "opencode");
-}
-function resolveGatewayWorkspacePath(configPath) {
-  return join(dirname(configPath), GATEWAY_WORKSPACE_DIR);
-}
-function defaultGatewayStateDbPath(env) {
-  return join(resolveDataHome(env), "opencode-gateway", "state.db");
-}
-function resolveConfigHome(env) {
-  return env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
-}
-function resolveDataHome(env) {
-  return env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
-}
-function defaultOpencodeConfigDir(env) {
-  return join(resolveConfigHome(env), "opencode");
-}
+import { readFile as readFile2 } from "node:fs/promises";
 
 // src/cli/opencode-config.ts
 var OPENCODE_SCHEMA_URL = "https://opencode.ai/config.json";
@@ -290,6 +257,47 @@ function isGatewayPluginReference(entry) {
 // src/cli/opencode-config-file.ts
 import { join as join2 } from "node:path";
 
+// src/config/paths.ts
+import { homedir } from "node:os";
+import { dirname, join, resolve as resolve2 } from "node:path";
+var GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
+var OPENCODE_CONFIG_FILE = "opencode.json";
+var OPENCODE_CONFIG_FILE_JSONC = "opencode.jsonc";
+var OPENCODE_CONFIG_FILE_CANDIDATES = [OPENCODE_CONFIG_FILE_JSONC, OPENCODE_CONFIG_FILE];
+var GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
+function resolveGatewayConfigPath(env) {
+  const explicit = env.OPENCODE_GATEWAY_CONFIG;
+  if (explicit && explicit.trim().length > 0) {
+    return resolve2(explicit);
+  }
+  return join(resolveOpencodeConfigDir(env), GATEWAY_CONFIG_FILE);
+}
+function resolveOpencodeConfigDir(env) {
+  const explicit = env.OPENCODE_CONFIG_DIR;
+  if (explicit && explicit.trim().length > 0) {
+    return resolve2(explicit);
+  }
+  return defaultOpencodeConfigDir(env);
+}
+function resolveManagedOpencodeConfigDir(env) {
+  return join(resolveConfigHome(env), "opencode-gateway", "opencode");
+}
+function resolveGatewayWorkspacePath(configPath) {
+  return join(dirname(configPath), GATEWAY_WORKSPACE_DIR);
+}
+function defaultGatewayStateDbPath(env) {
+  return join(resolveDataHome(env), "opencode-gateway", "state.db");
+}
+function resolveConfigHome(env) {
+  return env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+}
+function resolveDataHome(env) {
+  return env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
+}
+function defaultOpencodeConfigDir(env) {
+  return join(resolveConfigHome(env), "opencode");
+}
+
 // src/cli/paths.ts
 import { constants } from "node:fs";
 import { access } from "node:fs/promises";
@@ -329,19 +337,106 @@ async function resolveOpencodeConfigFile(configDir) {
   };
 }
 
+// src/cli/opencode-server.ts
+import { readFile } from "node:fs/promises";
+var DEFAULT_SERVER_ORIGIN = "http://127.0.0.1:4096";
+var WARM_REQUEST_TIMEOUT_MS = 2000;
+async function resolveServeTarget(options, env) {
+  const configDir = resolveCliConfigDir(options, env);
+  const gatewayConfigPath = resolveGatewayConfigPath({
+    ...env,
+    OPENCODE_CONFIG_DIR: configDir
+  });
+  const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
+  const opencodeConfig = await resolveOpencodeConfigFile(configDir);
+  const serverOrigin = opencodeConfig.exists ? await resolveServerOrigin(opencodeConfig.path) : DEFAULT_SERVER_ORIGIN;
+  return {
+    configDir,
+    gatewayConfigPath,
+    workspaceDirPath,
+    opencodeConfigPath: opencodeConfig.path,
+    serverOrigin,
+    env: {
+      OPENCODE_CONFIG_DIR: configDir,
+      OPENCODE_CONFIG: opencodeConfig.path
+    }
+  };
+}
+async function warmGatewayProject(target, options) {
+  const deadlineMs = options?.deadlineMs ?? 30000;
+  const intervalMs = options?.intervalMs ?? 250;
+  const warmUrl = new URL("/experimental/tool/ids", target.serverOrigin);
+  warmUrl.searchParams.set("directory", target.workspaceDirPath);
+  const deadline = Date.now() + deadlineMs;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(warmUrl, {
+        signal: AbortSignal.timeout(WARM_REQUEST_TIMEOUT_MS)
+      });
+      if (response.ok) {
+        const payload = await response.json();
+        if (isGatewayToolList(payload)) {
+          return;
+        }
+      }
+    } catch {}
+    await delay(intervalMs);
+  }
+  throw new Error(`failed to warm the gateway plugin at ${target.serverOrigin} for ${target.workspaceDirPath}`);
+}
+function resolveServerOriginFromDocument(document) {
+  const server = document.server;
+  if (server === null || typeof server !== "object" || Array.isArray(server)) {
+    return DEFAULT_SERVER_ORIGIN;
+  }
+  const hostname = readNonEmptyString(server.hostname);
+  const port = readPort(server.port);
+  if (hostname === null || port === null) {
+    return DEFAULT_SERVER_ORIGIN;
+  }
+  return `http://${hostname}:${port}`;
+}
+async function resolveServerOrigin(configPath) {
+  const source = await readFile(configPath, "utf8");
+  const document = parseOpencodeConfig(source, configPath);
+  return resolveServerOriginFromDocument(document);
+}
+function readNonEmptyString(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function readPort(value) {
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    return null;
+  }
+  return value >= 1 && value <= 65535 ? value : null;
+}
+function isGatewayToolList(value) {
+  return Array.isArray(value) && value.includes("gateway_status");
+}
+function delay(durationMs) {
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, durationMs);
+  });
+}
+
 // src/cli/doctor.ts
 async function runDoctor(options, env) {
   const configDir = resolveCliConfigDir(options, env);
-  const gatewayConfigPath = join3(configDir, GATEWAY_CONFIG_FILE);
-  const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
   const opencodeConfig = await resolveOpencodeConfigFile(configDir);
   const opencodeStatus = await inspectOpencodeConfig(opencodeConfig.path);
   const gatewayOverride = env.OPENCODE_GATEWAY_CONFIG?.trim() || null;
+  const serveTarget = await resolveServeTarget(options, env);
   console.log("doctor report");
   console.log(`  config dir: ${configDir}`);
   console.log(`  opencode config: ${await describePath(opencodeConfig.path)}`);
-  console.log(`  gateway config: ${await describePath(gatewayConfigPath)}`);
-  console.log(`  gateway workspace: ${await describePath(workspaceDirPath)}`);
+  console.log(`  gateway config: ${await describePath(serveTarget.gatewayConfigPath)}`);
+  console.log(`  gateway workspace: ${await describePath(serveTarget.workspaceDirPath)}`);
+  console.log(`  warm server: ${serveTarget.serverOrigin}`);
+  console.log(`  warm directory: ${serveTarget.workspaceDirPath}`);
   console.log(`  gateway config override: ${gatewayOverride ?? "not set"}`);
   console.log(`  plugin configured: ${opencodeStatus.pluginConfigured}`);
   console.log(`  TELEGRAM_BOT_TOKEN: ${env.TELEGRAM_BOT_TOKEN?.trim() ? "set" : "missing"}`);
@@ -360,7 +455,7 @@ async function inspectOpencodeConfig(path) {
     };
   }
   try {
-    const parsed = parseOpencodeConfig(await readFile(path, "utf8"), path);
+    const parsed = parseOpencodeConfig(await readFile2(path, "utf8"), path);
     return {
       pluginConfigured: inspectGatewayPlugin(parsed),
       error: null
@@ -374,8 +469,8 @@ async function inspectOpencodeConfig(path) {
 }
 
 // src/cli/init.ts
-import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
-import { dirname as dirname2, join as join4 } from "node:path";
+import { mkdir, readFile as readFile3, writeFile } from "node:fs/promises";
+import { dirname as dirname2, join as join3 } from "node:path";
 
 // src/cli/templates.ts
 function buildGatewayConfigTemplate(stateDbPath) {
@@ -387,6 +482,18 @@ function buildGatewayConfigTemplate(stateDbPath) {
     `state_db = "${escapeTomlString(stateDbPath)}"`,
     '# log_level = "warn"',
     "",
+    "# Optional mailbox settings.",
+    "# [gateway.mailbox]",
+    "# batch_replies = false",
+    "# batch_window_ms = 1500",
+    "#",
+    "# Optional route overrides. Matching ingress targets can share one mailbox/session.",
+    "# [[gateway.mailbox.routes]]",
+    '# channel = "telegram"',
+    '# target = "6212645712"',
+    '# topic = "12345"',
+    '# mailbox_key = "shared:telegram:dev"',
+    "",
     "[cron]",
     "enabled = true",
     "tick_seconds = 5",
@@ -397,16 +504,18 @@ function buildGatewayConfigTemplate(stateDbPath) {
     "enabled = false",
     'bot_token_env = "TELEGRAM_BOT_TOKEN"',
     "poll_timeout_seconds = 25",
+    "# Configure at least one allowlist when Telegram is enabled.",
     "allowed_chats = []",
     "allowed_users = []",
     "",
     "# Optional long-lived memory sources injected into gateway-managed sessions.",
     "# Relative paths are resolved from opencode-gateway-workspace.",
+    "# Missing files and directories are created automatically.",
     "#",
-    "# [[memory.entries]]",
-    '# path = "memory/project.md"',
-    '# description = "Project conventions and long-lived context"',
-    "# inject_content = true",
+    "[[memory.entries]]",
+    'path = "USER.md"',
+    'description = "Persistent user profile and preference memory. Keep this file accurate and concise. Record stable preferences, communication style, workflow habits, project conventions, tool constraints, review expectations, and other recurring facts that should shape future assistance. Update it proactively when you learn something durable about the user. Do not store one-off task details or transient context here."',
+    "inject_content = true",
     "#",
     "# [[memory.entries]]",
     '# path = "memory/notes"',
@@ -424,7 +533,7 @@ function escapeTomlString(value) {
 // src/cli/init.ts
 async function runInit(options, env) {
   const configDir = resolveCliConfigDir(options, env);
-  const gatewayConfigPath = join4(configDir, GATEWAY_CONFIG_FILE);
+  const gatewayConfigPath = join3(configDir, GATEWAY_CONFIG_FILE);
   const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
   const opencodeConfig = await resolveOpencodeConfigFile(configDir);
   const opencodeConfigPath = opencodeConfig.path;
@@ -435,7 +544,7 @@ async function runInit(options, env) {
     await writeFile(opencodeConfigPath, stringifyOpencodeConfig(createDefaultOpencodeConfig(options.managed)));
     opencodeStatus = "created";
   } else {
-    const source = await readFile2(opencodeConfigPath, "utf8");
+    const source = await readFile3(opencodeConfigPath, "utf8");
     const parsed = parseOpencodeConfig(source, opencodeConfigPath);
     const next = ensureGatewayPlugin(parsed);
     if (next.changed) {
@@ -453,6 +562,54 @@ async function runInit(options, env) {
   console.log(`opencode config: ${opencodeConfigPath} (${opencodeStatus})`);
   console.log(`gateway config: ${gatewayConfigPath} (${gatewayStatus})`);
   console.log(`gateway workspace: ${workspaceDirPath} (ready)`);
+  console.log("next step: start OpenCode with `opencode-gateway serve`");
+  console.log("fallback: if you still run `opencode serve`, run `opencode-gateway warm` after startup");
+}
+
+// src/cli/serve.ts
+import { spawn } from "node:child_process";
+import { mkdir as mkdir2 } from "node:fs/promises";
+async function runServe(options, env) {
+  const target = await resolveServeTarget(options, env);
+  await mkdir2(target.workspaceDirPath, { recursive: true });
+  const child = spawn("opencode", ["serve"], {
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      ...target.env
+    }
+  });
+  warmGatewayProject(target).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`warning: ${message}`);
+    console.warn("warning: the gateway plugin may stay idle until the first project-scoped request");
+  });
+  const exitCode = await waitForChild(child);
+  if (exitCode !== 0) {
+    process.exitCode = exitCode;
+  }
+}
+function waitForChild(child) {
+  return new Promise((resolve4, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (signal !== null) {
+        resolve4(1);
+        return;
+      }
+      resolve4(code ?? 0);
+    });
+  });
+}
+
+// src/cli/warm.ts
+import { mkdir as mkdir3 } from "node:fs/promises";
+async function runWarm(options, env) {
+  const target = await resolveServeTarget(options, env);
+  await mkdir3(target.workspaceDirPath, { recursive: true });
+  await warmGatewayProject(target);
+  console.log(`gateway plugin warmed: ${target.serverOrigin}`);
+  console.log(`warm directory: ${target.workspaceDirPath}`);
 }
 
 // src/cli.ts
@@ -468,6 +625,12 @@ async function main() {
     case "init":
       await runInit(command, process.env);
       return;
+    case "serve":
+      await runServe(command, process.env);
+      return;
+    case "warm":
+      await runWarm(command, process.env);
+      return;
   }
 }
 main().catch((error) => {

package/dist/index.js

@@ -16179,7 +16179,7 @@ async function readMemoryEntry(value, index, workspaceDirPath) {
   }
   throw new Error(`${field}.path must point to a regular file or directory`);
 }
-async function ensurePathMetadata(path, displayPath, entry, field) {
+async function ensurePathMetadata(path, displayPath, entry, _field) {
   try {
     return await stat(path);
   } catch (error) {
@@ -17754,7 +17754,9 @@ function delay(durationMs) {
 
 // src/opencode/adapter.ts
 var SESSION_IDLE_POLL_MS = 250;
-var PROMPT_RESPONSE_TIMEOUT_MS = 90000;
+var PROMPT_RESPONSE_PROGRESS_TIMEOUT_MS = 90000;
+var PROMPT_RESPONSE_MAX_TIMEOUT_MS = 10 * 60000;
+var PROMPT_RESPONSE_SETTLE_MS = 1000;
 
 class OpencodeSdkAdapter {
   client;
@@ -17900,8 +17902,12 @@ class OpencodeSdkAdapter {
     };
   }
   async awaitPromptResponse(command) {
-    const deadline = Date.now() + PROMPT_RESPONSE_TIMEOUT_MS;
+    const startedAtMs = Date.now();
+    const maxDeadline = startedAtMs + PROMPT_RESPONSE_MAX_TIMEOUT_MS;
+    let progressDeadline = startedAtMs + PROMPT_RESPONSE_PROGRESS_TIMEOUT_MS;
     let stableCandidateKey = null;
+    let stableCandidateSinceMs = null;
+    let progressKey = null;
     for (;; ) {
       const messages = await this.client.session.messages({
         path: { id: command.sessionId },
@@ -17912,22 +17918,32 @@ class OpencodeSdkAdapter {
         responseStyle: "data",
         throwOnError: true
       });
-      const response = selectAssistantResponse(unwrapData(messages), command.messageId);
+      const assistantChildren = listAssistantResponses(unwrapData(messages), command.messageId);
+      const nextProgressKey = createAssistantProgressKey(assistantChildren);
+      const now = Date.now();
+      if (progressKey !== nextProgressKey) {
+        progressKey = nextProgressKey;
+        progressDeadline = now + PROMPT_RESPONSE_PROGRESS_TIMEOUT_MS;
+      }
+      const response = selectAssistantResponse(assistantChildren);
       if (response !== null) {
         const candidateKey = createAssistantCandidateKey(response);
         if (stableCandidateKey === candidateKey) {
-          return {
-            kind: "awaitPromptResponse",
-            sessionId: command.sessionId,
-            messageId: response.info.id,
-            parts: response.parts.flatMap(toBindingMessagePart)
-          };
+          if (stableCandidateSinceMs !== null && now - stableCandidateSinceMs >= PROMPT_RESPONSE_SETTLE_MS) {
+            return toAwaitPromptResponseResult(command.sessionId, response);
+          }
+        } else {
+          stableCandidateKey = candidateKey;
+          stableCandidateSinceMs = now;
         }
-        stableCandidateKey = candidateKey;
       } else {
         stableCandidateKey = null;
+        stableCandidateSinceMs = null;
       }
-      if (Date.now() >= deadline) {
+      if (now >= progressDeadline || now >= maxDeadline) {
+        if (response !== null) {
+          return toAwaitPromptResponseResult(command.sessionId, response);
+        }
         throw new Error(`assistant message for prompt ${command.messageId} is unavailable after prompt completion`);
       }
       await delay(SESSION_IDLE_POLL_MS);
@@ -17988,8 +18004,10 @@ function toSessionPromptPart(part) {
       };
   }
 }
-function selectAssistantResponse(messages, userMessageId) {
-  const assistantChildren = messages.filter(isAssistantChildMessage(userMessageId));
+function listAssistantResponses(messages, userMessageId) {
+  return messages.filter(isAssistantChildMessage(userMessageId));
+}
+function selectAssistantResponse(assistantChildren) {
   for (let index = assistantChildren.length - 1;index >= 0; index -= 1) {
     const candidate = assistantChildren[index];
     if (hasVisibleText(candidate)) {
@@ -18004,6 +18022,9 @@ function selectAssistantResponse(messages, userMessageId) {
   }
   return null;
 }
+function createAssistantProgressKey(messages) {
+  return JSON.stringify(messages.map(createAssistantCandidateKey));
+}
 function createAssistantCandidateKey(message) {
   return JSON.stringify({
     messageId: message.info.id,
@@ -18020,6 +18041,14 @@ function createAssistantCandidateKey(message) {
 function isAssistantChildMessage(userMessageId) {
   return (message) => message.info?.role === "assistant" && message.info.parentID === userMessageId;
 }
+function toAwaitPromptResponseResult(sessionId, message) {
+  return {
+    kind: "awaitPromptResponse",
+    sessionId,
+    messageId: message.info.id,
+    parts: message.parts.flatMap(toBindingMessagePart)
+  };
+}
 function toBindingMessagePart(part) {
   if (typeof part.id !== "string" || typeof part.messageID !== "string" || part.type.length === 0) {
     return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-gateway",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "Gateway plugin for OpenCode",
   "license": "MIT",
   "type": "module",