opencode-gateway 0.2.10 → 0.3.1

package/README.md

@@ -98,8 +98,12 @@ inject_content = true
 [[memory.entries]]
 path = "memory/notes"
 description = "Domain notes and operating docs"
-inject_markdown_contents = true
-globs = ["**/*.rs", "notes/**/*.txt"]
+search_only = true
+
+[[memory.entries]]
+path = "memory/snippets"
+description = "Selected files are auto-injected; the rest stay searchable on demand"
+globs = ["**/*.md", "notes/**/*.txt"]
 ```
 
 When Telegram is enabled, export the bot token through the configured
@@ -122,13 +126,16 @@ Mailbox rules:
 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
+- file contents are auto-injected only when `inject_content = true`
+- `search_only = true` keeps an entry available to `memory_search` and `memory_get`
+  without auto-injecting its content
+- directory entries default to description-only plus on-demand search
+- directory `globs` are relative to the configured directory and define which
+  files are auto-injected; other UTF-8 text files remain searchable on demand
 - 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
+- `memory_search` returns matching snippets and paths; `memory_get` reads a
+  specific configured memory file by path and optional line window

package/dist/cli.js

@@ -518,10 +518,19 @@ function buildGatewayConfigTemplate(stateDbPath) {
     "inject_content = true",
     "#",
     "# [[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"]',
+    '# description = "Domain notes and operating docs. Use memory_search and memory_get to inspect this directory on demand."',
+    "# search_only = true",
+    "#",
+    "# [[memory.entries]]",
+    '# path = "memory/snippets"',
+    '# description = "Selected files are auto-injected; the rest stay searchable on demand."',
+    '# globs = ["**/*.md", "notes/**/*.txt"]',
     ""
   ].join(`
 `);

package/dist/config/memory.d.ts

@@ -7,12 +7,13 @@ export type GatewayMemoryEntryConfig = {
     displayPath: string;
     description: string;
     injectContent: boolean;
+    searchOnly: boolean;
 } | {
     kind: "directory";
     path: string;
     displayPath: string;
     description: string;
-    injectMarkdownContents: boolean;
     globs: string[];
+    searchOnly: boolean;
 };
 export declare function parseMemoryConfig(value: unknown, workspaceDirPath: string): Promise<GatewayMemoryConfig>;

package/dist/gateway.d.ts

@@ -2,6 +2,7 @@ import type { PluginInput } from "@opencode-ai/plugin";
 import type { GatewayBindingModule, GatewayContract } from "./binding";
 import { GatewayCronRuntime } from "./cron/runtime";
 import { ChannelFileSender } from "./host/file-sender";
+import { GatewayMemoryRuntime } from "./memory/runtime";
 import { GatewayExecutor } from "./runtime/executor";
 import { GatewaySessionContext } from "./session/context";
 import { ChannelSessionSwitcher } from "./session/switcher";
@@ -29,7 +30,8 @@ export declare class GatewayPluginRuntime {
     readonly channelSessions: ChannelSessionSwitcher;
     readonly sessionContext: GatewaySessionContext;
     readonly systemPrompts: GatewaySystemPromptBuilder;
-    constructor(contract: GatewayContract, executor: GatewayExecutor, cron: GatewayCronRuntime, telegram: GatewayTelegramRuntime, files: ChannelFileSender, channelSessions: ChannelSessionSwitcher, sessionContext: GatewaySessionContext, systemPrompts: GatewaySystemPromptBuilder);
+    readonly memory: GatewayMemoryRuntime;
+    constructor(contract: GatewayContract, executor: GatewayExecutor, cron: GatewayCronRuntime, telegram: GatewayTelegramRuntime, files: ChannelFileSender, channelSessions: ChannelSessionSwitcher, sessionContext: GatewaySessionContext, systemPrompts: GatewaySystemPromptBuilder, memory: GatewayMemoryRuntime);
     status(): GatewayPluginStatus;
 }
 export declare function createGatewayRuntime(module: GatewayBindingModule, input: PluginInput): Promise<GatewayPluginRuntime>;

package/dist/index.js

@@ -16151,30 +16151,42 @@ async function readMemoryEntry(value, index, workspaceDirPath) {
     throw new Error(`${field} must be a table`);
   }
   const entry = value;
+  if (entry.inject_markdown_contents !== undefined) {
+    throw new Error(`${field}.inject_markdown_contents has been removed; use globs for directory injection or search_only for on-demand access`);
+  }
   const displayPath = readRequiredString(entry.path, `${field}.path`);
   const description = readRequiredString(entry.description, `${field}.description`);
   const resolvedPath = resolve(workspaceDirPath, displayPath);
   const metadata = await ensurePathMetadata(resolvedPath, displayPath, entry, `${field}.path`);
+  const searchOnly = readBoolean2(entry.search_only, `${field}.search_only`, false);
   if (metadata.isFile()) {
-    ensureDirectoryOnlyFieldIsAbsent(entry.inject_markdown_contents, `${field}.inject_markdown_contents`);
     ensureDirectoryOnlyFieldIsAbsent(entry.globs, `${field}.globs`);
+    const injectContent = readBoolean2(entry.inject_content, `${field}.inject_content`, false);
+    if (searchOnly && injectContent) {
+      throw new Error(`${field} cannot enable both inject_content and search_only`);
+    }
     return {
       kind: "file",
       path: resolvedPath,
       displayPath,
       description,
-      injectContent: readBoolean2(entry.inject_content, `${field}.inject_content`, false)
+      injectContent,
+      searchOnly
     };
   }
   if (metadata.isDirectory()) {
     ensureFileOnlyFieldIsAbsent(entry.inject_content, `${field}.inject_content`);
+    const globs = readGlobList(entry.globs, `${field}.globs`);
+    if (searchOnly && globs.length > 0) {
+      throw new Error(`${field} cannot enable both globs and search_only`);
+    }
     return {
       kind: "directory",
       path: resolvedPath,
       displayPath,
       description,
-      injectMarkdownContents: readBoolean2(entry.inject_markdown_contents, `${field}.inject_markdown_contents`, false),
-      globs: readGlobList(entry.globs, `${field}.globs`)
+      globs,
+      searchOnly
     };
   }
   throw new Error(`${field}.path must point to a regular file or directory`);
@@ -16198,7 +16210,7 @@ function inferMissingEntryKind(displayPath, entry) {
   if (entry.inject_content !== undefined) {
     return "file";
   }
-  if (entry.inject_markdown_contents !== undefined || entry.globs !== undefined) {
+  if (entry.globs !== undefined) {
     return "directory";
   }
   const trimmedPath = displayPath.trim();
@@ -17614,87 +17626,58 @@ class GatewayMailboxRouter {
   }
 }
 
-// src/memory/prompt.ts
+// src/memory/files.ts
 var import_fast_glob = __toESM(require_out4(), 1);
 import { readFile as readFile3 } from "node:fs/promises";
 import { extname as extname3, relative } from "node:path";
-var MARKDOWN_GLOBS = ["**/*.md", "**/*.markdown"];
+var ALL_FILES_GLOB = "**/*";
 var UTF8_TEXT_DECODER = new TextDecoder("utf-8", { fatal: true });
-
-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(`
-
-`);
-  }
-  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(`
-`);
-  }
-}
-async function collectInjectedFiles(entry, logger) {
+async function collectInjectedMemoryFiles(entry, logger) {
   if (entry.kind === "file") {
-    if (!entry.injectContent) {
+    if (entry.searchOnly || !entry.injectContent) {
       return [];
     }
-    const text = await readTextFile(entry.path, logger);
+    const text = await readMemoryTextFile(entry.path, logger);
     if (text === null) {
       return [];
     }
     return [
       {
+        path: entry.path,
         displayPath: entry.displayPath,
+        description: entry.description,
         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);
+  if (entry.searchOnly || entry.globs.length === 0) {
+    return [];
   }
-  const injectedFiles = [];
-  for (const filePath of [...filePaths].sort((left, right) => left.localeCompare(right))) {
-    const text = await readTextFile(filePath, logger);
-    if (text === null) {
+  return await readDirectoryFiles(entry, entry.globs, logger);
+}
+async function collectSearchableMemoryFiles(config, logger) {
+  const files = [];
+  for (const entry of config.entries) {
+    if (entry.kind === "file") {
+      const text = await readMemoryTextFile(entry.path, logger);
+      if (text === null) {
+        continue;
+      }
+      files.push({
+        path: entry.path,
+        displayPath: entry.displayPath,
+        description: entry.description,
+        infoString: inferFenceInfoString(entry.path),
+        text
+      });
       continue;
     }
-    injectedFiles.push({
-      displayPath: relativeDisplayPath(entry.path, entry.displayPath, filePath),
-      infoString: inferFenceInfoString(filePath),
-      text
-    });
-  }
-  return injectedFiles;
-}
-function addMatchingFiles(result, cwd, pattern) {
-  for (const match of import_fast_glob.globSync(pattern, { cwd, absolute: true, onlyFiles: true })) {
-    result.add(match);
+    files.push(...await readDirectoryFiles(entry, [ALL_FILES_GLOB], logger));
   }
+  return files;
 }
-async function readTextFile(path, logger) {
+async function readMemoryTextFile(path, logger) {
   let bytes;
   try {
     bytes = await readFile3(path);
@@ -17715,6 +17698,37 @@ async function readTextFile(path, logger) {
   }
   return text;
 }
+function codeFence(infoString, text) {
+  const language = infoString.length === 0 ? "" : infoString;
+  return [`\`\`\`${language}`, text, "```"].join(`
+`);
+}
+function addMatchingFiles(result, cwd, pattern) {
+  for (const match of import_fast_glob.globSync(pattern, { cwd, absolute: true, onlyFiles: true, followSymbolicLinks: false })) {
+    result.add(match);
+  }
+}
+async function readDirectoryFiles(entry, patterns, logger) {
+  const filePaths = new Set;
+  for (const pattern of patterns) {
+    addMatchingFiles(filePaths, entry.path, pattern);
+  }
+  const files = [];
+  for (const filePath of [...filePaths].sort((left, right) => left.localeCompare(right))) {
+    const text = await readMemoryTextFile(filePath, logger);
+    if (text === null) {
+      continue;
+    }
+    files.push({
+      path: filePath,
+      displayPath: relativeDisplayPath(entry.path, entry.displayPath, filePath),
+      description: entry.description,
+      infoString: inferFenceInfoString(filePath),
+      text
+    });
+  }
+  return files;
+}
 function relativeDisplayPath(rootPath, rootDisplayPath, filePath) {
   const suffix = relative(rootPath, filePath);
   if (suffix.length === 0) {
@@ -17729,11 +17743,6 @@ function inferFenceInfoString(path) {
   }
   return extension2;
 }
-function codeFence(infoString, text) {
-  const language = infoString.length === 0 ? "" : infoString;
-  return [`\`\`\`${language}`, text, "```"].join(`
-`);
-}
 function formatError2(error) {
   if (error instanceof Error && error.message.trim().length > 0) {
     return error.message;
@@ -17741,6 +17750,218 @@ function formatError2(error) {
   return String(error);
 }
 
+// src/memory/prompt.ts
+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(`
+
+`);
+  }
+  async buildEntrySection(entry) {
+    const lines = [
+      `Configured path: ${entry.displayPath}`,
+      `Description: ${entry.description}`,
+      `Access: ${describeMemoryAccess(entry)}`
+    ];
+    const injectedFiles = await collectInjectedMemoryFiles(entry, this.logger);
+    if (entry.kind === "directory" && entry.globs.length > 0 && !entry.searchOnly) {
+      lines.push(`Auto-injected globs: ${entry.globs.join(", ")}`);
+    }
+    for (const file of injectedFiles) {
+      lines.push("");
+      lines.push(`File: ${file.displayPath}`);
+      lines.push(codeFence(file.infoString, file.text));
+    }
+    return lines.join(`
+`);
+  }
+}
+function describeMemoryAccess(entry) {
+  if (entry.kind === "file") {
+    if (entry.injectContent && !entry.searchOnly) {
+      return "auto-injected; use memory_search or memory_get for targeted follow-up";
+    }
+    return "search-only; use memory_search or memory_get when this file is relevant";
+  }
+  if (entry.searchOnly) {
+    return "search-only; all UTF-8 text files under this directory are available via memory_search or memory_get";
+  }
+  if (entry.globs.length > 0) {
+    return "globs are auto-injected; all UTF-8 text files under this directory remain available via memory_search or memory_get";
+  }
+  return "search-only by default; use memory_search or memory_get when this directory is relevant";
+}
+
+// src/memory/runtime.ts
+import { dirname as dirname3 } from "node:path";
+import { FileFinder } from "@ff-labs/fff-node";
+var DEFAULT_SEARCH_LIMIT = 5;
+var MAX_SEARCH_LIMIT = 20;
+var DEFAULT_GET_MAX_LINES = 200;
+var MAX_GET_MAX_LINES = 500;
+var SEARCH_CONTEXT_RADIUS = 1;
+var SEARCH_SCAN_TIMEOUT_MS = 5000;
+
+class GatewayMemoryRuntime {
+  config;
+  logger;
+  finderCache = new Map;
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+  }
+  hasEntries() {
+    return this.config.entries.length > 0;
+  }
+  async search(query, limit = DEFAULT_SEARCH_LIMIT) {
+    const normalizedQuery = normalizeRequiredString(query, "query");
+    const normalizedLimit = normalizePositiveInteger(limit, "limit", MAX_SEARCH_LIMIT);
+    const searchableFiles = await collectSearchableMemoryFiles(this.config, this.logger);
+    const searchableFilesByPath = new Map(searchableFiles.map((file) => [file.path, file]));
+    const results = [];
+    for (const entry of this.config.entries) {
+      const finder = await this.getFinder(searchRootForEntry(entry));
+      const grep = finder.grep(normalizedQuery, {
+        mode: "plain",
+        beforeContext: SEARCH_CONTEXT_RADIUS,
+        afterContext: SEARCH_CONTEXT_RADIUS
+      });
+      if (!grep.ok) {
+        throw new Error(`memory search failed for ${entry.displayPath}: ${grep.error}`);
+      }
+      for (const match of grep.value.items) {
+        if (entry.kind === "file" && match.path !== entry.path) {
+          continue;
+        }
+        const searchableFile = searchableFilesByPath.get(match.path);
+        if (searchableFile === undefined) {
+          continue;
+        }
+        const window2 = readSnippetWindow(searchableFile.text, match.lineNumber, SEARCH_CONTEXT_RADIUS);
+        results.push({
+          path: displayPathForMatch(entry, match.relativePath),
+          description: entry.description,
+          lineStart: window2.lineStart,
+          lineEnd: window2.lineEnd,
+          snippet: window2.text,
+          infoString: searchableFile.infoString
+        });
+        if (results.length >= normalizedLimit) {
+          return results;
+        }
+      }
+    }
+    return results;
+  }
+  async get(path, startLine = 1, maxLines = DEFAULT_GET_MAX_LINES) {
+    const normalizedPath = normalizeRequiredString(path, "path");
+    const normalizedStartLine = normalizePositiveInteger(startLine, "start_line");
+    const normalizedMaxLines = normalizePositiveInteger(maxLines, "max_lines", MAX_GET_MAX_LINES);
+    const files = await collectSearchableMemoryFiles(this.config, this.logger);
+    const matches = files.filter((file2) => file2.displayPath === normalizedPath);
+    if (matches.length === 0) {
+      throw new Error(`memory path was not found: ${normalizedPath}`);
+    }
+    if (matches.length > 1) {
+      throw new Error(`memory path is ambiguous: ${normalizedPath}`);
+    }
+    const file = matches[0];
+    const lines = splitLines(file.text);
+    if (normalizedStartLine > lines.length) {
+      throw new Error(`start_line ${normalizedStartLine} exceeds the file length of ${lines.length} line(s) for ${normalizedPath}`);
+    }
+    const startIndex = normalizedStartLine - 1;
+    const window2 = lines.slice(startIndex, startIndex + normalizedMaxLines);
+    return {
+      path: file.displayPath,
+      description: file.description,
+      lineStart: normalizedStartLine,
+      lineEnd: startIndex + window2.length,
+      text: window2.join(`
+`),
+      infoString: file.infoString
+    };
+  }
+  async getFinder(rootPath) {
+    const cached = this.finderCache.get(rootPath);
+    if (cached !== undefined && !cached.isDestroyed) {
+      return cached;
+    }
+    const created = FileFinder.create({
+      basePath: rootPath,
+      aiMode: true
+    });
+    if (!created.ok) {
+      throw new Error(`could not initialize memory search index for ${rootPath}: ${created.error}`);
+    }
+    const finder = created.value;
+    const ready = await finder.waitForScan(SEARCH_SCAN_TIMEOUT_MS);
+    if (!ready.ok) {
+      finder.destroy();
+      throw new Error(`memory search index failed while waiting for scan: ${ready.error}`);
+    }
+    if (!ready.value) {
+      this.logger.log("warn", `memory search scan is still warming after ${SEARCH_SCAN_TIMEOUT_MS}ms: ${rootPath}`);
+    }
+    this.finderCache.set(rootPath, finder);
+    return finder;
+  }
+}
+function searchRootForEntry(entry) {
+  return entry.kind === "file" ? dirname3(entry.path) : entry.path;
+}
+function displayPathForMatch(entry, relativePath) {
+  if (entry.kind === "file") {
+    return entry.displayPath;
+  }
+  const normalizedRelativePath = relativePath.replaceAll("\\", "/");
+  return normalizedRelativePath.length === 0 ? entry.displayPath : `${entry.displayPath}/${normalizedRelativePath}`;
+}
+function splitLines(text) {
+  return text.split(/\r?\n/);
+}
+function readSnippetWindow(text, lineNumber, contextRadius) {
+  const lines = splitLines(text);
+  const matchIndex = Math.min(Math.max(lineNumber - 1, 0), Math.max(lines.length - 1, 0));
+  const startIndex = Math.max(0, matchIndex - contextRadius);
+  const endIndex = Math.min(lines.length - 1, matchIndex + contextRadius);
+  return {
+    lineStart: startIndex + 1,
+    lineEnd: endIndex + 1,
+    text: lines.slice(startIndex, endIndex + 1).join(`
+`)
+  };
+}
+function normalizePositiveInteger(value, field, maxValue) {
+  if (!Number.isSafeInteger(value)) {
+    throw new Error(`${field} must be an integer`);
+  }
+  if (value <= 0) {
+    throw new Error(`${field} must be greater than 0`);
+  }
+  if (maxValue !== undefined && value > maxValue) {
+    throw new Error(`${field} must be less than or equal to ${maxValue}`);
+  }
+  return value;
+}
+function normalizeRequiredString(value, field) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`${field} must not be empty`);
+  }
+  return trimmed;
+}
+
 // src/opencode/adapter.ts
 import { basename as basename2 } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -18010,18 +18231,24 @@ function listAssistantResponses(messages, userMessageId) {
 function selectAssistantResponse(assistantChildren) {
   for (let index = assistantChildren.length - 1;index >= 0; index -= 1) {
     const candidate = assistantChildren[index];
-    if (hasVisibleText(candidate)) {
+    if (isTerminalAssistantMessage(candidate) && hasVisibleText(candidate)) {
       return candidate;
     }
   }
   for (let index = assistantChildren.length - 1;index >= 0; index -= 1) {
     const candidate = assistantChildren[index];
-    if (candidate.info?.finish === "stop" || candidate.info?.error !== undefined) {
+    if (isTerminalAssistantMessage(candidate)) {
       return candidate;
     }
   }
   return null;
 }
+function isTerminalAssistantMessage(message) {
+  if (message.info.error !== undefined) {
+    return true;
+  }
+  return typeof message.info.finish === "string" && message.info.finish !== "tool-calls";
+}
 function createAssistantProgressKey(messages) {
   return JSON.stringify(messages.map(createAssistantCandidateKey));
 }
@@ -22492,7 +22719,7 @@ function buildGatewayContextPrompt(targets) {
 
 // src/store/sqlite.ts
 import { mkdir as mkdir2 } from "node:fs/promises";
-import { dirname as dirname3 } from "node:path";
+import { dirname as dirname4 } from "node:path";
 
 // src/store/migrations.ts
 var LATEST_SCHEMA_VERSION = 7;
@@ -23406,7 +23633,7 @@ function readBooleanField(value, field, fallback) {
   return raw;
 }
 async function openSqliteStore(path) {
-  await mkdir2(dirname3(path), { recursive: true });
+  await mkdir2(dirname4(path), { recursive: true });
   const { openRuntimeSqliteDatabase: openRuntimeSqliteDatabase2 } = await Promise.resolve().then(() => (init_database(), exports_database));
   const db2 = await openRuntimeSqliteDatabase2(path);
   migrateGatewayDatabase(db2);
@@ -24136,7 +24363,8 @@ class GatewayPluginRuntime {
   channelSessions;
   sessionContext;
   systemPrompts;
-  constructor(contract, executor, cron, telegram, files, channelSessions, sessionContext, systemPrompts) {
+  memory;
+  constructor(contract, executor, cron, telegram, files, channelSessions, sessionContext, systemPrompts, memory) {
     this.contract = contract;
     this.executor = executor;
     this.cron = cron;
@@ -24145,6 +24373,7 @@ class GatewayPluginRuntime {
     this.channelSessions = channelSessions;
     this.sessionContext = sessionContext;
     this.systemPrompts = systemPrompts;
+    this.memory = memory;
   }
   status() {
     const rustStatus = this.contract.gatewayStatus();
@@ -24175,6 +24404,7 @@ async function createGatewayRuntime(module, input) {
     const effectiveCronTimeZone = resolveEffectiveCronTimeZone(module, config);
     const store = await openSqliteStore(config.stateDbPath);
     const sessionContext = new GatewaySessionContext(store);
+    const memory = new GatewayMemoryRuntime(config.memory, logger);
     const memoryPrompts = new GatewayMemoryPromptProvider(config.memory, logger);
     const systemPrompts = new GatewaySystemPromptBuilder(sessionContext, memoryPrompts);
     const telegramClient = config.telegram.enabled ? new TelegramBotClient(config.telegram.botToken) : null;
@@ -24199,7 +24429,7 @@ async function createGatewayRuntime(module, input) {
     cron.start();
     mailbox.start();
     telegram.start();
-    return new GatewayPluginRuntime(module, executor, cron, telegram, files, channelSessions, sessionContext, systemPrompts);
+    return new GatewayPluginRuntime(module, executor, cron, telegram, files, channelSessions, sessionContext, systemPrompts, memory);
   });
 }
 function resolveEffectiveCronTimeZone(module, config) {
@@ -36761,6 +36991,63 @@ function formatGatewayStatus(status) {
 `);
 }
 
+// src/tools/memory-get.ts
+function createMemoryGetTool(runtime) {
+  return tool({
+    description: "Read a configured gateway memory file by path. Use the path returned by memory_search or a configured file path.",
+    args: {
+      path: tool.schema.string().min(1),
+      start_line: tool.schema.number().optional(),
+      max_lines: tool.schema.number().optional()
+    },
+    async execute(args) {
+      return formatMemoryGetResult(await runtime.get(args.path, args.start_line, args.max_lines));
+    }
+  });
+}
+function formatMemoryGetResult(result) {
+  return [
+    `path=${result.path}`,
+    `description=${result.description}`,
+    `line_start=${result.lineStart}`,
+    `line_end=${result.lineEnd}`,
+    "content:",
+    codeFence(result.infoString, result.text)
+  ].join(`
+`);
+}
+
+// src/tools/memory-search.ts
+function createMemorySearchTool(runtime) {
+  return tool({
+    description: "Search configured gateway memory files and directories. Returns matching snippets and paths that can be read in more detail with memory_get.",
+    args: {
+      query: tool.schema.string().min(1),
+      limit: tool.schema.number().optional()
+    },
+    async execute(args) {
+      const results = await runtime.search(args.query, args.limit);
+      if (results.length === 0) {
+        return "no memory matches";
+      }
+      return results.map((result, index) => formatMemorySearchResult(result, index + 1)).join(`
+
+`);
+    }
+  });
+}
+function formatMemorySearchResult(result, ordinal) {
+  return [
+    `result[${ordinal}].path=${result.path}`,
+    `result[${ordinal}].description=${result.description}`,
+    `result[${ordinal}].line_start=${result.lineStart}`,
+    `result[${ordinal}].line_end=${result.lineEnd}`,
+    `result[${ordinal}].snippet:`,
+    codeFence(result.infoString, result.snippet)
+  ].join(`
+`);
+}
+
 // src/tools/schedule-cancel.ts
 function createScheduleCancelTool(runtime) {
   return tool({
@@ -37001,6 +37288,10 @@ var OpencodeGatewayPlugin = async (input) => {
     schedule_once: createScheduleOnceTool(runtime.cron, runtime.sessionContext),
     schedule_status: createScheduleStatusTool(runtime.cron)
   };
+  if (runtime.memory.hasEntries()) {
+    tools.memory_search = createMemorySearchTool(runtime.memory);
+    tools.memory_get = createMemoryGetTool(runtime.memory);
+  }
   if (runtime.files.hasEnabledChannel()) {
     tools.channel_send_file = createChannelSendFileTool(runtime.files, runtime.sessionContext);
   }

package/dist/memory/files.d.ts

@@ -0,0 +1,13 @@
+import type { BindingLoggerHost } from "../binding";
+import type { GatewayMemoryConfig, GatewayMemoryEntryConfig } from "../config/memory";
+export type SearchableMemoryFile = {
+    path: string;
+    displayPath: string;
+    description: string;
+    infoString: string;
+    text: string;
+};
+export declare function collectInjectedMemoryFiles(entry: GatewayMemoryEntryConfig, logger: Pick<BindingLoggerHost, "log">): Promise<SearchableMemoryFile[]>;
+export declare function collectSearchableMemoryFiles(config: GatewayMemoryConfig, logger: Pick<BindingLoggerHost, "log">): Promise<SearchableMemoryFile[]>;
+export declare function readMemoryTextFile(path: string, logger: Pick<BindingLoggerHost, "log">): Promise<string | null>;
+export declare function codeFence(infoString: string, text: string): string;

package/dist/memory/runtime.d.ts

@@ -0,0 +1,28 @@
+import type { BindingLoggerHost } from "../binding";
+import type { GatewayMemoryConfig } from "../config/memory";
+export type MemorySearchResult = {
+    path: string;
+    description: string;
+    lineStart: number;
+    lineEnd: number;
+    snippet: string;
+    infoString: string;
+};
+export type MemoryGetResult = {
+    path: string;
+    description: string;
+    lineStart: number;
+    lineEnd: number;
+    text: string;
+    infoString: string;
+};
+export declare class GatewayMemoryRuntime {
+    private readonly config;
+    private readonly logger;
+    private readonly finderCache;
+    constructor(config: GatewayMemoryConfig, logger: Pick<BindingLoggerHost, "log">);
+    hasEntries(): boolean;
+    search(query: string, limit?: number): Promise<MemorySearchResult[]>;
+    get(path: string, startLine?: number, maxLines?: number): Promise<MemoryGetResult>;
+    private getFinder;
+}

package/dist/tools/memory-get.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import type { GatewayMemoryRuntime } from "../memory/runtime";
+export declare function createMemoryGetTool(runtime: GatewayMemoryRuntime): ToolDefinition;

package/dist/tools/memory-search.d.ts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import type { GatewayMemoryRuntime } from "../memory/runtime";
+export declare function createMemorySearchTool(runtime: GatewayMemoryRuntime): ToolDefinition;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-gateway",
-  "version": "0.2.10",
+  "version": "0.3.1",
   "description": "Gateway plugin for OpenCode",
   "license": "MIT",
   "type": "module",
@@ -52,6 +52,7 @@
     "access": "public"
   },
   "dependencies": {
+    "@ff-labs/fff-node": "^0.4.2",
     "@opencode-ai/plugin": "~1.3.0",
     "@opencode-ai/sdk": "~1.3.0",
     "better-sqlite3": "^12.8.0",