opencode-gateway 0.1.1 → 0.2.1

package/dist/cli.js

@@ -58,13 +58,15 @@ function formatCliHelp() {
 
 // src/cli/doctor.ts
 import { readFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
+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;
@@ -95,10 +97,11 @@ function defaultOpencodeConfigDir(env) {
 // src/cli/opencode-config.ts
 var OPENCODE_SCHEMA_URL = "https://opencode.ai/config.json";
 var PACKAGE_NAME = "opencode-gateway";
+var PACKAGE_SPEC = "opencode-gateway@latest";
 function createDefaultOpencodeConfig(managed) {
   const document = {
     $schema: OPENCODE_SCHEMA_URL,
-    plugin: [PACKAGE_NAME]
+    plugin: [PACKAGE_SPEC]
   };
   if (managed) {
     document.server = {
@@ -109,20 +112,17 @@ function createDefaultOpencodeConfig(managed) {
   return document;
 }
 function ensureGatewayPlugin(document) {
-  const plugins = document.plugin;
+  const plugins = readPluginArray(document);
   if (plugins === undefined) {
     return {
       changed: true,
       document: {
         ...document,
-        plugin: [PACKAGE_NAME]
+        plugin: [PACKAGE_SPEC]
       }
     };
   }
-  if (!Array.isArray(plugins)) {
-    throw new Error("opencode.json field `plugin` must be an array when present");
-  }
-  if (plugins.some((entry) => entry === PACKAGE_NAME)) {
+  if (plugins.includes(PACKAGE_SPEC)) {
     return {
       changed: false,
       document
@@ -132,14 +132,14 @@ function ensureGatewayPlugin(document) {
     changed: true,
     document: {
       ...document,
-      plugin: [...plugins, PACKAGE_NAME]
+      plugin: [...plugins, PACKAGE_SPEC]
     }
   };
 }
 function parseOpencodeConfig(source, path) {
   let parsed;
   try {
-    parsed = JSON.parse(source);
+    parsed = JSON.parse(toStrictJson(source));
   } catch (error) {
     throw new Error(`failed to parse opencode config ${path}: ${formatError(error)}`);
   }
@@ -152,9 +152,143 @@ function stringifyOpencodeConfig(document) {
   return `${JSON.stringify(document, null, 2)}
 `;
 }
+function inspectGatewayPlugin(document) {
+  const plugins = readPluginArray(document);
+  if (plugins === undefined) {
+    return "no";
+  }
+  if (plugins.includes(PACKAGE_SPEC)) {
+    return "yes";
+  }
+  return plugins.some((entry) => isGatewayPluginReference(entry)) ? "needs_update" : "no";
+}
 function formatError(error) {
   return error instanceof Error ? error.message : String(error);
 }
+function readPluginArray(document) {
+  const plugins = document.plugin;
+  if (plugins === undefined) {
+    return;
+  }
+  if (!Array.isArray(plugins)) {
+    throw new Error("opencode config field `plugin` must be an array when present");
+  }
+  const normalized = [];
+  for (const [index, entry] of plugins.entries()) {
+    if (typeof entry !== "string") {
+      throw new Error(`opencode config field \`plugin[${index}]\` must be a string`);
+    }
+    normalized.push(entry);
+  }
+  return normalized;
+}
+function toStrictJson(source) {
+  return stripTrailingCommas(stripJsonComments(source));
+}
+function stripJsonComments(source) {
+  let result = "";
+  let inString = false;
+  let escaped = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let index = 0;index < source.length; index += 1) {
+    const current = source[index];
+    const next = source[index + 1];
+    if (inLineComment) {
+      if (current === `
+`) {
+        inLineComment = false;
+        result += current;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (current === "*" && next === "/") {
+        inBlockComment = false;
+        index += 1;
+      } else if (current === `
+`) {
+        result += current;
+      }
+      continue;
+    }
+    if (inString) {
+      result += current;
+      if (escaped) {
+        escaped = false;
+      } else if (current === "\\") {
+        escaped = true;
+      } else if (current === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (current === '"') {
+      inString = true;
+      result += current;
+      continue;
+    }
+    if (current === "/" && next === "/") {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+    if (current === "/" && next === "*") {
+      inBlockComment = true;
+      index += 1;
+      continue;
+    }
+    result += current;
+  }
+  return result;
+}
+function stripTrailingCommas(source) {
+  let result = "";
+  let inString = false;
+  let escaped = false;
+  for (let index = 0;index < source.length; index += 1) {
+    const current = source[index];
+    if (inString) {
+      result += current;
+      if (escaped) {
+        escaped = false;
+      } else if (current === "\\") {
+        escaped = true;
+      } else if (current === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (current === '"') {
+      inString = true;
+      result += current;
+      continue;
+    }
+    if (current === ",") {
+      const nextSignificant = findNextSignificantCharacter(source, index + 1);
+      if (nextSignificant === "]" || nextSignificant === "}") {
+        continue;
+      }
+    }
+    result += current;
+  }
+  return result;
+}
+function findNextSignificantCharacter(source, startIndex) {
+  for (let index = startIndex;index < source.length; index += 1) {
+    const current = source[index];
+    if (!/\s/.test(current)) {
+      return current;
+    }
+  }
+  return null;
+}
+function isGatewayPluginReference(entry) {
+  return entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`);
+}
+
+// src/cli/opencode-config-file.ts
+import { join as join2 } from "node:path";
 
 // src/cli/paths.ts
 import { constants } from "node:fs";
@@ -178,17 +312,34 @@ async function pathExists(path) {
   }
 }
 
+// src/cli/opencode-config-file.ts
+async function resolveOpencodeConfigFile(configDir) {
+  for (const fileName of OPENCODE_CONFIG_FILE_CANDIDATES) {
+    const path = join2(configDir, fileName);
+    if (await pathExists(path)) {
+      return {
+        path,
+        exists: true
+      };
+    }
+  }
+  return {
+    path: join2(configDir, OPENCODE_CONFIG_FILE_JSONC),
+    exists: false
+  };
+}
+
 // src/cli/doctor.ts
 async function runDoctor(options, env) {
   const configDir = resolveCliConfigDir(options, env);
-  const opencodeConfigPath = join2(configDir, OPENCODE_CONFIG_FILE);
-  const gatewayConfigPath = join2(configDir, GATEWAY_CONFIG_FILE);
+  const gatewayConfigPath = join3(configDir, GATEWAY_CONFIG_FILE);
   const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
-  const opencodeStatus = await inspectOpencodeConfig(opencodeConfigPath);
+  const opencodeConfig = await resolveOpencodeConfigFile(configDir);
+  const opencodeStatus = await inspectOpencodeConfig(opencodeConfig.path);
   const gatewayOverride = env.OPENCODE_GATEWAY_CONFIG?.trim() || null;
   console.log("doctor report");
   console.log(`  config dir: ${configDir}`);
-  console.log(`  opencode config: ${await describePath(opencodeConfigPath)}`);
+  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 override: ${gatewayOverride ?? "not set"}`);
@@ -210,21 +361,8 @@ async function inspectOpencodeConfig(path) {
   }
   try {
     const parsed = parseOpencodeConfig(await readFile(path, "utf8"), path);
-    const plugins = parsed.plugin;
-    if (plugins === undefined) {
-      return {
-        pluginConfigured: "no",
-        error: null
-      };
-    }
-    if (!Array.isArray(plugins)) {
-      return {
-        pluginConfigured: "invalid",
-        error: "`plugin` is not an array"
-      };
-    }
     return {
-      pluginConfigured: plugins.some((entry) => entry === "opencode-gateway") ? "yes" : "no",
+      pluginConfigured: inspectGatewayPlugin(parsed),
       error: null
     };
   } catch (error) {
@@ -237,7 +375,7 @@ async function inspectOpencodeConfig(path) {
 
 // src/cli/init.ts
 import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { dirname as dirname2, join as join4 } from "node:path";
 
 // src/cli/templates.ts
 function buildGatewayConfigTemplate(stateDbPath) {
@@ -247,6 +385,7 @@ function buildGatewayConfigTemplate(stateDbPath) {
     "",
     "[gateway]",
     `state_db = "${escapeTomlString(stateDbPath)}"`,
+    '# log_level = "warn"',
     "",
     "[cron]",
     "enabled = true",
@@ -260,6 +399,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(`
 `);
@@ -271,13 +424,14 @@ function escapeTomlString(value) {
 // src/cli/init.ts
 async function runInit(options, env) {
   const configDir = resolveCliConfigDir(options, env);
-  const opencodeConfigPath = join3(configDir, OPENCODE_CONFIG_FILE);
-  const gatewayConfigPath = join3(configDir, GATEWAY_CONFIG_FILE);
+  const gatewayConfigPath = join4(configDir, GATEWAY_CONFIG_FILE);
   const workspaceDirPath = resolveGatewayWorkspacePath(gatewayConfigPath);
+  const opencodeConfig = await resolveOpencodeConfigFile(configDir);
+  const opencodeConfigPath = opencodeConfig.path;
   await mkdir(configDir, { recursive: true });
   await mkdir(workspaceDirPath, { recursive: true });
   let opencodeStatus = "already present";
-  if (!await pathExists(opencodeConfigPath)) {
+  if (!opencodeConfig.exists) {
     await writeFile(opencodeConfigPath, stringifyOpencodeConfig(createDefaultOpencodeConfig(options.managed)));
     opencodeStatus = "created";
   } else {

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/config/paths.d.ts

@@ -1,5 +1,7 @@
 export declare const GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
 export declare const OPENCODE_CONFIG_FILE = "opencode.json";
+export declare const OPENCODE_CONFIG_FILE_JSONC = "opencode.jsonc";
+export declare const OPENCODE_CONFIG_FILE_CANDIDATES: readonly ["opencode.jsonc", "opencode.json"];
 export declare const GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
 type EnvSource = Record<string, string | undefined>;
 export declare function resolveGatewayConfigPath(env: EnvSource): string;

package/dist/config/paths.js

@@ -2,6 +2,8 @@ import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 export const GATEWAY_CONFIG_FILE = "opencode-gateway.toml";
 export const OPENCODE_CONFIG_FILE = "opencode.json";
+export const OPENCODE_CONFIG_FILE_JSONC = "opencode.jsonc";
+export const OPENCODE_CONFIG_FILE_CANDIDATES = [OPENCODE_CONFIG_FILE_JSONC, OPENCODE_CONFIG_FILE];
 export const GATEWAY_WORKSPACE_DIR = "opencode-gateway-workspace";
 export function resolveGatewayConfigPath(env) {
     const explicit = env.OPENCODE_GATEWAY_CONFIG;

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;
+}