opencode-gateway 0.1.0 → 0.2.0

package/dist/cron/runtime.js

@@ -1,6 +1,7 @@
 import { formatError } from "../utils/error";
 const CRON_EFFECTIVE_TIME_ZONE_KEY = "cron.effective_timezone";
 const LEGACY_CRON_TIME_ZONE = "UTC";
+const MAX_STATUS_RUNS = 20;
 export class GatewayCronRuntime {
     executor;
     contract;
@@ -8,15 +9,17 @@ export class GatewayCronRuntime {
     logger;
     config;
     effectiveTimeZone;
+    resolveConversationKeyForTarget;
     runningJobIds = new Set();
     running = false;
-    constructor(executor, contract, store, logger, config, effectiveTimeZone) {
+    constructor(executor, contract, store, logger, config, effectiveTimeZone, resolveConversationKeyForTarget) {
         this.executor = executor;
         this.contract = contract;
         this.store = store;
         this.logger = logger;
         this.config = config;
         this.effectiveTimeZone = effectiveTimeZone;
+        this.resolveConversationKeyForTarget = resolveConversationKeyForTarget;
     }
     isEnabled() {
         return this.config.enabled;
@@ -39,8 +42,21 @@ export class GatewayCronRuntime {
             this.running = false;
         });
     }
-    listJobs() {
-        return this.store.listCronJobs();
+    listJobs(includeTerminal = false) {
+        const jobs = this.store.listCronJobs();
+        if (includeTerminal) {
+            return jobs;
+        }
+        return jobs.filter((job) => !isTerminalJob(job));
+    }
+    getJobStatus(id, limit = 5) {
+        const job = this.requireJob(normalizeId(id));
+        const runs = this.store.listCronRuns(job.id, clampStatusLimit(limit));
+        return {
+            job,
+            state: deriveJobState(job, runs[0] ?? null),
+            runs,
+        };
     }
     upsertJob(input) {
         const normalized = normalizeUpsertInput(input);
@@ -53,13 +69,31 @@ export class GatewayCronRuntime {
         });
         return this.requireJob(normalized.id);
     }
-    removeJob(id) {
-        return this.store.removeCronJob(normalizeId(id));
+    scheduleOnce(input) {
+        const normalized = normalizeOnceInput(input);
+        const recordedAtMs = Date.now();
+        this.store.upsertCronJob({
+            ...normalized,
+            nextRunAtMs: normalized.runAtMs ?? recordedAtMs,
+            recordedAtMs,
+        });
+        return this.requireJob(normalized.id);
+    }
+    cancelJob(id) {
+        const job = this.store.getCronJob(normalizeId(id));
+        if (job === null || !job.enabled) {
+            return false;
+        }
+        this.store.setCronJobEnabled(job.id, false, Date.now());
+        return true;
     }
     async runNow(id) {
         const job = this.requireJob(normalizeId(id));
+        if (!job.enabled) {
+            throw new Error(`schedule job is not active: ${job.id}`);
+        }
         if (this.runningJobIds.has(job.id)) {
-            throw new Error(`cron job is already running: ${job.id}`);
+            throw new Error(`schedule job is already running: ${job.id}`);
         }
         this.runningJobIds.add(job.id);
         try {
@@ -88,7 +122,7 @@ export class GatewayCronRuntime {
                 ? `rebasing enabled cron jobs from legacy ${LEGACY_CRON_TIME_ZONE} semantics to ${this.effectiveTimeZone}`
                 : `cron time zone changed from ${previousTimeZone} to ${this.effectiveTimeZone}; rebasing enabled jobs`;
             this.logger.log("warn", message);
-            this.rebaseJobs(this.store.listCronJobs().filter((job) => job.enabled), nowMs);
+            this.rebaseJobs(this.store.listCronJobs().filter((job) => job.enabled && job.kind === "cron"), nowMs);
         }
         else {
             this.rebaseJobs(this.store.listOverdueCronJobs(nowMs), nowMs);
@@ -108,7 +142,7 @@ export class GatewayCronRuntime {
             this.runningJobIds.add(job.id);
             void this.executeJob(job, job.nextRunAtMs, nowMs)
                 .catch((error) => {
-                this.logger.log("error", `cron job ${job.id} failed: ${formatError(error)}`);
+                this.logger.log("error", `schedule job ${job.id} failed: ${formatError(error)}`);
             })
                 .finally(() => {
                 this.runningJobIds.delete(job.id);
@@ -120,26 +154,60 @@ export class GatewayCronRuntime {
     }
     async executeJob(job, scheduledForMs, nextRunBaseMs) {
         const startedAtMs = Date.now();
-        if (nextRunBaseMs !== null) {
+        if (job.kind === "cron" && nextRunBaseMs !== null) {
             const nextRunAtMs = computeNextRunAt(this.contract, job, Math.max(nextRunBaseMs, scheduledForMs), this.effectiveTimeZone);
             this.store.updateCronJobNextRun(job.id, nextRunAtMs, startedAtMs);
         }
+        else if (job.kind === "once") {
+            this.store.setCronJobEnabled(job.id, false, startedAtMs);
+        }
         const runId = this.store.insertCronRun(job.id, scheduledForMs, startedAtMs);
         try {
-            const report = await this.executor.dispatchCronJob(toBindingCronJobSpec(job));
+            const report = await this.executor.dispatchScheduledJob({
+                jobId: job.id,
+                jobKind: job.kind,
+                conversationKey: conversationKeyForJob(job),
+                prompt: job.prompt,
+                replyTarget: toReplyTarget(job),
+            });
             this.store.finishCronRun(runId, "succeeded", Date.now(), report.responseText, null);
+            await this.appendScheduleResultToTarget(job, scheduledForMs, {
+                kind: "success",
+                responseText: report.responseText,
+            });
             return report;
         }
         catch (error) {
             const message = formatError(error);
             this.store.finishCronRun(runId, "failed", Date.now(), null, message);
+            await this.appendScheduleResultToTarget(job, scheduledForMs, {
+                kind: "failure",
+                errorMessage: message,
+            });
             throw error;
         }
     }
+    async appendScheduleResultToTarget(job, scheduledForMs, outcome) {
+        const replyTarget = toReplyTarget(job);
+        if (replyTarget === null) {
+            return;
+        }
+        try {
+            await this.executor.appendContextToConversation({
+                conversationKey: this.resolveConversationKeyForTarget(replyTarget),
+                replyTarget,
+                body: formatScheduleContextNote(job, scheduledForMs, outcome),
+                recordedAtMs: Date.now(),
+            });
+        }
+        catch (error) {
+            this.logger.log("warn", `failed to append schedule result to ${replyTarget.channel}:${replyTarget.target}: ${formatError(error)}`);
+        }
+    }
     requireJob(id) {
         const job = this.store.getCronJob(id);
         if (job === null) {
-            throw new Error(`unknown cron job: ${id}`);
+            throw new Error(`unknown schedule job: ${id}`);
         }
         return job;
     }
@@ -186,7 +254,9 @@ function normalizeUpsertInput(input) {
     }
     return {
         id,
+        kind: "cron",
         schedule,
+        runAtMs: null,
         prompt,
         enabled: input.enabled,
         deliveryChannel,
@@ -196,8 +266,57 @@ function normalizeUpsertInput(input) {
         recordedAtMs: 0,
     };
 }
+function normalizeOnceInput(input) {
+    const id = normalizeId(input.id);
+    const prompt = normalizeRequiredField(input.prompt, "schedule prompt");
+    const deliveryChannel = normalizeOptionalField(input.deliveryChannel);
+    const deliveryTarget = normalizeOptionalField(input.deliveryTarget);
+    const deliveryTopic = normalizeOptionalField(input.deliveryTopic);
+    if ((deliveryChannel === null) !== (deliveryTarget === null)) {
+        throw new Error("schedule delivery_channel and delivery_target must be provided together");
+    }
+    if (deliveryChannel === null && deliveryTopic !== null) {
+        throw new Error("schedule delivery_topic requires delivery_channel and delivery_target");
+    }
+    if (deliveryChannel !== null && deliveryChannel !== "telegram") {
+        throw new Error(`unsupported schedule delivery channel: ${deliveryChannel}`);
+    }
+    const runAtMs = resolveOnceRunAt(input);
+    return {
+        id,
+        kind: "once",
+        schedule: null,
+        runAtMs,
+        prompt,
+        enabled: true,
+        deliveryChannel,
+        deliveryTarget,
+        deliveryTopic,
+        nextRunAtMs: runAtMs,
+        recordedAtMs: 0,
+    };
+}
+function resolveOnceRunAt(input) {
+    if (input.delaySeconds === null && input.runAtMs === null) {
+        throw new Error("schedule_once requires delay_seconds or run_at_ms");
+    }
+    if (input.delaySeconds !== null && input.runAtMs !== null) {
+        throw new Error("schedule_once accepts only one of delay_seconds or run_at_ms");
+    }
+    if (input.runAtMs !== null) {
+        if (!Number.isSafeInteger(input.runAtMs) || input.runAtMs < 0) {
+            throw new Error("schedule run_at_ms must be a non-negative integer");
+        }
+        return input.runAtMs;
+    }
+    const delaySeconds = input.delaySeconds ?? 0;
+    if (!Number.isSafeInteger(delaySeconds) || delaySeconds < 0) {
+        throw new Error("schedule delay_seconds must be a non-negative integer");
+    }
+    return Date.now() + delaySeconds * 1_000;
+}
 function normalizeId(id) {
-    return normalizeRequiredField(id, "cron id");
+    return normalizeRequiredField(id, "schedule id");
 }
 function normalizeRequiredField(value, field) {
     const trimmed = value.trim();
@@ -216,7 +335,7 @@ function normalizeOptionalField(value) {
 function toBindingCronJobSpec(job) {
     return {
         id: job.id,
-        schedule: job.schedule,
+        schedule: normalizeRequiredField(job.schedule ?? "", "cron schedule"),
         prompt: job.prompt,
         deliveryChannel: job.deliveryChannel,
         deliveryTarget: job.deliveryTarget,
@@ -235,3 +354,49 @@ function sleep(durationMs) {
         setTimeout(resolve, durationMs);
     });
 }
+function clampStatusLimit(limit) {
+    if (!Number.isSafeInteger(limit) || limit <= 0) {
+        throw new Error("schedule_status limit must be a positive integer");
+    }
+    return Math.min(limit, MAX_STATUS_RUNS);
+}
+function deriveJobState(job, latestRun) {
+    if (latestRun?.status === "running") {
+        return "running";
+    }
+    if (job.enabled) {
+        return "scheduled";
+    }
+    if (latestRun !== null) {
+        return latestRun.status;
+    }
+    return "canceled";
+}
+function isTerminalJob(job) {
+    return !job.enabled;
+}
+function toReplyTarget(job) {
+    if (job.deliveryChannel === null || job.deliveryTarget === null) {
+        return null;
+    }
+    return {
+        channel: job.deliveryChannel,
+        target: job.deliveryTarget,
+        topic: job.deliveryTopic,
+    };
+}
+function conversationKeyForJob(job) {
+    return job.kind === "cron" ? `cron:${job.id}` : `once:${job.id}`;
+}
+function formatScheduleContextNote(job, scheduledForMs, outcome) {
+    const header = [
+        "[Gateway schedule result]",
+        `job_id=${job.id}`,
+        `job_kind=${job.kind}`,
+        `scheduled_for_ms=${scheduledForMs}`,
+    ];
+    if (outcome.kind === "success") {
+        return [...header, "status=succeeded", "", outcome.responseText].join("\n");
+    }
+    return [...header, "status=failed", "", outcome.errorMessage].join("\n");
+}

package/dist/delivery/text.js

@@ -114,7 +114,7 @@ class ProgressiveTextDeliverySession {
         this.telegramSupport.startTyping(this.target);
     }
     async preview(text) {
-        if (this.previewFailed || this.closed) {
+        if (this.previewFailed || this.closed || text.trim().length === 0) {
             return;
         }
         const runPreview = async () => {

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

@@ -1,11 +1,13 @@
+import { mkdir } from "node:fs/promises";
 import { loadGatewayConfig } from "./config/gateway";
 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";
@@ -13,8 +15,11 @@ import { createQuestionClient } from "./questions/client";
 import { GatewayQuestionRuntime } from "./questions/runtime";
 import { GatewayExecutor } from "./runtime/executor";
 import { GatewayMailboxRuntime } from "./runtime/mailbox";
+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";
@@ -28,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;
@@ -36,6 +42,7 @@ export class GatewayPluginRuntime {
         this.files = files;
         this.channelSessions = channelSessions;
         this.sessionContext = sessionContext;
+        this.systemPrompts = systemPrompts;
     }
     status() {
         const rustStatus = this.contract.gatewayStatus();
@@ -56,41 +63,46 @@ export class GatewayPluginRuntime {
 }
 export async function createGatewayRuntime(module, input) {
     const config = await loadGatewayConfig();
-    const logger = new ConsoleLoggerHost();
-    if (config.hasLegacyGatewayTimezone) {
-        const suffix = config.legacyGatewayTimezone === null ? "" : ` (${config.legacyGatewayTimezone})`;
-        logger.log("warn", `gateway.timezone${suffix} is ignored; use cron.timezone instead`);
-    }
-    const effectiveCronTimeZone = resolveEffectiveCronTimeZone(module, config);
-    const store = await openSqliteStore(config.stateDbPath);
-    const sessionContext = new GatewaySessionContext(store);
-    const telegramClient = config.telegram.enabled ? new TelegramBotClient(config.telegram.botToken) : null;
-    const telegramMediaStore = config.telegram.enabled && telegramClient !== null
-        ? new TelegramInboundMediaStore(telegramClient, config.mediaRootPath)
-        : null;
-    const mailboxRouter = new GatewayMailboxRouter(config.mailbox.routes);
-    const opencodeEvents = new OpencodeEventHub();
-    const opencode = new OpencodeSdkAdapter(input.client, input.directory);
-    const questionClient = createQuestionClient(input.client, input.serverUrl, input.directory);
-    const transport = new GatewayTransportHost(telegramClient, store);
-    const files = new ChannelFileSender(telegramClient);
-    const channelSessions = new ChannelSessionSwitcher(store, sessionContext, mailboxRouter, module, opencode, config.telegram.enabled);
-    const questions = new GatewayQuestionRuntime(questionClient, input.directory, store, sessionContext, transport, telegramClient, logger);
-    const progressiveSupport = new TelegramProgressiveSupport(telegramClient, store, logger);
-    const delivery = new GatewayTextDelivery(transport, store, progressiveSupport);
-    const executor = new GatewayExecutor(module, store, opencode, opencodeEvents, delivery, logger);
-    const mailbox = new GatewayMailboxRuntime(executor, store, logger, config.mailbox, questions);
-    const cron = new GatewayCronRuntime(executor, module, store, logger, config.cron, effectiveCronTimeZone);
-    const eventStream = new OpencodeEventStream(input.client, input.directory, opencodeEvents, [questions], logger);
-    const telegramPolling = config.telegram.enabled && telegramClient !== null && telegramMediaStore !== null
-        ? new TelegramPollingService(telegramClient, mailbox, store, logger, config.telegram, mailboxRouter, telegramMediaStore, questions)
-        : null;
-    const telegram = new GatewayTelegramRuntime(telegramClient, delivery, store, logger, config.telegram, telegramPolling, eventStream);
-    eventStream.start();
-    cron.start();
-    mailbox.start();
-    telegram.start();
-    return new GatewayPluginRuntime(module, executor, cron, telegram, files, channelSessions, sessionContext);
+    return await getOrCreateRuntimeSingleton(config.configPath, async () => {
+        await mkdir(config.workspaceDirPath, { recursive: true });
+        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`);
+        }
+        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)
+            : null;
+        const mailboxRouter = new GatewayMailboxRouter(config.mailbox.routes);
+        const opencodeEvents = new OpencodeEventHub();
+        const opencode = new OpencodeSdkAdapter(input.client, config.workspaceDirPath);
+        const questionClient = createQuestionClient(input.client, input.serverUrl, config.workspaceDirPath);
+        const transport = new GatewayTransportHost(telegramClient, store);
+        const files = new ChannelFileSender(telegramClient);
+        const channelSessions = new ChannelSessionSwitcher(store, sessionContext, mailboxRouter, module, opencode, config.telegram.enabled);
+        const questions = new GatewayQuestionRuntime(questionClient, config.workspaceDirPath, store, sessionContext, transport, telegramClient, logger);
+        const progressiveSupport = new TelegramProgressiveSupport(telegramClient, store, logger);
+        const delivery = new GatewayTextDelivery(transport, store, progressiveSupport);
+        const executor = new GatewayExecutor(module, store, opencode, opencodeEvents, delivery, logger);
+        const mailbox = new GatewayMailboxRuntime(executor, store, logger, config.mailbox, questions);
+        const cron = new GatewayCronRuntime(executor, module, store, logger, config.cron, effectiveCronTimeZone, (target) => resolveConversationKeyForTarget(target, mailboxRouter, module));
+        const eventStream = new OpencodeEventStream(input.client, config.workspaceDirPath, opencodeEvents, [questions], logger);
+        const telegramPolling = config.telegram.enabled && telegramClient !== null && telegramMediaStore !== null
+            ? new TelegramPollingService(telegramClient, mailbox, store, logger, config.telegram, mailboxRouter, telegramMediaStore, questions)
+            : null;
+        const telegram = new GatewayTelegramRuntime(telegramClient, delivery, store, logger, config.telegram, telegramPolling, eventStream);
+        eventStream.start();
+        cron.start();
+        mailbox.start();
+        telegram.start();
+        return new GatewayPluginRuntime(module, executor, cron, telegram, files, channelSessions, sessionContext, systemPrompts);
+    });
 }
 function resolveEffectiveCronTimeZone(module, config) {
     const candidate = config.cron.timezone ?? resolveRuntimeLocalTimeZone();

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

@@ -2,12 +2,14 @@ import { loadGatewayBindingModule } from "./binding";
 import { createGatewayRuntime } from "./gateway";
 import { createChannelNewSessionTool } from "./tools/channel-new-session";
 import { createChannelSendFileTool } from "./tools/channel-send-file";
-import { createCronListTool } from "./tools/cron-list";
-import { createCronRemoveTool } from "./tools/cron-remove";
 import { createCronRunTool } from "./tools/cron-run";
 import { createCronUpsertTool } from "./tools/cron-upsert";
 import { createGatewayDispatchCronTool } from "./tools/gateway-dispatch-cron";
 import { createGatewayStatusTool } from "./tools/gateway-status";
+import { createScheduleCancelTool } from "./tools/schedule-cancel";
+import { createScheduleListTool } from "./tools/schedule-list";
+import { createScheduleOnceTool } from "./tools/schedule-once";
+import { createScheduleStatusTool } from "./tools/schedule-status";
 import { createTelegramSendTestTool } from "./tools/telegram-send-test";
 import { createTelegramStatusTool } from "./tools/telegram-status";
 /**
@@ -18,12 +20,14 @@ export const OpencodeGatewayPlugin = async (input) => {
     const gatewayModule = await loadGatewayBindingModule();
     const runtime = await createGatewayRuntime(gatewayModule, input);
     const tools = {
-        cron_list: createCronListTool(runtime.cron),
-        cron_remove: createCronRemoveTool(runtime.cron),
         cron_run: createCronRunTool(runtime.cron),
-        cron_upsert: createCronUpsertTool(runtime.cron),
+        cron_upsert: createCronUpsertTool(runtime.cron, runtime.sessionContext),
         gateway_status: createGatewayStatusTool(runtime),
         gateway_dispatch_cron: createGatewayDispatchCronTool(runtime.executor),
+        schedule_cancel: createScheduleCancelTool(runtime.cron),
+        schedule_list: createScheduleListTool(runtime.cron),
+        schedule_once: createScheduleOnceTool(runtime.cron, runtime.sessionContext),
+        schedule_status: createScheduleStatusTool(runtime.cron),
     };
     if (runtime.files.hasEnabledChannel()) {
         tools.channel_send_file = createChannelSendFileTool(runtime.files, runtime.sessionContext);
@@ -42,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;
+}