opencode-gateway 0.2.3 → 0.2.5

package/dist/runtime/executor.js

@@ -1,407 +0,0 @@
-import { ConversationCoordinator } from "./conversation-coordinator";
-import { runOpencodeDriver } from "./opencode-runner";
-const SESSION_ABORT_SETTLE_TIMEOUT_MS = 5_000;
-const SESSION_ABORT_POLL_MS = 250;
-const SESSION_RESIDUAL_BUSY_GRACE_POLLS = 3;
-export class GatewayExecutor {
-    module;
-    store;
-    opencode;
-    events;
-    delivery;
-    logger;
-    coordinator;
-    internalPromptSequence = 0;
-    constructor(module, store, opencode, events, delivery, logger, coordinator = new ConversationCoordinator()) {
-        this.module = module;
-        this.store = store;
-        this.opencode = opencode;
-        this.events = events;
-        this.delivery = delivery;
-        this.logger = logger;
-        this.coordinator = coordinator;
-    }
-    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");
-        return await this.coordinator.runExclusive(conversationKey, async () => {
-            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.executePreparedBatch(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.coordinator.runExclusive(prepared.conversationKey, async () => {
-            return await this.executePreparedBatch([
-                {
-                    entry: null,
-                    message: null,
-                    prepared,
-                },
-            ], recordedAtMs);
-        });
-    }
-    async dispatchScheduledJob(input) {
-        const prepared = prepareTextExecution(input.conversationKey, input.prompt, input.replyTarget);
-        const recordedAtMs = Date.now();
-        this.logger.log("info", "dispatching scheduled gateway job");
-        return await this.coordinator.runExclusive(prepared.conversationKey, async () => {
-            this.store.appendJournal(createJournalEntry("cron_dispatch", recordedAtMs, prepared.conversationKey, {
-                id: input.jobId,
-                kind: input.jobKind,
-                promptParts: prepared.promptParts,
-                deliveryChannel: prepared.replyTarget?.channel ?? null,
-                deliveryTarget: prepared.replyTarget?.target ?? null,
-                deliveryTopic: prepared.replyTarget?.topic ?? null,
-            }));
-            return await this.executePreparedBatch([
-                {
-                    entry: null,
-                    message: null,
-                    prepared,
-                },
-            ], recordedAtMs);
-        });
-    }
-    async appendContextToConversation(input) {
-        const conversationKey = normalizeRequiredField(input.conversationKey, "conversation key");
-        const body = normalizeRequiredField(input.body, "context body");
-        await this.coordinator.runExclusive(conversationKey, async () => {
-            const sessionId = await this.ensureConversationSession(conversationKey, input.recordedAtMs, input.replyTarget === null ? [] : [input.replyTarget]);
-            const promptIdentity = this.createInternalPromptIdentity("context", input.recordedAtMs);
-            await this.appendPrompt(sessionId, promptIdentity.messageId, [
-                {
-                    kind: "text",
-                    partId: promptIdentity.partId,
-                    text: body,
-                },
-            ]);
-        });
-    }
-    async executePreparedBatch(entries, recordedAtMs) {
-        const conversationKey = entries[0].prepared.conversationKey;
-        const persistedSessionId = this.store.getSessionBinding(conversationKey);
-        const preparedSessionId = await this.preparePersistedSessionForPrompt(persistedSessionId);
-        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, preparedSessionId, deliverySession, replyTargets);
-        await this.cleanupResidualBusySession(promptResult.sessionId);
-        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 ensureConversationSession(conversationKey, recordedAtMs, replyTargets) {
-        const persistedSessionId = this.store.getSessionBinding(conversationKey);
-        let sessionId = await this.preparePersistedSessionForPrompt(persistedSessionId);
-        let retryMissingSession = true;
-        for (;;) {
-            if (sessionId === null) {
-                sessionId = await this.createSession(conversationKey);
-            }
-            try {
-                await this.waitUntilIdle(sessionId);
-                break;
-            }
-            catch (error) {
-                if (retryMissingSession && error instanceof MissingSessionCommandError) {
-                    retryMissingSession = false;
-                    sessionId = null;
-                    continue;
-                }
-                throw error;
-            }
-        }
-        this.store.putSessionBindingIfUnchanged(conversationKey, persistedSessionId, sessionId, recordedAtMs);
-        this.initializeReplyTargetsIfMissing(sessionId, conversationKey, replyTargets, recordedAtMs);
-        return sessionId;
-    }
-    initializeReplyTargetsIfMissing(sessionId, conversationKey, replyTargets, recordedAtMs) {
-        if (replyTargets.length === 0 || this.store.listSessionReplyTargets(sessionId).length > 0) {
-            return;
-        }
-        this.store.replaceSessionReplyTargets({
-            sessionId,
-            conversationKey,
-            targets: replyTargets,
-            recordedAtMs,
-        });
-    }
-    async preparePersistedSessionForPrompt(sessionId) {
-        if (sessionId === null) {
-            return null;
-        }
-        const found = await this.lookupSession(sessionId);
-        if (!found) {
-            return null;
-        }
-        if (!(await this.opencode.isSessionBusy(sessionId))) {
-            return sessionId;
-        }
-        this.logger.log("warn", `aborting busy gateway session before prompt dispatch: ${sessionId}`);
-        try {
-            await this.abortSessionAndWaitForSettle(sessionId);
-            return sessionId;
-        }
-        catch (error) {
-            this.logger.log("warn", `busy gateway session did not settle and will be replaced: ${sessionId}: ${extractErrorMessage(error)}`);
-            return null;
-        }
-    }
-    async lookupSession(sessionId) {
-        const result = await this.opencode.execute({
-            kind: "lookupSession",
-            sessionId,
-        });
-        const lookup = expectCommandResult(result, "lookupSession");
-        return lookup.found;
-    }
-    async createSession(conversationKey) {
-        const result = await this.opencode.execute({
-            kind: "createSession",
-            title: `Gateway ${conversationKey}`,
-        });
-        return expectCommandResult(result, "createSession").sessionId;
-    }
-    async waitUntilIdle(sessionId) {
-        const result = await this.opencode.execute({
-            kind: "waitUntilIdle",
-            sessionId,
-        });
-        expectCommandResult(result, "waitUntilIdle");
-    }
-    async appendPrompt(sessionId, messageId, parts) {
-        const result = await this.opencode.execute({
-            kind: "appendPrompt",
-            sessionId,
-            messageId,
-            parts,
-        });
-        expectCommandResult(result, "appendPrompt");
-    }
-    async cleanupResidualBusySession(sessionId) {
-        if (await this.waitForSessionToSettle(sessionId, SESSION_RESIDUAL_BUSY_GRACE_POLLS)) {
-            return;
-        }
-        this.logger.log("debug", `aborting residual busy gateway session after prompt completion: ${sessionId}`);
-        try {
-            await this.abortSessionAndWaitForSettle(sessionId);
-        }
-        catch (error) {
-            this.logger.log("warn", `residual busy gateway session did not settle after abort: ${sessionId}: ${extractErrorMessage(error)}`);
-        }
-    }
-    async waitForSessionToSettle(sessionId, extraPolls) {
-        for (let attempt = 0; attempt <= extraPolls; attempt += 1) {
-            if (!(await this.opencode.isSessionBusy(sessionId))) {
-                return true;
-            }
-            if (attempt < extraPolls) {
-                await Bun.sleep(SESSION_ABORT_POLL_MS);
-            }
-        }
-        return false;
-    }
-    async abortSessionAndWaitForSettle(sessionId) {
-        await this.opencode.abortSession(sessionId);
-        const deadline = Date.now() + SESSION_ABORT_SETTLE_TIMEOUT_MS;
-        for (;;) {
-            if (!(await this.opencode.isSessionBusy(sessionId))) {
-                return;
-            }
-            if (Date.now() >= deadline) {
-                throw new Error(`session remained busy after abort for ${SESSION_ABORT_SETTLE_TIMEOUT_MS}ms`);
-            }
-            await Bun.sleep(SESSION_ABORT_POLL_MS);
-        }
-    }
-    createInternalPromptIdentity(prefix, recordedAtMs) {
-        const suffix = `${recordedAtMs}_${this.internalPromptSequence}`;
-        this.internalPromptSequence += 1;
-        const normalizedPrefix = prefix.replaceAll(":", "_");
-        return {
-            messageId: `msg_gateway_${normalizedPrefix}_${suffix}`,
-            partId: `prt_gateway_${normalizedPrefix}_${suffix}_0`,
-        };
-    }
-    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 prepareTextExecution(conversationKey, prompt, replyTarget) {
-    return {
-        conversationKey: normalizeRequiredField(conversationKey, "conversation key"),
-        promptParts: [
-            {
-                kind: "text",
-                text: normalizeRequiredField(prompt, "schedule prompt"),
-            },
-        ],
-        replyTarget,
-    };
-}
-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 extractErrorMessage(error) {
-    if (error instanceof Error && error.message.trim().length > 0) {
-        return error.message;
-    }
-    return String(error);
-}
-function expectCommandResult(result, expectedKind) {
-    if (result.kind === "error") {
-        if (result.code === "missingSession") {
-            throw new MissingSessionCommandError(result.message);
-        }
-        throw new Error(result.message);
-    }
-    if (result.kind !== expectedKind) {
-        throw new Error(`unexpected OpenCode result kind: expected ${expectedKind}, received ${result.kind}`);
-    }
-    return result;
-}
-class MissingSessionCommandError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "MissingSessionCommandError";
-    }
-}
-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.js

@@ -1,112 +0,0 @@
-import { formatError } from "../utils/error";
-import { deleteInboundAttachmentFiles } from "./attachments";
-const RETRY_DELAY_MS = 1_000;
-export class GatewayMailboxRuntime {
-    executor;
-    store;
-    logger;
-    config;
-    questions;
-    activeMailboxes = new Set();
-    scheduledMailboxes = new Map();
-    constructor(executor, store, logger, config, questions) {
-        this.executor = executor;
-        this.store = store;
-        this.logger = logger;
-        this.config = config;
-        this.questions = questions;
-    }
-    start() {
-        for (const mailboxKey of this.store.listPendingMailboxKeys()) {
-            this.scheduleImmediate(mailboxKey);
-        }
-    }
-    async enqueueInboundMessage(message, sourceKind, externalId) {
-        if (await this.questions.tryHandleInboundMessage(message)) {
-            return;
-        }
-        const prepared = this.executor.prepareInboundMessage(message);
-        const recordedAtMs = Date.now();
-        this.store.enqueueMailboxEntry({
-            mailboxKey: prepared.conversationKey,
-            sourceKind,
-            externalId,
-            sender: message.sender,
-            text: message.text,
-            attachments: message.attachments,
-            replyChannel: message.deliveryTarget.channel,
-            replyTarget: message.deliveryTarget.target,
-            replyTopic: message.deliveryTarget.topic,
-            recordedAtMs,
-        });
-        this.store.appendJournal(createJournalEntry("mailbox_enqueue", recordedAtMs, prepared.conversationKey, {
-            sourceKind,
-            externalId,
-            sender: message.sender,
-            text: message.text,
-            attachments: message.attachments,
-            deliveryTarget: message.deliveryTarget,
-        }));
-        this.scheduleAfterEnqueue(prepared.conversationKey);
-    }
-    scheduleAfterEnqueue(mailboxKey) {
-        if (this.activeMailboxes.has(mailboxKey) || this.scheduledMailboxes.has(mailboxKey)) {
-            return;
-        }
-        this.schedule(mailboxKey, this.config.batchReplies ? this.config.batchWindowMs : 0);
-    }
-    scheduleImmediate(mailboxKey) {
-        if (this.activeMailboxes.has(mailboxKey) || this.scheduledMailboxes.has(mailboxKey)) {
-            return;
-        }
-        this.schedule(mailboxKey, 0);
-    }
-    scheduleRetry(mailboxKey) {
-        if (this.activeMailboxes.has(mailboxKey) || this.scheduledMailboxes.has(mailboxKey)) {
-            return;
-        }
-        this.schedule(mailboxKey, RETRY_DELAY_MS);
-    }
-    schedule(mailboxKey, delayMs) {
-        const handle = setTimeout(() => {
-            this.scheduledMailboxes.delete(mailboxKey);
-            void this.processMailbox(mailboxKey);
-        }, delayMs);
-        this.scheduledMailboxes.set(mailboxKey, handle);
-    }
-    async processMailbox(mailboxKey) {
-        if (this.activeMailboxes.has(mailboxKey)) {
-            return;
-        }
-        this.activeMailboxes.add(mailboxKey);
-        try {
-            const entries = this.store.listMailboxEntries(mailboxKey);
-            if (entries.length === 0) {
-                return;
-            }
-            const batch = this.config.batchReplies ? entries : [entries[0]];
-            await this.executor.executeMailboxEntries(batch);
-            this.store.deleteMailboxEntries(batch.map((entry) => entry.id));
-            await deleteInboundAttachmentFiles(batch, this.logger);
-        }
-        catch (error) {
-            this.logger.log("warn", `mailbox flush failed for ${mailboxKey}: ${formatError(error)}`);
-            this.scheduleRetry(mailboxKey);
-            return;
-        }
-        finally {
-            this.activeMailboxes.delete(mailboxKey);
-        }
-        if (this.store.listMailboxEntries(mailboxKey).length > 0) {
-            this.scheduleImmediate(mailboxKey);
-        }
-    }
-}
-function createJournalEntry(kind, recordedAtMs, conversationKey, payload) {
-    return {
-        kind,
-        recordedAtMs,
-        conversationKey,
-        payload,
-    };
-}

package/dist/runtime/opencode-runner.js

@@ -1,79 +0,0 @@
-const DEFAULT_FLUSH_INTERVAL_MS = 400;
-export async function runOpencodeDriver(options) {
-    const driver = new options.module.OpencodeExecutionDriver({
-        conversationKey: options.conversationKey,
-        persistedSessionId: options.persistedSessionId,
-        mode: options.deliverySession?.mode === "progressive" ? "progressive" : "oneshot",
-        flushIntervalMs: DEFAULT_FLUSH_INTERVAL_MS,
-        prompts: options.prompts,
-    });
-    let registration = null;
-    let activeSessionId = null;
-    try {
-        let step = driver.start();
-        for (;;) {
-            if (step.kind === "command") {
-                activeSessionId = await syncSessionContext(activeSessionId, step.command, options.onSessionAvailable);
-                registration = syncDriverRegistration(registration, step.command, driver, options);
-                const result = await options.opencode.execute(step.command);
-                activeSessionId = await syncSessionContext(activeSessionId, result, options.onSessionAvailable);
-                registration = syncDriverRegistration(registration, result, driver, options);
-                step = driver.resume(result);
-                continue;
-            }
-            if (step.kind === "complete") {
-                return {
-                    sessionId: step.sessionId,
-                    responseText: step.responseText,
-                    finalText: step.finalText,
-                };
-            }
-            throw new Error(step.message);
-        }
-    }
-    finally {
-        registration?.dispose();
-        driver.free?.();
-    }
-}
-async function syncSessionContext(currentSessionId, value, onSessionAvailable) {
-    const sessionId = sessionIdFromCommandOrResult(value);
-    if (sessionId === null || sessionId === currentSessionId) {
-        return currentSessionId;
-    }
-    await onSessionAvailable?.(sessionId);
-    return sessionId;
-}
-function syncDriverRegistration(registration, value, driver, options) {
-    const sessionId = sessionIdFromCommandOrResult(value);
-    if (sessionId === null) {
-        return registration;
-    }
-    if (registration !== null) {
-        registration.updateSession(sessionId);
-        return registration;
-    }
-    const deliverySession = options.deliverySession;
-    return options.events.registerDriver(sessionId, driver, async (snapshot) => {
-        if (deliverySession?.mode !== "progressive") {
-            return;
-        }
-        await deliverySession.preview(snapshot);
-    });
-}
-function sessionIdFromCommandOrResult(value) {
-    switch (value.kind) {
-        case "lookupSession":
-        case "waitUntilIdle":
-        case "appendPrompt":
-        case "sendPromptAsync":
-        case "awaitPromptResponse":
-        case "readMessage":
-        case "listMessages":
-            return value.sessionId;
-        case "createSession":
-            return "sessionId" in value ? value.sessionId : null;
-        case "error":
-            return value.sessionId;
-    }
-}

package/dist/runtime/runtime-singleton.js

@@ -1,28 +0,0 @@
-const RUNTIME_CACHE_KEY = Symbol.for("opencode-gateway.runtime-cache");
-export function getOrCreateRuntimeSingleton(key, factory) {
-    const cache = getRuntimeCache();
-    const existing = cache.get(key);
-    if (existing !== undefined) {
-        return existing;
-    }
-    const promise = factory().catch((error) => {
-        if (cache.get(key) === promise) {
-            cache.delete(key);
-        }
-        throw error;
-    });
-    cache.set(key, promise);
-    return promise;
-}
-export function clearRuntimeSingletonForTests(key) {
-    getRuntimeCache().delete(key);
-}
-function getRuntimeCache() {
-    const globalScope = globalThis;
-    let cache = globalScope[RUNTIME_CACHE_KEY];
-    if (cache === undefined) {
-        cache = new Map();
-        globalScope[RUNTIME_CACHE_KEY] = cache;
-    }
-    return cache;
-}

package/dist/session/context.js

@@ -1,23 +0,0 @@
-export class GatewaySessionContext {
-    store;
-    constructor(store) {
-        this.store = store;
-    }
-    replaceReplyTargets(sessionId, conversationKey, targets, recordedAtMs) {
-        this.store.replaceSessionReplyTargets({
-            sessionId,
-            conversationKey,
-            targets,
-            recordedAtMs,
-        });
-    }
-    listReplyTargets(sessionId) {
-        return this.store.listSessionReplyTargets(sessionId);
-    }
-    getDefaultReplyTarget(sessionId) {
-        return this.store.getDefaultSessionReplyTarget(sessionId);
-    }
-    isGatewaySession(sessionId) {
-        return this.store.hasGatewaySession(sessionId);
-    }
-}

package/dist/session/conversation-key.js

@@ -1,3 +0,0 @@
-export function resolveConversationKeyForTarget(target, router, contract) {
-    return router.resolve(target) ?? contract.conversationKeyForDeliveryTarget(target);
-}