opencode-gateway 0.1.1 → 0.2.0

package/README.md

@@ -48,6 +48,7 @@ opencode serve
 ```toml
 [gateway]
 state_db = "/home/you/.local/share/opencode-gateway/state.db"
+# log_level = "warn"
 
 [cron]
 enabled = true
@@ -60,6 +61,17 @@ bot_token_env = "TELEGRAM_BOT_TOKEN"
 poll_timeout_seconds = 25
 allowed_chats = []
 allowed_users = []
+
+[[memory.entries]]
+path = "memory/project.md"
+description = "Project conventions and long-lived context"
+inject_content = true
+
+[[memory.entries]]
+path = "memory/notes"
+description = "Domain notes and operating docs"
+inject_markdown_contents = true
+globs = ["**/*.rs", "notes/**/*.txt"]
 ```
 
 When Telegram is enabled, export the bot token through the configured
@@ -68,3 +80,17 @@ environment variable, for example:
 ```bash
 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.
+
+Memory rules:
+
+- all entries inject their configured path and description
+- file contents are injected only when `inject_content = true`
+- directory entries default to description-only
+- `inject_markdown_contents = true` recursively injects `*.md` and `*.markdown`
+- `globs` are relative to the configured directory and may match other UTF-8
+  text files
+- relative paths are resolved from `opencode-gateway.toml`
+- memory is injected only into gateway-managed sessions

package/dist/binding/gateway.d.ts

@@ -60,8 +60,9 @@ export type BindingOutboundMessage = {
 export type BindingTransportHost = {
     sendMessage(message: BindingOutboundMessage): Promise<BindingHostAck>;
 };
+export type BindingLogLevel = "debug" | "info" | "warn" | "error";
 export type BindingLoggerHost = {
-    log(level: string, message: string): void;
+    log(level: BindingLogLevel, message: string): void;
 };
 export type GatewayContract = {
     gatewayStatus(): GatewayStatusSnapshot;

package/dist/binding/index.d.ts

@@ -1,7 +1,7 @@
 import type { BindingCronJobSpec, BindingInboundMessage, BindingPreparedExecution, GatewayContract } from "./gateway";
 import type { BindingOpencodeExecutionInput, OpencodeExecutionDriver } from "./opencode";
 export type { BindingExecutionObservation, BindingProgressiveDirective } from "./execution";
-export type { BindingCronJobSpec, BindingDeliveryTarget, BindingHostAck, BindingInboundAttachment, BindingInboundMessage, BindingLoggerHost, BindingOutboundMessage, BindingPreparedExecution, BindingPromptPart, BindingRuntimeReport, BindingTransportHost, GatewayContract, GatewayStatusSnapshot, } from "./gateway";
+export type { BindingCronJobSpec, BindingDeliveryTarget, BindingHostAck, BindingInboundAttachment, BindingInboundMessage, BindingLoggerHost, BindingLogLevel, BindingOutboundMessage, BindingPreparedExecution, BindingPromptPart, BindingRuntimeReport, BindingTransportHost, GatewayContract, GatewayStatusSnapshot, } from "./gateway";
 export type { BindingOpencodeCommand, BindingOpencodeCommandPart, BindingOpencodeCommandResult, BindingOpencodeDriverStep, BindingOpencodeExecutionInput, BindingOpencodeMessage, BindingOpencodeMessagePart, BindingOpencodePrompt, OpencodeExecutionDriver, } from "./opencode";
 export type GatewayBindingModule = GatewayContract & {
     prepareInboundExecution: (message: BindingInboundMessage) => BindingPreparedExecution;

package/dist/cli/templates.js

@@ -5,6 +5,7 @@ export function buildGatewayConfigTemplate(stateDbPath) {
         "",
         "[gateway]",
         `state_db = "${escapeTomlString(stateDbPath)}"`,
+        '# log_level = "warn"',
         "",
         "[cron]",
         "enabled = true",
@@ -19,6 +20,20 @@ export function buildGatewayConfigTemplate(stateDbPath) {
         "allowed_chats = []",
         "allowed_users = []",
         "",
+        "# Optional long-lived memory sources injected into gateway-managed sessions.",
+        "# Relative paths are resolved from this config file.",
+        "#",
+        "# [[memory.entries]]",
+        '# path = "memory/project.md"',
+        '# description = "Project conventions and long-lived context"',
+        "# inject_content = true",
+        "#",
+        "# [[memory.entries]]",
+        '# path = "memory/notes"',
+        '# description = "Domain notes and operating docs"',
+        "# inject_markdown_contents = true",
+        '# globs = ["**/*.rs", "notes/**/*.txt"]',
+        "",
     ].join("\n");
 }
 function escapeTomlString(value) {

package/dist/cli.js

@@ -247,6 +247,7 @@ function buildGatewayConfigTemplate(stateDbPath) {
     "",
     "[gateway]",
     `state_db = "${escapeTomlString(stateDbPath)}"`,
+    '# log_level = "warn"',
     "",
     "[cron]",
     "enabled = true",
@@ -260,6 +261,20 @@ function buildGatewayConfigTemplate(stateDbPath) {
     "poll_timeout_seconds = 25",
     "allowed_chats = []",
     "allowed_users = []",
+    "",
+    "# Optional long-lived memory sources injected into gateway-managed sessions.",
+    "# Relative paths are resolved from this config file.",
+    "#",
+    "# [[memory.entries]]",
+    '# path = "memory/project.md"',
+    '# description = "Project conventions and long-lived context"',
+    "# inject_content = true",
+    "#",
+    "# [[memory.entries]]",
+    '# path = "memory/notes"',
+    '# description = "Domain notes and operating docs"',
+    "# inject_markdown_contents = true",
+    '# globs = ["**/*.rs", "notes/**/*.txt"]',
     ""
   ].join(`
 `);

package/dist/config/gateway.d.ts

@@ -1,4 +1,6 @@
+import { type GatewayLogLevel } from "../host/logger";
 import { type CronConfig } from "./cron";
+import { type GatewayMemoryConfig } from "./memory";
 import { type TelegramConfig } from "./telegram";
 export type GatewayMailboxRouteConfig = {
     channel: string;
@@ -16,9 +18,11 @@ export type GatewayConfig = {
     stateDbPath: string;
     mediaRootPath: string;
     workspaceDirPath: string;
+    logLevel: GatewayLogLevel;
     hasLegacyGatewayTimezone: boolean;
     legacyGatewayTimezone: string | null;
     mailbox: GatewayMailboxConfig;
+    memory: GatewayMemoryConfig;
     cron: CronConfig;
     telegram: TelegramConfig;
 };

package/dist/config/gateway.js

@@ -1,6 +1,8 @@
 import { existsSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
+import { parseGatewayLogLevel } from "../host/logger";
 import { parseCronConfig } from "./cron";
+import { parseMemoryConfig } from "./memory";
 import { defaultGatewayStateDbPath, resolveGatewayConfigPath, resolveGatewayWorkspacePath } from "./paths";
 import { parseTelegramConfig } from "./telegram";
 export async function loadGatewayConfig(env = process.env) {
@@ -16,9 +18,11 @@ export async function loadGatewayConfig(env = process.env) {
         stateDbPath,
         mediaRootPath: resolveMediaRootPath(stateDbPath),
         workspaceDirPath: resolveGatewayWorkspacePath(configPath),
+        logLevel: parseGatewayLogLevel(rawConfig?.gateway?.log_level, "gateway.log_level"),
         hasLegacyGatewayTimezone: rawConfig?.gateway?.timezone !== undefined,
         legacyGatewayTimezone: readLegacyGatewayTimezone(rawConfig?.gateway?.timezone),
         mailbox: parseMailboxConfig(rawConfig?.gateway?.mailbox),
+        memory: await parseMemoryConfig(rawConfig?.memory, configPath),
         cron: parseCronConfig(rawConfig?.cron),
         telegram: parseTelegramConfig(rawConfig?.channels?.telegram, env),
     };

package/dist/config/memory.d.ts

@@ -0,0 +1,18 @@
+export type GatewayMemoryConfig = {
+    entries: GatewayMemoryEntryConfig[];
+};
+export type GatewayMemoryEntryConfig = {
+    kind: "file";
+    path: string;
+    displayPath: string;
+    description: string;
+    injectContent: boolean;
+} | {
+    kind: "directory";
+    path: string;
+    displayPath: string;
+    description: string;
+    injectMarkdownContents: boolean;
+    globs: string[];
+};
+export declare function parseMemoryConfig(value: unknown, configPath: string): Promise<GatewayMemoryConfig>;

package/dist/config/memory.js

@@ -0,0 +1,105 @@
+import { stat } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+export async function parseMemoryConfig(value, configPath) {
+    const table = readMemoryTable(value);
+    const entries = await readMemoryEntries(table.entries, configPath);
+    return { entries };
+}
+function readMemoryTable(value) {
+    if (value === undefined) {
+        return {};
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("memory must be a table when present");
+    }
+    return value;
+}
+async function readMemoryEntries(value, configPath) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error("memory.entries must be an array when present");
+    }
+    return await Promise.all(value.map((entry, index) => readMemoryEntry(entry, index, configPath)));
+}
+async function readMemoryEntry(value, index, configPath) {
+    const field = `memory.entries[${index}]`;
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${field} must be a table`);
+    }
+    const entry = value;
+    const displayPath = readRequiredString(entry.path, `${field}.path`);
+    const description = readRequiredString(entry.description, `${field}.description`);
+    const resolvedPath = resolve(dirname(configPath), displayPath);
+    const metadata = await statPath(resolvedPath, `${field}.path`);
+    if (metadata.isFile()) {
+        ensureDirectoryOnlyFieldIsAbsent(entry.inject_markdown_contents, `${field}.inject_markdown_contents`);
+        ensureDirectoryOnlyFieldIsAbsent(entry.globs, `${field}.globs`);
+        return {
+            kind: "file",
+            path: resolvedPath,
+            displayPath,
+            description,
+            injectContent: readBoolean(entry.inject_content, `${field}.inject_content`, false),
+        };
+    }
+    if (metadata.isDirectory()) {
+        ensureFileOnlyFieldIsAbsent(entry.inject_content, `${field}.inject_content`);
+        return {
+            kind: "directory",
+            path: resolvedPath,
+            displayPath,
+            description,
+            injectMarkdownContents: readBoolean(entry.inject_markdown_contents, `${field}.inject_markdown_contents`, false),
+            globs: readGlobList(entry.globs, `${field}.globs`),
+        };
+    }
+    throw new Error(`${field}.path must point to a regular file or directory`);
+}
+async function statPath(path, field) {
+    try {
+        return await stat(path);
+    }
+    catch (error) {
+        throw new Error(`${field} does not exist: ${path}`, { cause: error });
+    }
+}
+function ensureDirectoryOnlyFieldIsAbsent(value, field) {
+    if (value !== undefined) {
+        throw new Error(`${field} is only valid for directory entries`);
+    }
+}
+function ensureFileOnlyFieldIsAbsent(value, field) {
+    if (value !== undefined) {
+        throw new Error(`${field} is only valid for file entries`);
+    }
+}
+function readBoolean(value, field, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (typeof value !== "boolean") {
+        throw new Error(`${field} must be a boolean when present`);
+    }
+    return value;
+}
+function readGlobList(value, field) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${field} must be an array when present`);
+    }
+    return value.map((entry, index) => readRequiredString(entry, `${field}[${index}]`));
+}
+function readRequiredString(value, field) {
+    if (typeof value !== "string") {
+        throw new Error(`${field} must be a string`);
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${field} must not be empty`);
+    }
+    return trimmed;
+}

package/dist/gateway.d.ts

@@ -5,6 +5,7 @@ import { ChannelFileSender } from "./host/file-sender";
 import { GatewayExecutor } from "./runtime/executor";
 import { GatewaySessionContext } from "./session/context";
 import { ChannelSessionSwitcher } from "./session/switcher";
+import { GatewaySystemPromptBuilder } from "./session/system-prompt";
 import { GatewayTelegramRuntime } from "./telegram/runtime";
 export type GatewayPluginStatus = {
     runtimeMode: string;
@@ -27,7 +28,8 @@ export declare class GatewayPluginRuntime {
     readonly files: ChannelFileSender;
     readonly channelSessions: ChannelSessionSwitcher;
     readonly sessionContext: GatewaySessionContext;
-    constructor(contract: GatewayContract, executor: GatewayExecutor, cron: GatewayCronRuntime, telegram: GatewayTelegramRuntime, files: ChannelFileSender, channelSessions: ChannelSessionSwitcher, sessionContext: GatewaySessionContext);
+    readonly systemPrompts: GatewaySystemPromptBuilder;
+    constructor(contract: GatewayContract, executor: GatewayExecutor, cron: GatewayCronRuntime, telegram: GatewayTelegramRuntime, files: ChannelFileSender, channelSessions: ChannelSessionSwitcher, sessionContext: GatewaySessionContext, systemPrompts: GatewaySystemPromptBuilder);
     status(): GatewayPluginStatus;
 }
 export declare function createGatewayRuntime(module: GatewayBindingModule, input: PluginInput): Promise<GatewayPluginRuntime>;

package/dist/gateway.js

@@ -4,9 +4,10 @@ import { GatewayCronRuntime } from "./cron/runtime";
 import { TelegramProgressiveSupport } from "./delivery/telegram";
 import { GatewayTextDelivery } from "./delivery/text";
 import { ChannelFileSender } from "./host/file-sender";
-import { ConsoleLoggerHost } from "./host/noop";
+import { ConsoleLoggerHost } from "./host/logger";
 import { GatewayTransportHost } from "./host/transport";
 import { GatewayMailboxRouter } from "./mailbox/router";
+import { GatewayMemoryPromptProvider } from "./memory/prompt";
 import { OpencodeSdkAdapter } from "./opencode/adapter";
 import { OpencodeEventStream } from "./opencode/event-stream";
 import { OpencodeEventHub } from "./opencode/events";
@@ -18,6 +19,7 @@ import { getOrCreateRuntimeSingleton } from "./runtime/runtime-singleton";
 import { GatewaySessionContext } from "./session/context";
 import { resolveConversationKeyForTarget } from "./session/conversation-key";
 import { ChannelSessionSwitcher } from "./session/switcher";
+import { GatewaySystemPromptBuilder } from "./session/system-prompt";
 import { openSqliteStore } from "./store/sqlite";
 import { TelegramBotClient } from "./telegram/client";
 import { TelegramInboundMediaStore } from "./telegram/media";
@@ -31,7 +33,8 @@ export class GatewayPluginRuntime {
     files;
     channelSessions;
     sessionContext;
-    constructor(contract, executor, cron, telegram, files, channelSessions, sessionContext) {
+    systemPrompts;
+    constructor(contract, executor, cron, telegram, files, channelSessions, sessionContext, systemPrompts) {
         this.contract = contract;
         this.executor = executor;
         this.cron = cron;
@@ -39,6 +42,7 @@ export class GatewayPluginRuntime {
         this.files = files;
         this.channelSessions = channelSessions;
         this.sessionContext = sessionContext;
+        this.systemPrompts = systemPrompts;
     }
     status() {
         const rustStatus = this.contract.gatewayStatus();
@@ -61,7 +65,7 @@ export async function createGatewayRuntime(module, input) {
     const config = await loadGatewayConfig();
     return await getOrCreateRuntimeSingleton(config.configPath, async () => {
         await mkdir(config.workspaceDirPath, { recursive: true });
-        const logger = new ConsoleLoggerHost();
+        const logger = new ConsoleLoggerHost(config.logLevel);
         if (config.hasLegacyGatewayTimezone) {
             const suffix = config.legacyGatewayTimezone === null ? "" : ` (${config.legacyGatewayTimezone})`;
             logger.log("warn", `gateway.timezone${suffix} is ignored; use cron.timezone instead`);
@@ -69,6 +73,8 @@ export async function createGatewayRuntime(module, input) {
         const effectiveCronTimeZone = resolveEffectiveCronTimeZone(module, config);
         const store = await openSqliteStore(config.stateDbPath);
         const sessionContext = new GatewaySessionContext(store);
+        const memoryPrompts = new GatewayMemoryPromptProvider(config.memory, logger);
+        const systemPrompts = new GatewaySystemPromptBuilder(sessionContext, memoryPrompts);
         const telegramClient = config.telegram.enabled ? new TelegramBotClient(config.telegram.botToken) : null;
         const telegramMediaStore = config.telegram.enabled && telegramClient !== null
             ? new TelegramInboundMediaStore(telegramClient, config.mediaRootPath)
@@ -95,7 +101,7 @@ export async function createGatewayRuntime(module, input) {
         cron.start();
         mailbox.start();
         telegram.start();
-        return new GatewayPluginRuntime(module, executor, cron, telegram, files, channelSessions, sessionContext);
+        return new GatewayPluginRuntime(module, executor, cron, telegram, files, channelSessions, sessionContext, systemPrompts);
     });
 }
 function resolveEffectiveCronTimeZone(module, config) {

package/dist/host/logger.d.ts

@@ -0,0 +1,8 @@
+import type { BindingLoggerHost, BindingLogLevel } from "../binding";
+export type GatewayLogLevel = BindingLogLevel | "off";
+export declare class ConsoleLoggerHost implements BindingLoggerHost {
+    private readonly threshold;
+    constructor(threshold: GatewayLogLevel);
+    log(level: BindingLogLevel, message: string): void;
+}
+export declare function parseGatewayLogLevel(value: unknown, field: string): GatewayLogLevel;

package/dist/host/logger.js

@@ -0,0 +1,53 @@
+const LOG_LEVEL_PRIORITY = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+};
+export class ConsoleLoggerHost {
+    threshold;
+    constructor(threshold) {
+        this.threshold = threshold;
+    }
+    log(level, message) {
+        if (!shouldLog(level, this.threshold)) {
+            return;
+        }
+        const line = `[gateway:${level}] ${message}`;
+        switch (level) {
+            case "error":
+                console.error(line);
+                return;
+            case "warn":
+                console.warn(line);
+                return;
+            default:
+                console.info(line);
+        }
+    }
+}
+export function parseGatewayLogLevel(value, field) {
+    if (value === undefined) {
+        return "off";
+    }
+    if (typeof value !== "string") {
+        throw new Error(`${field} must be a string when present`);
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "off") {
+        return "off";
+    }
+    if (isBindingLogLevel(normalized)) {
+        return normalized;
+    }
+    throw new Error(`${field} must be one of: off, error, warn, info, debug`);
+}
+function shouldLog(level, threshold) {
+    if (threshold === "off") {
+        return false;
+    }
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[threshold];
+}
+function isBindingLogLevel(value) {
+    return value === "debug" || value === "info" || value === "warn" || value === "error";
+}

package/dist/index.js

@@ -46,8 +46,8 @@ export const OpencodeGatewayPlugin = async (input) => {
             if (!sessionId) {
                 return;
             }
-            const systemPrompt = runtime.sessionContext.buildSystemPrompt(sessionId);
-            if (systemPrompt !== null) {
+            const systemPrompts = await runtime.systemPrompts.buildPrompts(sessionId);
+            for (const systemPrompt of systemPrompts) {
                 output.system.push(systemPrompt);
             }
         },

package/dist/memory/prompt.d.ts

@@ -0,0 +1,9 @@
+import type { BindingLoggerHost } from "../binding";
+import type { GatewayMemoryConfig } from "../config/memory";
+export declare class GatewayMemoryPromptProvider {
+    private readonly config;
+    private readonly logger;
+    constructor(config: GatewayMemoryConfig, logger: Pick<BindingLoggerHost, "log">);
+    buildPrompt(): Promise<string | null>;
+    private buildEntrySection;
+}

package/dist/memory/prompt.js

@@ -0,0 +1,122 @@
+import { readFile } from "node:fs/promises";
+import { extname, relative } from "node:path";
+const MARKDOWN_GLOBS = ["**/*.md", "**/*.markdown"];
+const UTF8_TEXT_DECODER = new TextDecoder("utf-8", { fatal: true });
+export class GatewayMemoryPromptProvider {
+    config;
+    logger;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    async buildPrompt() {
+        if (this.config.entries.length === 0) {
+            return null;
+        }
+        const sections = await Promise.all(this.config.entries.map((entry) => this.buildEntrySection(entry)));
+        return ["Gateway memory:", ...sections].join("\n\n");
+    }
+    async buildEntrySection(entry) {
+        const lines = [`Configured path: ${entry.displayPath}`, `Description: ${entry.description}`];
+        const injectedFiles = await collectInjectedFiles(entry, this.logger);
+        for (const file of injectedFiles) {
+            lines.push("");
+            lines.push(`File: ${file.displayPath}`);
+            lines.push(codeFence(file.infoString, file.text));
+        }
+        return lines.join("\n");
+    }
+}
+async function collectInjectedFiles(entry, logger) {
+    if (entry.kind === "file") {
+        if (!entry.injectContent) {
+            return [];
+        }
+        const text = await readTextFile(entry.path, logger);
+        if (text === null) {
+            return [];
+        }
+        return [
+            {
+                displayPath: entry.displayPath,
+                infoString: inferFenceInfoString(entry.path),
+                text,
+            },
+        ];
+    }
+    const filePaths = new Set();
+    if (entry.injectMarkdownContents) {
+        for (const pattern of MARKDOWN_GLOBS) {
+            addMatchingFiles(filePaths, entry.path, pattern);
+        }
+    }
+    for (const pattern of entry.globs) {
+        addMatchingFiles(filePaths, entry.path, pattern);
+    }
+    const injectedFiles = [];
+    for (const filePath of [...filePaths].sort((left, right) => left.localeCompare(right))) {
+        const text = await readTextFile(filePath, logger);
+        if (text === null) {
+            continue;
+        }
+        injectedFiles.push({
+            displayPath: relativeDisplayPath(entry.path, entry.displayPath, filePath),
+            infoString: inferFenceInfoString(filePath),
+            text,
+        });
+    }
+    return injectedFiles;
+}
+function addMatchingFiles(result, cwd, pattern) {
+    const glob = new Bun.Glob(pattern);
+    for (const match of glob.scanSync({ cwd, absolute: true, onlyFiles: true })) {
+        result.add(match);
+    }
+}
+async function readTextFile(path, logger) {
+    let bytes;
+    try {
+        bytes = await readFile(path);
+    }
+    catch (error) {
+        logger.log("warn", `memory file could not be read and will be skipped: ${path}: ${formatError(error)}`);
+        return null;
+    }
+    let text;
+    try {
+        text = UTF8_TEXT_DECODER.decode(bytes);
+    }
+    catch {
+        logger.log("warn", `memory file is not valid UTF-8 and will be skipped: ${path}`);
+        return null;
+    }
+    if (text.includes("\u0000")) {
+        logger.log("warn", `memory file looks binary and will be skipped: ${path}`);
+        return null;
+    }
+    return text;
+}
+function relativeDisplayPath(rootPath, rootDisplayPath, filePath) {
+    const suffix = relative(rootPath, filePath);
+    if (suffix.length === 0) {
+        return rootDisplayPath;
+    }
+    return `${rootDisplayPath}/${suffix.replaceAll("\\", "/")}`;
+}
+function inferFenceInfoString(path) {
+    const extension = extname(path).slice(1).toLowerCase();
+    if (!/^[a-z0-9_+-]+$/.test(extension)) {
+        return "";
+    }
+    return extension;
+}
+function codeFence(infoString, text) {
+    const language = infoString.length === 0 ? "" : infoString;
+    return [`\`\`\`${language}`, text, "```"].join("\n");
+}
+function formatError(error) {
+    if (error instanceof Error && error.message.trim().length > 0) {
+        return error.message;
+    }
+    return String(error);
+}

package/dist/runtime/executor.d.ts

@@ -29,6 +29,7 @@ export declare class GatewayExecutor {
     private waitUntilIdle;
     private appendPrompt;
     private cleanupResidualBusySession;
+    private waitForSessionToSettle;
     private abortSessionAndWaitForSettle;
     private createInternalPromptIdentity;
     private executeDriver;

package/dist/runtime/executor.js

@@ -2,6 +2,7 @@ import { ConversationCoordinator } from "./conversation-coordinator";
 import { runOpencodeDriver } from "./opencode-runner";
 const SESSION_ABORT_SETTLE_TIMEOUT_MS = 5_000;
 const SESSION_ABORT_POLL_MS = 250;
+const SESSION_RESIDUAL_BUSY_GRACE_POLLS = 3;
 export class GatewayExecutor {
     module;
     store;
@@ -250,10 +251,10 @@ export class GatewayExecutor {
         expectCommandResult(result, "appendPrompt");
     }
     async cleanupResidualBusySession(sessionId) {
-        if (!(await this.opencode.isSessionBusy(sessionId))) {
+        if (await this.waitForSessionToSettle(sessionId, SESSION_RESIDUAL_BUSY_GRACE_POLLS)) {
             return;
         }
-        this.logger.log("warn", `aborting residual busy gateway session after prompt completion: ${sessionId}`);
+        this.logger.log("debug", `aborting residual busy gateway session after prompt completion: ${sessionId}`);
         try {
             await this.abortSessionAndWaitForSettle(sessionId);
         }
@@ -261,6 +262,17 @@ export class GatewayExecutor {
             this.logger.log("warn", `residual busy gateway session did not settle after abort: ${sessionId}: ${extractErrorMessage(error)}`);
         }
     }
+    async waitForSessionToSettle(sessionId, extraPolls) {
+        for (let attempt = 0; attempt <= extraPolls; attempt += 1) {
+            if (!(await this.opencode.isSessionBusy(sessionId))) {
+                return true;
+            }
+            if (attempt < extraPolls) {
+                await Bun.sleep(SESSION_ABORT_POLL_MS);
+            }
+        }
+        return false;
+    }
     async abortSessionAndWaitForSettle(sessionId) {
         await this.opencode.abortSession(sessionId);
         const deadline = Date.now() + SESSION_ABORT_SETTLE_TIMEOUT_MS;

package/dist/session/context.d.ts

@@ -6,5 +6,5 @@ export declare class GatewaySessionContext {
     replaceReplyTargets(sessionId: string, conversationKey: string, targets: BindingDeliveryTarget[], recordedAtMs: number): void;
     listReplyTargets(sessionId: string): BindingDeliveryTarget[];
     getDefaultReplyTarget(sessionId: string): BindingDeliveryTarget | null;
-    buildSystemPrompt(sessionId: string): string | null;
+    isGatewaySession(sessionId: string): boolean;
 }

package/dist/session/context.js

@@ -17,34 +17,7 @@ export class GatewaySessionContext {
     getDefaultReplyTarget(sessionId) {
         return this.store.getDefaultSessionReplyTarget(sessionId);
     }
-    buildSystemPrompt(sessionId) {
-        const targets = this.listReplyTargets(sessionId);
-        if (targets.length === 0) {
-            return null;
-        }
-        if (targets.length === 1) {
-            const target = targets[0];
-            return [
-                "Gateway context:",
-                `- Current message source channel: ${target.channel}`,
-                `- Current reply target id: ${target.target}`,
-                `- Current reply topic: ${target.topic ?? "none"}`,
-                "- Unless the user explicitly asks otherwise, channel-aware actions should default to this target.",
-                "- If the user asks to start a fresh channel session, use channel_new_session.",
-                "- If the user asks for a one-shot reminder or relative-time follow-up, prefer schedule_once.",
-                "- If the user asks for a recurring schedule, prefer cron_upsert.",
-                "- Use schedule_list and schedule_status to inspect existing scheduled jobs and recent run results.",
-                "- Scheduled results delivered to this channel are automatically appended to this session as context.",
-            ].join("\n");
-        }
-        return [
-            "Gateway context:",
-            `- This session currently fans out to ${targets.length} reply targets.`,
-            ...targets.map((target, index) => `- Target ${index + 1}: channel=${target.channel}, id=${target.target}, topic=${target.topic ?? "none"}`),
-            "- If a tool needs a single explicit target, do not guess; ask the user or use explicit tool arguments.",
-            "- If the user asks to start a fresh channel session for this route, use channel_new_session.",
-            "- Prefer schedule_once for one-shot reminders and cron_upsert for recurring schedules.",
-            "- Use schedule_list and schedule_status to inspect scheduled jobs and recent run results.",
-        ].join("\n");
+    isGatewaySession(sessionId) {
+        return this.store.hasGatewaySession(sessionId);
     }
 }

package/dist/session/system-prompt.d.ts

@@ -0,0 +1,8 @@
+import type { GatewayMemoryPromptProvider } from "../memory/prompt";
+import type { GatewaySessionContext } from "./context";
+export declare class GatewaySystemPromptBuilder {
+    private readonly sessions;
+    private readonly memory;
+    constructor(sessions: GatewaySessionContext, memory: GatewayMemoryPromptProvider);
+    buildPrompts(sessionId: string): Promise<string[]>;
+}

package/dist/session/system-prompt.js

@@ -0,0 +1,52 @@
+export class GatewaySystemPromptBuilder {
+    sessions;
+    memory;
+    constructor(sessions, memory) {
+        this.sessions = sessions;
+        this.memory = memory;
+    }
+    async buildPrompts(sessionId) {
+        if (!this.sessions.isGatewaySession(sessionId)) {
+            return [];
+        }
+        const prompts = [];
+        const gatewayPrompt = buildGatewayContextPrompt(this.sessions.listReplyTargets(sessionId));
+        if (gatewayPrompt !== null) {
+            prompts.push(gatewayPrompt);
+        }
+        const memoryPrompt = await this.memory.buildPrompt();
+        if (memoryPrompt !== null) {
+            prompts.push(memoryPrompt);
+        }
+        return prompts;
+    }
+}
+function buildGatewayContextPrompt(targets) {
+    if (targets.length === 0) {
+        return null;
+    }
+    if (targets.length === 1) {
+        const target = targets[0];
+        return [
+            "Gateway context:",
+            `- Current message source channel: ${target.channel}`,
+            `- Current reply target id: ${target.target}`,
+            `- Current reply topic: ${target.topic ?? "none"}`,
+            "- Unless the user explicitly asks otherwise, channel-aware actions should default to this target.",
+            "- If the user asks to start a fresh channel session, use channel_new_session.",
+            "- If the user asks for a one-shot reminder or relative-time follow-up, prefer schedule_once.",
+            "- If the user asks for a recurring schedule, prefer cron_upsert.",
+            "- Use schedule_list and schedule_status to inspect existing scheduled jobs and recent run results.",
+            "- Scheduled results delivered to this channel are automatically appended to this session as context.",
+        ].join("\n");
+    }
+    return [
+        "Gateway context:",
+        `- This session currently fans out to ${targets.length} reply targets.`,
+        ...targets.map((target, index) => `- Target ${index + 1}: channel=${target.channel}, id=${target.target}, topic=${target.topic ?? "none"}`),
+        "- If a tool needs a single explicit target, do not guess; ask the user or use explicit tool arguments.",
+        "- If the user asks to start a fresh channel session for this route, use channel_new_session.",
+        "- Prefer schedule_once for one-shot reminders and cron_upsert for recurring schedules.",
+        "- Use schedule_list and schedule_status to inspect scheduled jobs and recent run results.",
+    ].join("\n");
+}

package/dist/store/sqlite.d.ts

@@ -112,6 +112,7 @@ export declare class SqliteStore {
     replaceSessionReplyTargets(input: PersistSessionReplyTargetsInput): void;
     listSessionReplyTargets(sessionId: string): BindingDeliveryTarget[];
     getDefaultSessionReplyTarget(sessionId: string): BindingDeliveryTarget | null;
+    hasGatewaySession(sessionId: string): boolean;
     appendJournal(entry: RuntimeJournalEntry): void;
     replacePendingQuestion(input: PersistPendingQuestionInput): void;
     deletePendingQuestion(requestId: string): void;

package/dist/store/sqlite.js

@@ -109,6 +109,28 @@ export class SqliteStore {
             .get(sessionId);
         return row ? mapSessionReplyTargetRow(row) : null;
     }
+    hasGatewaySession(sessionId) {
+        const binding = this.db
+            .query(`
+                    SELECT 1 AS present
+                    FROM session_bindings
+                    WHERE session_id = ?1
+                    LIMIT 1;
+                `)
+            .get(sessionId);
+        if (binding?.present === 1) {
+            return true;
+        }
+        const replyTarget = this.db
+            .query(`
+                    SELECT 1 AS present
+                    FROM session_reply_targets
+                    WHERE session_id = ?1
+                    LIMIT 1;
+                `)
+            .get(sessionId);
+        return replyTarget?.present === 1;
+    }
     appendJournal(entry) {
         this.db
             .query(`

package/package.json

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

package/dist/host/noop.d.ts

@@ -1,4 +0,0 @@
-import type { BindingLoggerHost } from "../binding";
-export declare class ConsoleLoggerHost implements BindingLoggerHost {
-    log(level: string, message: string): void;
-}

package/dist/host/noop.js

@@ -1,14 +0,0 @@
-export class ConsoleLoggerHost {
-    log(level, message) {
-        const line = `[gateway:${level}] ${message}`;
-        if (level === "error") {
-            console.error(line);
-            return;
-        }
-        if (level === "warn") {
-            console.warn(line);
-            return;
-        }
-        console.info(line);
-    }
-}