opencode-gateway 0.2.2 → 0.2.4

package/dist/opencode/adapter.js

@@ -1,340 +0,0 @@
-import { basename } from "node:path";
-import { pathToFileURL } from "node:url";
-const SESSION_IDLE_POLL_MS = 250;
-const PROMPT_RESPONSE_TIMEOUT_MS = 90_000;
-export class OpencodeSdkAdapter {
-    client;
-    directory;
-    constructor(client, directory) {
-        this.client = client;
-        this.directory = directory;
-    }
-    async createFreshSession(title) {
-        const session = await this.client.session.create({
-            body: { title },
-            query: { directory: this.directory },
-            responseStyle: "data",
-            throwOnError: true,
-        });
-        return unwrapData(session).id;
-    }
-    async isSessionBusy(sessionId) {
-        const statuses = await this.client.session.status({
-            query: { directory: this.directory },
-            responseStyle: "data",
-            throwOnError: true,
-        });
-        const current = unwrapData(statuses)[sessionId];
-        return current?.type === "busy";
-    }
-    async abortSession(sessionId) {
-        try {
-            await this.client.session.abort({
-                path: { id: sessionId },
-                query: { directory: this.directory },
-                responseStyle: "data",
-                throwOnError: true,
-            });
-        }
-        catch (error) {
-            if (isMissingSessionError(error)) {
-                return;
-            }
-            throw error;
-        }
-    }
-    async execute(command) {
-        try {
-            switch (command.kind) {
-                case "lookupSession":
-                    return await this.lookupSession(command.sessionId);
-                case "createSession":
-                    return await this.createSession(command.title);
-                case "waitUntilIdle":
-                    return await this.waitUntilIdle(command.sessionId);
-                case "appendPrompt":
-                    return await this.appendPrompt(command);
-                case "sendPromptAsync":
-                    return await this.sendPromptAsync(command);
-                case "awaitPromptResponse":
-                    return await this.awaitPromptResponse(command);
-                case "readMessage":
-                    return await this.readMessage(command);
-                case "listMessages":
-                    return await this.listMessages(command);
-            }
-        }
-        catch (error) {
-            return toErrorResult(command, error);
-        }
-    }
-    async lookupSession(sessionId) {
-        try {
-            await this.client.session.get({
-                path: { id: sessionId },
-                query: { directory: this.directory },
-                responseStyle: "data",
-                throwOnError: true,
-            });
-            return {
-                kind: "lookupSession",
-                sessionId,
-                found: true,
-            };
-        }
-        catch (error) {
-            if (isMissingSessionError(error)) {
-                return {
-                    kind: "lookupSession",
-                    sessionId,
-                    found: false,
-                };
-            }
-            throw error;
-        }
-    }
-    async createSession(title) {
-        return {
-            kind: "createSession",
-            sessionId: await this.createFreshSession(title),
-        };
-    }
-    async waitUntilIdle(sessionId) {
-        for (;;) {
-            const statuses = await this.client.session.status({
-                query: { directory: this.directory },
-                responseStyle: "data",
-                throwOnError: true,
-            });
-            const current = unwrapData(statuses)[sessionId];
-            if (!current || current.type === "idle") {
-                return {
-                    kind: "waitUntilIdle",
-                    sessionId,
-                };
-            }
-            await Bun.sleep(SESSION_IDLE_POLL_MS);
-        }
-    }
-    async appendPrompt(command) {
-        await this.client.session.prompt({
-            path: { id: command.sessionId },
-            query: { directory: this.directory },
-            body: {
-                messageID: command.messageId,
-                noReply: true,
-                parts: command.parts.map(toSessionPromptPart),
-            },
-            responseStyle: "data",
-            throwOnError: true,
-        });
-        return {
-            kind: "appendPrompt",
-            sessionId: command.sessionId,
-        };
-    }
-    async sendPromptAsync(command) {
-        await this.client.session.promptAsync({
-            path: { id: command.sessionId },
-            query: { directory: this.directory },
-            body: {
-                messageID: command.messageId,
-                parts: command.parts.map(toSessionPromptPart),
-            },
-            throwOnError: true,
-        });
-        return {
-            kind: "sendPromptAsync",
-            sessionId: command.sessionId,
-        };
-    }
-    async awaitPromptResponse(command) {
-        const deadline = Date.now() + PROMPT_RESPONSE_TIMEOUT_MS;
-        let stableCandidateKey = null;
-        for (;;) {
-            const messages = await this.client.session.messages({
-                path: { id: command.sessionId },
-                query: {
-                    directory: this.directory,
-                    limit: 64,
-                },
-                responseStyle: "data",
-                throwOnError: true,
-            });
-            const response = selectAssistantResponse(unwrapData(messages), command.messageId);
-            if (response !== null) {
-                const candidateKey = createAssistantCandidateKey(response);
-                if (stableCandidateKey === candidateKey) {
-                    return {
-                        kind: "awaitPromptResponse",
-                        sessionId: command.sessionId,
-                        messageId: response.info.id,
-                        parts: response.parts.flatMap(toBindingMessagePart),
-                    };
-                }
-                stableCandidateKey = candidateKey;
-            }
-            else {
-                stableCandidateKey = null;
-            }
-            if (Date.now() >= deadline) {
-                throw new Error(`assistant message for prompt ${command.messageId} is unavailable after prompt completion`);
-            }
-            await Bun.sleep(SESSION_IDLE_POLL_MS);
-        }
-    }
-    async readMessage(command) {
-        const message = await this.client.session.message({
-            path: {
-                id: command.sessionId,
-                messageID: command.messageId,
-            },
-            query: { directory: this.directory },
-            responseStyle: "data",
-            throwOnError: true,
-        });
-        return {
-            kind: "readMessage",
-            sessionId: command.sessionId,
-            messageId: command.messageId,
-            parts: unwrapData(message).parts.flatMap(toBindingMessagePart),
-        };
-    }
-    async listMessages(command) {
-        const messages = await this.client.session.messages({
-            path: { id: command.sessionId },
-            query: {
-                directory: this.directory,
-                limit: 32,
-            },
-            responseStyle: "data",
-            throwOnError: true,
-        });
-        return {
-            kind: "listMessages",
-            sessionId: command.sessionId,
-            messages: unwrapData(messages).flatMap(toBindingMessage),
-        };
-    }
-}
-function unwrapData(value) {
-    return typeof value === "object" && value !== null && "data" in value ? value.data : value;
-}
-function toSessionPromptPart(part) {
-    switch (part.kind) {
-        case "text":
-            return {
-                id: part.partId,
-                type: "text",
-                text: part.text,
-            };
-        case "file":
-            return {
-                id: part.partId,
-                type: "file",
-                mime: part.mimeType,
-                url: pathToFileURL(part.localPath).href,
-                filename: part.fileName ?? basename(part.localPath),
-            };
-    }
-}
-function selectAssistantResponse(messages, userMessageId) {
-    const assistantChildren = messages.filter(isAssistantChildMessage(userMessageId));
-    for (let index = assistantChildren.length - 1; index >= 0; index -= 1) {
-        const candidate = assistantChildren[index];
-        if (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) {
-            return candidate;
-        }
-    }
-    return null;
-}
-function createAssistantCandidateKey(message) {
-    return JSON.stringify({
-        messageId: message.info.id,
-        finish: message.info.finish ?? null,
-        hasError: message.info.error !== undefined,
-        parts: message.parts.map((part) => ({
-            id: part.id ?? null,
-            type: part.type,
-            text: typeof part.text === "string" ? part.text : null,
-            ignored: part.ignored === true,
-        })),
-    });
-}
-function isAssistantChildMessage(userMessageId) {
-    return (message) => message.info?.role === "assistant" && message.info.parentID === userMessageId;
-}
-function toBindingMessagePart(part) {
-    if (typeof part.id !== "string" || typeof part.messageID !== "string" || part.type.length === 0) {
-        return [];
-    }
-    return [
-        {
-            messageId: part.messageID,
-            partId: part.id,
-            type: part.type,
-            text: typeof part.text === "string" ? part.text : null,
-            ignored: part.ignored === true,
-        },
-    ];
-}
-function hasVisibleText(message) {
-    return message.parts.some((part) => part.type === "text" &&
-        part.ignored !== true &&
-        typeof part.text === "string" &&
-        part.text.trim().length > 0);
-}
-function toBindingMessage(message) {
-    if (typeof message.info?.id !== "string" ||
-        typeof message.info.role !== "string" ||
-        message.info.role.length === 0) {
-        return [];
-    }
-    return [
-        {
-            messageId: message.info.id,
-            role: message.info.role,
-            parentId: typeof message.info.parentID === "string" ? message.info.parentID : null,
-            parts: message.parts.flatMap(toBindingMessagePart),
-        },
-    ];
-}
-function toErrorResult(command, error) {
-    return {
-        kind: "error",
-        commandKind: command.kind,
-        sessionId: "sessionId" in command ? command.sessionId : null,
-        code: isMissingSessionError(error) ? "missingSession" : "unknown",
-        message: extractErrorMessage(error),
-    };
-}
-function isMissingSessionError(error) {
-    if (typeof error !== "object" || error === null) {
-        return false;
-    }
-    const name = "name" in error ? error.name : undefined;
-    const message = "data" in error ? extractDataMessage(error.data) : null;
-    return name === "NotFoundError" && message?.includes("Session not found:") === true;
-}
-function extractDataMessage(value) {
-    if (typeof value !== "object" || value === null) {
-        return null;
-    }
-    const message = value.message;
-    return typeof message === "string" ? message : null;
-}
-function extractErrorMessage(error) {
-    if (error instanceof Error && error.message.length > 0) {
-        return error.message;
-    }
-    if (typeof error === "string" && error.length > 0) {
-        return error;
-    }
-    return "OpenCode command failed";
-}

package/dist/opencode/driver-hub.js

@@ -1,82 +0,0 @@
-import { normalizeExecutionObservation } from "./event-normalize";
-export class OpencodeEventHub {
-    activeDrivers = new Map();
-    nextDriverId = 0;
-    registerDriver(sessionId, driver, onPreview) {
-        const driverId = this.nextDriverId++;
-        attachDriver(this.activeDrivers, sessionId, driverId, {
-            driver,
-            onPreview,
-        });
-        return {
-            dispose: () => {
-                detachDriver(this.activeDrivers, sessionId, driverId);
-            },
-            updateSession: (nextSessionId) => {
-                if (nextSessionId === sessionId) {
-                    return;
-                }
-                const current = this.activeDrivers.get(sessionId)?.get(driverId);
-                if (!current) {
-                    return;
-                }
-                detachDriver(this.activeDrivers, sessionId, driverId);
-                attachDriver(this.activeDrivers, nextSessionId, driverId, current);
-                sessionId = nextSessionId;
-            },
-        };
-    }
-    handleEvent(event) {
-        const observation = normalizeExecutionObservation(event);
-        if (observation === null) {
-            return;
-        }
-        if ("sessionId" in observation) {
-            this.dispatchToSession(observation.sessionId, observation);
-            return;
-        }
-        for (const drivers of this.activeDrivers.values()) {
-            for (const driver of drivers.values()) {
-                this.publishDirective(driver, driver.driver.observeEvent(observation, monotonicNowMs()));
-            }
-        }
-    }
-    dispatchToSession(sessionId, observation) {
-        const drivers = this.activeDrivers.get(sessionId);
-        if (!drivers) {
-            return;
-        }
-        for (const driver of drivers.values()) {
-            this.publishDirective(driver, driver.driver.observeEvent(observation, monotonicNowMs()));
-        }
-    }
-    publishDirective(driver, directive) {
-        if (directive.kind !== "preview" || directive.text === null) {
-            return;
-        }
-        void Promise.resolve(driver.onPreview(directive.text)).catch(() => {
-            // Preview delivery must not break the final response path.
-        });
-    }
-}
-function monotonicNowMs() {
-    return Math.trunc(performance.now());
-}
-function attachDriver(activeDrivers, sessionId, driverId, driver) {
-    let drivers = activeDrivers.get(sessionId);
-    if (!drivers) {
-        drivers = new Map();
-        activeDrivers.set(sessionId, drivers);
-    }
-    drivers.set(driverId, driver);
-}
-function detachDriver(activeDrivers, sessionId, driverId) {
-    const drivers = activeDrivers.get(sessionId);
-    if (!drivers) {
-        return;
-    }
-    drivers.delete(driverId);
-    if (drivers.size === 0) {
-        activeDrivers.delete(sessionId);
-    }
-}

package/dist/opencode/event-normalize.js

@@ -1,48 +0,0 @@
-export function normalizeExecutionObservation(event) {
-    if (isMessageUpdatedEvent(event)) {
-        const info = event.properties.info;
-        return {
-            kind: "messageUpdated",
-            sessionId: info.sessionID,
-            messageId: info.id,
-            role: info.role,
-            parentId: typeof info.parentID === "string" ? info.parentID : null,
-        };
-    }
-    if (isMessagePartUpdatedEvent(event)) {
-        const part = event.properties.part;
-        if (part.type !== "text") {
-            return null;
-        }
-        return {
-            kind: "textPartUpdated",
-            sessionId: part.sessionID,
-            messageId: part.messageID,
-            partId: part.id,
-            text: typeof part.text === "string" ? part.text : null,
-            delta: typeof event.properties.delta === "string" ? event.properties.delta : null,
-            ignored: part.ignored === true,
-        };
-    }
-    if (isMessagePartDeltaEvent(event)) {
-        if (event.properties.field !== "text" || event.properties.delta.length === 0) {
-            return null;
-        }
-        return {
-            kind: "textPartDelta",
-            messageId: event.properties.messageID,
-            partId: event.properties.partID,
-            delta: event.properties.delta,
-        };
-    }
-    return null;
-}
-function isMessageUpdatedEvent(event) {
-    return event.type === "message.updated" && typeof event.properties === "object" && event.properties !== null;
-}
-function isMessagePartUpdatedEvent(event) {
-    return event.type === "message.part.updated" && typeof event.properties === "object" && event.properties !== null;
-}
-function isMessagePartDeltaEvent(event) {
-    return event.type === "message.part.delta" && typeof event.properties === "object" && event.properties !== null;
-}

package/dist/opencode/event-stream.js

@@ -1,65 +0,0 @@
-import { formatError } from "../utils/error";
-const RECONNECT_DELAY_MS = 1_000;
-export class OpencodeEventStream {
-    client;
-    directory;
-    hub;
-    consumers;
-    logger;
-    running = false;
-    connected = false;
-    lastError = null;
-    constructor(client, directory, hub, consumers, logger) {
-        this.client = client;
-        this.directory = directory;
-        this.hub = hub;
-        this.consumers = consumers;
-        this.logger = logger;
-    }
-    isConnected() {
-        return this.connected;
-    }
-    lastStreamError() {
-        return this.lastError;
-    }
-    start() {
-        if (this.running) {
-            return;
-        }
-        this.running = true;
-        void this.runLoop();
-    }
-    stop() {
-        this.running = false;
-    }
-    async runLoop() {
-        while (this.running) {
-            try {
-                const events = await this.client.event.subscribe({
-                    query: { directory: this.directory },
-                    onSseError: (error) => {
-                        this.connected = false;
-                        this.lastError = formatError(error);
-                    },
-                });
-                this.connected = true;
-                this.lastError = null;
-                for await (const event of events.stream) {
-                    const runtimeEvent = event;
-                    this.hub.handleEvent(runtimeEvent);
-                    for (const consumer of this.consumers) {
-                        consumer.handleEvent(runtimeEvent);
-                    }
-                }
-            }
-            catch (error) {
-                this.lastError = formatError(error);
-                this.logger.log("warn", `opencode event stream failed: ${this.lastError}`);
-            }
-            finally {
-                this.connected = false;
-            }
-            await Bun.sleep(RECONNECT_DELAY_MS);
-        }
-    }
-}

package/dist/opencode/events.js

@@ -1 +0,0 @@
-export { OpencodeEventHub } from "./driver-hub";

package/dist/questions/client.js

@@ -1,36 +0,0 @@
-import { createOpencodeClient } from "@opencode-ai/sdk/v2/client";
-export function createQuestionClient(client, serverUrl, directory) {
-    const snapshot = readClientConfig(client);
-    return createOpencodeClient({
-        baseUrl: snapshot.baseUrl ?? serverUrl.toString(),
-        directory,
-        headers: stripManagedHeaders(snapshot.headers),
-    });
-}
-function readClientConfig(client) {
-    const configReader = client._client?.getConfig;
-    if (typeof configReader !== "function") {
-        return {};
-    }
-    return configReader() ?? {};
-}
-function stripManagedHeaders(headers) {
-    if (headers === undefined) {
-        return undefined;
-    }
-    const normalized = new Headers(toHeadersInit(headers));
-    normalized.delete("x-opencode-directory");
-    const result = Object.fromEntries(normalized.entries());
-    return Object.keys(result).length === 0 ? undefined : result;
-}
-function toHeadersInit(headers) {
-    if (headers instanceof Headers || Array.isArray(headers)) {
-        return headers;
-    }
-    if (typeof headers === "object" && headers !== null) {
-        return Object.fromEntries(Object.entries(headers)
-            .filter((entry) => typeof entry[1] === "string")
-            .map(([key, value]) => [key, value]));
-    }
-    return {};
-}

package/dist/questions/format.js

@@ -1,36 +0,0 @@
-export function formatPlainTextQuestion(request) {
-    return [
-        "OpenCode needs additional input before it can continue.",
-        "",
-        ...request.questions.flatMap((question, index) => formatQuestionBlock(question, index)),
-        formatReplyInstructions(request.questions),
-    ].join("\n");
-}
-export function formatQuestionReplyError(request, message) {
-    return [message, "", formatReplyInstructions(request.questions)].join("\n");
-}
-function formatQuestionBlock(question, index) {
-    const label = `Question ${index + 1}: ${question.header}`;
-    const options = question.options.length === 0
-        ? []
-        : [
-            "Options:",
-            ...question.options.map((option, optionIndex) => `${optionIndex + 1}. ${option.label} - ${option.description}`),
-        ];
-    return [label, question.question, ...options, ""];
-}
-function formatReplyInstructions(questions) {
-    if (questions.length === 1) {
-        const question = questions[0];
-        const selectionHint = question.multiple
-            ? "Reply with one line. You may send option numbers or labels separated by commas."
-            : "Reply with one line. You may send an option number, an option label, or custom text.";
-        return ["How to reply:", `- ${selectionHint}`, "- Reply /cancel to reject this question."].join("\n");
-    }
-    return [
-        "How to reply:",
-        "- Reply with one non-empty line per question, in order.",
-        "- Each line may use option numbers, option labels, or custom text when allowed.",
-        "- Reply /cancel to reject this question.",
-    ].join("\n");
-}

package/dist/questions/normalize.js

@@ -1,45 +0,0 @@
-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";
-}