opencode-gateway 0.1.0

package/dist/questions/normalize.js

@@ -0,0 +1,45 @@
+export function normalizeQuestionEvent(event) {
+    if (isQuestionAskedEvent(event)) {
+        return {
+            kind: "asked",
+            request: {
+                requestId: event.properties.id,
+                sessionId: event.properties.sessionID,
+                questions: event.properties.questions.map((question) => ({
+                    header: question.header,
+                    question: question.question,
+                    options: question.options.map((option) => ({
+                        label: option.label,
+                        description: option.description,
+                    })),
+                    multiple: question.multiple === true,
+                    custom: question.custom !== false,
+                })),
+            },
+        };
+    }
+    if (isQuestionResolvedEvent(event)) {
+        return {
+            kind: "resolved",
+            requestId: event.properties.requestID,
+        };
+    }
+    return null;
+}
+function isQuestionAskedEvent(event) {
+    if (event.type !== "question.asked" || typeof event.properties !== "object" || event.properties === null) {
+        return false;
+    }
+    const properties = event.properties;
+    return (typeof properties.id === "string" &&
+        typeof properties.sessionID === "string" &&
+        Array.isArray(properties.questions));
+}
+function isQuestionResolvedEvent(event) {
+    if ((event.type !== "question.replied" && event.type !== "question.rejected") ||
+        typeof event.properties !== "object" ||
+        event.properties === null) {
+        return false;
+    }
+    return typeof event.properties.requestID === "string";
+}

package/dist/questions/parser.d.ts

@@ -0,0 +1,11 @@
+import type { GatewayQuestionRequest } from "./types";
+export type ParsedQuestionReply = {
+    kind: "reply";
+    answers: string[][];
+} | {
+    kind: "reject";
+} | {
+    kind: "invalid";
+    message: string;
+};
+export declare function parseQuestionReply(request: GatewayQuestionRequest, text: string | null): ParsedQuestionReply;

package/dist/questions/parser.js

@@ -0,0 +1,96 @@
+const CANCEL_WORDS = new Set(["/cancel", "cancel", "/reject", "reject"]);
+export function parseQuestionReply(request, text) {
+    if (text === null) {
+        return {
+            kind: "invalid",
+            message: "This question currently accepts text replies only.",
+        };
+    }
+    const trimmed = text.trim();
+    if (trimmed.length === 0) {
+        return {
+            kind: "invalid",
+            message: "Reply text must not be empty.",
+        };
+    }
+    if (CANCEL_WORDS.has(trimmed.toLowerCase())) {
+        return {
+            kind: "reject",
+        };
+    }
+    if (request.questions.length === 1) {
+        const parsedAnswer = parseQuestionLine(request.questions[0], trimmed);
+        return parsedAnswer.kind === "invalid"
+            ? parsedAnswer
+            : {
+                kind: "reply",
+                answers: [parsedAnswer.answer],
+            };
+    }
+    const lines = trimmed
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (lines.length !== request.questions.length) {
+        return {
+            kind: "invalid",
+            message: `Expected ${request.questions.length} non-empty lines, but received ${lines.length}.`,
+        };
+    }
+    const answers = [];
+    for (const [index, question] of request.questions.entries()) {
+        const parsedAnswer = parseQuestionLine(question, lines[index]);
+        if (parsedAnswer.kind === "invalid") {
+            return parsedAnswer;
+        }
+        answers.push(parsedAnswer.answer);
+    }
+    return {
+        kind: "reply",
+        answers,
+    };
+}
+function parseQuestionLine(question, line) {
+    const rawSelections = question.multiple
+        ? line
+            .split(/[,\n]/u)
+            .map((token) => token.trim())
+            .filter((token) => token.length > 0)
+        : [line];
+    if (rawSelections.length === 0) {
+        return {
+            kind: "invalid",
+            message: "At least one answer is required.",
+        };
+    }
+    const answers = [];
+    for (const rawSelection of rawSelections) {
+        const option = resolveOptionSelection(question, rawSelection);
+        if (option !== null) {
+            answers.push(option);
+            continue;
+        }
+        if (!question.custom) {
+            return {
+                kind: "invalid",
+                message: `Answer "${rawSelection}" does not match any allowed option.`,
+            };
+        }
+        answers.push(rawSelection);
+    }
+    return {
+        kind: "answer",
+        answer: answers,
+    };
+}
+function resolveOptionSelection(question, selection) {
+    if (question.options.length === 0) {
+        return null;
+    }
+    const numericIndex = Number.parseInt(selection, 10);
+    if (Number.isSafeInteger(numericIndex) && String(numericIndex) === selection && numericIndex >= 1) {
+        return question.options[numericIndex - 1]?.label ?? null;
+    }
+    const normalized = selection.toLowerCase();
+    return question.options.find((option) => option.label.toLowerCase() === normalized)?.label ?? null;
+}

package/dist/questions/runtime.d.ts

@@ -0,0 +1,53 @@
+import type { BindingDeliveryTarget, BindingInboundMessage, BindingLoggerHost } from "../binding";
+import type { OpencodeRuntimeEvent } from "../opencode/events";
+import type { GatewaySessionContext } from "../session/context";
+import type { SqliteStore } from "../store/sqlite";
+import type { TelegramQuestionClientLike } from "../telegram/client";
+import type { TelegramNormalizedCallbackQuery } from "../telegram/normalize";
+type QuestionClientLike = {
+    question: {
+        reply(input: {
+            requestID: string;
+            directory?: string;
+            answers?: string[][];
+        }, options?: {
+            responseStyle?: "data";
+            throwOnError?: boolean;
+        }): Promise<unknown>;
+        reject(input: {
+            requestID: string;
+            directory?: string;
+        }, options?: {
+            responseStyle?: "data";
+            throwOnError?: boolean;
+        }): Promise<unknown>;
+    };
+};
+export declare class GatewayQuestionRuntime {
+    private readonly client;
+    private readonly directory;
+    private readonly store;
+    private readonly sessions;
+    private readonly transport;
+    private readonly telegramClient;
+    private readonly logger;
+    constructor(client: QuestionClientLike, directory: string, store: SqliteStore, sessions: GatewaySessionContext, transport: QuestionTransportLike, telegramClient: TelegramQuestionClientLike | null, logger: BindingLoggerHost);
+    handleEvent(event: OpencodeRuntimeEvent): void;
+    tryHandleInboundMessage(message: BindingInboundMessage): Promise<boolean>;
+    handleTelegramCallbackQuery(query: TelegramNormalizedCallbackQuery): Promise<boolean>;
+    private processEvent;
+    private handleQuestionAsked;
+    private sendQuestion;
+    private sendPlainText;
+    private replyQuestion;
+    private rejectQuestion;
+}
+type QuestionTransportLike = {
+    sendMessage(input: {
+        deliveryTarget: BindingDeliveryTarget;
+        body: string;
+    }): Promise<{
+        errorMessage: string | null;
+    }>;
+};
+export {};

package/dist/questions/runtime.js

@@ -0,0 +1,195 @@
+import { recordTelegramSendFailure, recordTelegramSendSuccess } from "../telegram/state";
+import { formatError } from "../utils/error";
+import { formatPlainTextQuestion, formatQuestionReplyError } from "./format";
+import { normalizeQuestionEvent } from "./normalize";
+import { parseQuestionReply } from "./parser";
+export class GatewayQuestionRuntime {
+    client;
+    directory;
+    store;
+    sessions;
+    transport;
+    telegramClient;
+    logger;
+    constructor(client, directory, store, sessions, transport, telegramClient, logger) {
+        this.client = client;
+        this.directory = directory;
+        this.store = store;
+        this.sessions = sessions;
+        this.transport = transport;
+        this.telegramClient = telegramClient;
+        this.logger = logger;
+    }
+    handleEvent(event) {
+        const normalized = normalizeQuestionEvent(event);
+        if (normalized === null) {
+            return;
+        }
+        void this.processEvent(normalized).catch((error) => {
+            this.logger.log("warn", `question bridge failed: ${formatError(error)}`);
+        });
+    }
+    async tryHandleInboundMessage(message) {
+        const pending = this.store.getPendingQuestionForTarget(message.deliveryTarget);
+        if (pending === null) {
+            return false;
+        }
+        const parsed = parseQuestionReply(pending, message.text);
+        switch (parsed.kind) {
+            case "invalid":
+                await this.sendPlainText(pending.deliveryTarget, formatQuestionReplyError(pending, parsed.message));
+                return true;
+            case "reject":
+                await this.rejectQuestion(pending.requestId);
+                this.store.deletePendingQuestion(pending.requestId);
+                return true;
+            case "reply":
+                await this.replyQuestion(pending.requestId, parsed.answers);
+                this.store.deletePendingQuestion(pending.requestId);
+                return true;
+        }
+    }
+    async handleTelegramCallbackQuery(query) {
+        if (this.telegramClient === null) {
+            return false;
+        }
+        const pending = this.store.getPendingQuestionForTelegramMessage(query.deliveryTarget, query.messageId);
+        if (pending === null) {
+            await this.telegramClient.answerCallbackQuery(query.callbackQueryId, "This question is no longer pending.");
+            return true;
+        }
+        const answer = resolveCallbackAnswer(query.data, pending);
+        if (answer === null) {
+            await this.telegramClient.answerCallbackQuery(query.callbackQueryId, "This button is no longer valid.");
+            return true;
+        }
+        await this.replyQuestion(pending.requestId, [[answer]]);
+        this.store.deletePendingQuestion(pending.requestId);
+        await this.telegramClient.answerCallbackQuery(query.callbackQueryId, `Sent: ${answer}`);
+        return true;
+    }
+    async processEvent(event) {
+        switch (event.kind) {
+            case "asked":
+                await this.handleQuestionAsked(event.request);
+                return;
+            case "resolved":
+                this.store.deletePendingQuestion(event.requestId);
+                return;
+        }
+    }
+    async handleQuestionAsked(request) {
+        const targets = this.sessions.listReplyTargets(request.sessionId);
+        if (targets.length === 0) {
+            this.logger.log("warn", `question ${request.requestId} has no reply target for session ${request.sessionId}`);
+            return;
+        }
+        const deliveredTargets = [];
+        for (const target of targets) {
+            try {
+                deliveredTargets.push(await this.sendQuestion(target, request));
+            }
+            catch (error) {
+                this.logger.log("warn", `question ${request.requestId} delivery failed for ${target.channel}:${target.target}: ${formatError(error)}`);
+            }
+        }
+        if (deliveredTargets.length === 0) {
+            return;
+        }
+        this.store.replacePendingQuestion({
+            requestId: request.requestId,
+            sessionId: request.sessionId,
+            questions: request.questions,
+            targets: deliveredTargets,
+            recordedAtMs: Date.now(),
+        });
+    }
+    async sendQuestion(target, request) {
+        const nativeKeyboard = buildTelegramInlineKeyboard(request);
+        if (target.channel === "telegram" && nativeKeyboard !== null && this.telegramClient !== null) {
+            try {
+                const sent = await this.telegramClient.sendInteractiveMessage(target.target, formatTelegramNativeQuestion(request), target.topic, nativeKeyboard);
+                recordTelegramSendSuccess(this.store, Date.now());
+                return {
+                    deliveryTarget: target,
+                    telegramMessageId: sent.message_id,
+                };
+            }
+            catch (error) {
+                recordTelegramSendFailure(this.store, formatError(error), Date.now());
+                throw error;
+            }
+        }
+        await this.sendPlainText(target, formatPlainTextQuestion(request));
+        return {
+            deliveryTarget: target,
+            telegramMessageId: null,
+        };
+    }
+    async sendPlainText(target, body) {
+        const ack = await this.transport.sendMessage({
+            deliveryTarget: target,
+            body,
+        });
+        if (ack.errorMessage !== null) {
+            throw new Error(ack.errorMessage);
+        }
+    }
+    async replyQuestion(requestId, answers) {
+        await this.client.question.reply({
+            requestID: requestId,
+            directory: this.directory,
+            answers,
+        }, {
+            responseStyle: "data",
+            throwOnError: true,
+        });
+    }
+    async rejectQuestion(requestId) {
+        await this.client.question.reject({
+            requestID: requestId,
+            directory: this.directory,
+        }, {
+            responseStyle: "data",
+            throwOnError: true,
+        });
+    }
+}
+function buildTelegramInlineKeyboard(request) {
+    if (request.questions.length !== 1) {
+        return null;
+    }
+    const [question] = request.questions;
+    if (question.multiple || question.options.length === 0) {
+        return null;
+    }
+    return {
+        inline_keyboard: question.options.map((option, index) => [
+            {
+                text: option.label,
+                callback_data: `q:${index}`,
+            },
+        ]),
+    };
+}
+function formatTelegramNativeQuestion(request) {
+    const [question] = request.questions;
+    return [
+        "OpenCode needs additional input before it can continue.",
+        "",
+        `${question.header}: ${question.question}`,
+        "",
+        "Tap a button below or reply with text.",
+    ].join("\n");
+}
+function resolveCallbackAnswer(data, pending) {
+    if (data === null || !data.startsWith("q:") || pending.questions.length !== 1) {
+        return null;
+    }
+    const indexText = data.slice(2);
+    const index = Number.parseInt(indexText, 10);
+    if (!Number.isSafeInteger(index) || index < 0) {
+        return null;
+    }
+    return pending.questions[0]?.options[index]?.label ?? null;
+}

package/dist/questions/types.d.ts

@@ -0,0 +1,22 @@
+import type { BindingDeliveryTarget } from "../binding";
+export type GatewayQuestionOption = {
+    label: string;
+    description: string;
+};
+export type GatewayQuestionInfo = {
+    header: string;
+    question: string;
+    options: GatewayQuestionOption[];
+    multiple: boolean;
+    custom: boolean;
+};
+export type GatewayQuestionRequest = {
+    requestId: string;
+    sessionId: string;
+    questions: GatewayQuestionInfo[];
+};
+export type PendingQuestionRecord = GatewayQuestionRequest & {
+    deliveryTarget: BindingDeliveryTarget;
+    telegramMessageId: number | null;
+    createdAtMs: number;
+};

package/dist/questions/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/attachments.d.ts

@@ -0,0 +1,3 @@
+import type { BindingLoggerHost } from "../binding";
+import type { MailboxEntryRecord } from "../store/sqlite";
+export declare function deleteInboundAttachmentFiles(entries: Pick<MailboxEntryRecord, "attachments">[], logger: Pick<BindingLoggerHost, "log">): Promise<void>;

package/dist/runtime/attachments.js

@@ -0,0 +1,12 @@
+import { rm } from "node:fs/promises";
+export async function deleteInboundAttachmentFiles(entries, logger) {
+    const paths = new Set(entries.flatMap((entry) => entry.attachments.map((attachment) => attachment.localPath)));
+    await Promise.all([...paths].map(async (path) => {
+        try {
+            await rm(path, { force: true });
+        }
+        catch (error) {
+            logger.log("warn", `failed to remove cached inbound attachment ${path}: ${String(error)}`);
+        }
+    }));
+}

package/dist/runtime/executor.d.ts

@@ -0,0 +1,24 @@
+import type { BindingCronJobSpec, BindingInboundMessage, BindingLoggerHost, BindingPreparedExecution, BindingRuntimeReport, GatewayBindingModule } from "../binding";
+import type { GatewayTextDelivery } from "../delivery/text";
+import type { OpencodeSdkAdapter } from "../opencode/adapter";
+import type { OpencodeEventHub } from "../opencode/events";
+import type { MailboxEntryRecord, SqliteStore } from "../store/sqlite";
+export declare class GatewayExecutor {
+    private readonly module;
+    private readonly store;
+    private readonly opencode;
+    private readonly events;
+    private readonly delivery;
+    private readonly logger;
+    constructor(module: GatewayBindingModule, store: SqliteStore, opencode: GatewayOpencodeRuntimeLike, events: OpencodeEventHub, delivery: GatewayTextDeliveryLike, logger: BindingLoggerHost);
+    prepareInboundMessage(message: BindingInboundMessage): BindingPreparedExecution;
+    handleInboundMessage(message: BindingInboundMessage): Promise<BindingRuntimeReport>;
+    executeMailboxEntries(entries: MailboxEntryRecord[]): Promise<BindingRuntimeReport>;
+    dispatchCronJob(job: BindingCronJobSpec): Promise<BindingRuntimeReport>;
+    private executePreparedEntries;
+    private executeDriver;
+}
+export type GatewayExecutorLike = Pick<GatewayExecutor, "handleInboundMessage" | "dispatchCronJob" | "executeMailboxEntries" | "prepareInboundMessage">;
+type GatewayTextDeliveryLike = Pick<GatewayTextDelivery, "openMany">;
+type GatewayOpencodeRuntimeLike = Pick<OpencodeSdkAdapter, "execute">;
+export {};

package/dist/runtime/executor.js

@@ -0,0 +1,188 @@
+import { runOpencodeDriver } from "./opencode-runner";
+export class GatewayExecutor {
+    module;
+    store;
+    opencode;
+    events;
+    delivery;
+    logger;
+    constructor(module, store, opencode, events, delivery, logger) {
+        this.module = module;
+        this.store = store;
+        this.opencode = opencode;
+        this.events = events;
+        this.delivery = delivery;
+        this.logger = logger;
+    }
+    prepareInboundMessage(message) {
+        return this.module.prepareInboundExecution(message);
+    }
+    async handleInboundMessage(message) {
+        const prepared = this.prepareInboundMessage(message);
+        const syntheticEntry = {
+            id: Date.now(),
+            mailboxKey: prepared.conversationKey,
+            sourceKind: "direct_runtime",
+            externalId: `direct:${Date.now()}`,
+            sender: normalizeRequiredField(message.sender, "message sender"),
+            text: message.text,
+            attachments: withAttachmentOrdinals(message.attachments),
+            replyChannel: message.deliveryTarget.channel,
+            replyTarget: message.deliveryTarget.target,
+            replyTopic: message.deliveryTarget.topic,
+            createdAtMs: Date.now(),
+        };
+        return await this.executeMailboxEntries([syntheticEntry]);
+    }
+    async executeMailboxEntries(entries) {
+        if (entries.length === 0) {
+            throw new Error("mailbox execution requires at least one entry");
+        }
+        const preparedEntries = entries.map((entry) => {
+            const message = mailboxEntryToInboundMessage(entry);
+            return {
+                entry,
+                message,
+                prepared: this.prepareInboundMessage(message),
+            };
+        });
+        const conversationKey = preparedEntries[0].prepared.conversationKey;
+        if (preparedEntries.some((entry) => entry.prepared.conversationKey !== conversationKey)) {
+            throw new Error("mailbox batch contains mixed conversation keys");
+        }
+        const recordedAtMs = Date.now();
+        this.logger.log("info", "handling inbound gateway message");
+        this.store.appendJournal(createJournalEntry("mailbox_flush", recordedAtMs, conversationKey, {
+            entryIds: preparedEntries.map((entry) => entry.entry.id),
+            count: preparedEntries.length,
+        }));
+        for (const entry of preparedEntries) {
+            this.store.appendJournal(createJournalEntry("inbound_message", entry.entry.createdAtMs, conversationKey, {
+                deliveryTarget: entry.prepared.replyTarget,
+                sender: entry.message.sender,
+                text: entry.message.text,
+                attachments: entry.message.attachments,
+            }));
+        }
+        return await this.executePreparedEntries(preparedEntries, recordedAtMs);
+    }
+    async dispatchCronJob(job) {
+        const prepared = this.module.prepareCronExecution(job);
+        const id = normalizeRequiredField(job.id, "cron job id");
+        const schedule = normalizeRequiredField(job.schedule, "cron schedule");
+        const recordedAtMs = Date.now();
+        this.logger.log("info", "dispatching cron gateway job");
+        this.store.appendJournal(createJournalEntry("cron_dispatch", recordedAtMs, prepared.conversationKey, {
+            id,
+            schedule,
+            promptParts: prepared.promptParts,
+            deliveryChannel: prepared.replyTarget?.channel ?? null,
+            deliveryTarget: prepared.replyTarget?.target ?? null,
+            deliveryTopic: prepared.replyTarget?.topic ?? null,
+        }));
+        return await this.executePreparedEntries([
+            {
+                entry: null,
+                message: null,
+                prepared,
+            },
+        ], recordedAtMs);
+    }
+    async executePreparedEntries(entries, recordedAtMs) {
+        const conversationKey = entries[0].prepared.conversationKey;
+        const persistedSessionId = this.store.getSessionBinding(conversationKey);
+        const replyTargets = dedupeReplyTargets(entries.flatMap((entry) => (entry.prepared.replyTarget === null ? [] : [entry.prepared.replyTarget])));
+        const [deliverySession] = replyTargets.length === 0 ? [null] : await this.delivery.openMany(replyTargets, "auto");
+        const promptResult = await this.executeDriver(entries, recordedAtMs, persistedSessionId, deliverySession, replyTargets);
+        this.store.putSessionBindingIfUnchanged(conversationKey, persistedSessionId, promptResult.sessionId, recordedAtMs);
+        let delivered = false;
+        if (deliverySession !== null) {
+            delivered = await deliverySession.finish(promptResult.finalText);
+            if (promptResult.finalText !== null) {
+                this.store.appendJournal(createJournalEntry("delivery", recordedAtMs, conversationKey, {
+                    deliveryTargets: replyTargets,
+                    body: promptResult.finalText,
+                }));
+            }
+        }
+        return {
+            conversationKey,
+            responseText: promptResult.responseText,
+            delivered,
+            recordedAtMs: BigInt(recordedAtMs),
+        };
+    }
+    async executeDriver(entries, recordedAtMs, persistedSessionId, deliverySession, replyTargets) {
+        return await runOpencodeDriver({
+            module: this.module,
+            opencode: this.opencode,
+            events: this.events,
+            conversationKey: entries[0].prepared.conversationKey,
+            persistedSessionId,
+            deliverySession,
+            prompts: entries.map((entry, index) => ({
+                promptKey: createPromptKey(entry, recordedAtMs, index),
+                parts: entry.prepared.promptParts,
+            })),
+            onSessionAvailable: async (sessionId) => {
+                this.store.replaceSessionReplyTargets({
+                    sessionId,
+                    conversationKey: entries[0].prepared.conversationKey,
+                    targets: replyTargets,
+                    recordedAtMs,
+                });
+            },
+        });
+    }
+}
+function createJournalEntry(kind, recordedAtMs, conversationKey, payload) {
+    return {
+        kind,
+        recordedAtMs,
+        conversationKey,
+        payload,
+    };
+}
+function mailboxEntryToInboundMessage(entry) {
+    return {
+        deliveryTarget: {
+            channel: normalizeRequiredField(entry.replyChannel ?? "", "mailbox reply channel"),
+            target: normalizeRequiredField(entry.replyTarget ?? "", "mailbox reply target"),
+            topic: entry.replyTopic,
+        },
+        sender: entry.sender,
+        text: entry.text,
+        attachments: entry.attachments,
+        mailboxKey: entry.mailboxKey,
+    };
+}
+function dedupeReplyTargets(targets) {
+    const seen = new Set();
+    return targets.filter((target) => {
+        const key = `${target.channel}:${target.target}:${target.topic ?? ""}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+function normalizeRequiredField(value, field) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`${field} must not be empty`);
+    }
+    return trimmed;
+}
+function createPromptKey(entry, recordedAtMs, index) {
+    if (entry.entry !== null) {
+        return `mailbox:${entry.entry.id}:${recordedAtMs}`;
+    }
+    return `synthetic:${recordedAtMs}:${index}`;
+}
+function withAttachmentOrdinals(messageAttachments) {
+    return messageAttachments.map((attachment, ordinal) => ({
+        ...attachment,
+        ordinal,
+    }));
+}

package/dist/runtime/mailbox.d.ts

@@ -0,0 +1,25 @@
+import type { BindingInboundMessage, BindingLoggerHost } from "../binding";
+import type { GatewayMailboxConfig } from "../config/gateway";
+import type { GatewayQuestionRuntime } from "../questions/runtime";
+import type { SqliteStore } from "../store/sqlite";
+import type { GatewayExecutor } from "./executor";
+export declare class GatewayMailboxRuntime {
+    private readonly executor;
+    private readonly store;
+    private readonly logger;
+    private readonly config;
+    private readonly questions;
+    private readonly activeMailboxes;
+    private readonly scheduledMailboxes;
+    constructor(executor: GatewayExecutorLike, store: SqliteStore, logger: BindingLoggerHost, config: GatewayMailboxConfig, questions: GatewayQuestionRuntimeLike);
+    start(): void;
+    enqueueInboundMessage(message: BindingInboundMessage, sourceKind: string, externalId: string): Promise<void>;
+    private scheduleAfterEnqueue;
+    private scheduleImmediate;
+    private scheduleRetry;
+    private schedule;
+    private processMailbox;
+}
+type GatewayExecutorLike = Pick<GatewayExecutor, "executeMailboxEntries" | "prepareInboundMessage">;
+type GatewayQuestionRuntimeLike = Pick<GatewayQuestionRuntime, "tryHandleInboundMessage">;
+export {};