opencode-muse 0.0.0-stage → 0.1.1

package/dist/model/stream.js

@@ -0,0 +1,235 @@
+import { MspProtocolError, MuseTurnFailedError, MuseTurnUnqueuedError, } from "../errors.js";
+function isNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function terminalFinishReason(terminal) {
+    if (terminal === "completed")
+        return "stop";
+    if (terminal === "failed")
+        return "error";
+    return "other";
+}
+/** Maps typed Muse view facts to text/reasoning-only V3 events and safe usage. */
+export class MuseStreamMapper {
+    turnId;
+    itemKinds = new Map();
+    itemStarted = new Set();
+    reasoningStarted = new Set();
+    itemDeltaCounts = new Map();
+    itemText = new Map();
+    seenUsageCursors = new Set();
+    textParts = [];
+    terminalUsage;
+    callUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0, reasoningTokens: 0 };
+    hasCallUsage = false;
+    finishWasSent = false;
+    currentFinishReason;
+    terminal;
+    failure;
+    constructor(turnId) {
+        this.turnId = turnId;
+    }
+    get generatedText() {
+        return this.textParts.map((part) => part.text).join("");
+    }
+    get content() {
+        const text = this.generatedText;
+        return text.length > 0 ? [{ type: "text", text }] : [];
+    }
+    get usage() {
+        if (this.terminalUsage)
+            return { ...this.terminalUsage };
+        if (!this.hasCallUsage)
+            return undefined;
+        return { ...this.callUsage };
+    }
+    get finishWasSentToOpenCode() {
+        return this.finishWasSent;
+    }
+    get finishReason() {
+        return this.currentFinishReason;
+    }
+    accept(notification) {
+        const params = notification.params ?? {};
+        switch (notification.method) {
+            case "item/started":
+                return this.itemStartedEvent(params);
+            case "item/delta":
+                return this.itemDeltaEvent(params);
+            case "item/completed":
+                return this.itemCompletedEvent(params);
+            case "session/tokenUsage":
+                this.tokenUsageEvent(params);
+                return [];
+            case "turn/foregroundCompleted":
+                if (params.turnId !== this.turnId || this.finishWasSent)
+                    return [];
+                this.terminal = "foregroundCompleted";
+                return [this.finishPart("stop", "foregroundCompleted")];
+            case "turn/unqueued":
+                if (params.turnId !== this.turnId)
+                    return [];
+                this.terminal = "unqueued";
+                this.failure = new MuseTurnUnqueuedError();
+                return this.finishWasSent ? [] : this.failAndFinish(this.failure, "unqueued");
+            case "turn/retracted":
+                if (params.turnId !== this.turnId)
+                    return [];
+                this.terminal = "retracted";
+                return this.finishWasSent ? [] : [this.finishPart("other", "retracted")];
+            case "turn/completed":
+                return this.turnCompleted(params);
+            default:
+                return [];
+        }
+    }
+    itemStartedEvent(params) {
+        const item = params.item;
+        if (!item || item.turnId !== this.turnId || typeof item.itemId !== "string")
+            return [];
+        this.itemKinds.set(item.itemId, item.kind ?? "unknown");
+        this.itemStarted.add(item.itemId);
+        if (item.kind === "agentMessage")
+            return [{ type: "text-start", id: item.itemId }];
+        return [];
+    }
+    itemDeltaEvent(params) {
+        if (typeof params.itemId !== "string" || typeof params.delta !== "string")
+            return [];
+        const kind = this.itemKinds.get(params.itemId);
+        if (kind === "agentMessage" && (params.field === undefined || params.field === "text")) {
+            this.itemDeltaCounts.set(params.itemId, (this.itemDeltaCounts.get(params.itemId) ?? 0) + 1);
+            this.itemText.set(params.itemId, (this.itemText.get(params.itemId) ?? "") + params.delta);
+            this.textParts.push({ type: "text", text: params.delta });
+            return [{ type: "text-delta", id: params.itemId, delta: params.delta }];
+        }
+        if (kind === "reasoning" && typeof params.field === "string" && params.field.startsWith("summary.")) {
+            this.itemDeltaCounts.set(params.itemId, (this.itemDeltaCounts.get(params.itemId) ?? 0) + 1);
+            const parts = [];
+            if (!this.reasoningStarted.has(params.itemId)) {
+                this.reasoningStarted.add(params.itemId);
+                parts.push({ type: "reasoning-start", id: params.itemId });
+            }
+            parts.push({ type: "reasoning-delta", id: params.itemId, delta: params.delta });
+            return parts;
+        }
+        return [];
+    }
+    itemCompletedEvent(params) {
+        const item = params.item;
+        if (!item || item.turnId !== this.turnId || typeof item.itemId !== "string")
+            return [];
+        this.itemKinds.set(item.itemId, item.kind ?? "unknown");
+        if (item.kind === "reasoning") {
+            const summaries = Array.isArray(item.summary) ? item.summary.filter((value) => typeof value === "string") : [];
+            const hasSummaryDeltas = (this.itemDeltaCounts.get(item.itemId) ?? 0) > 0;
+            if (hasSummaryDeltas)
+                return this.reasoningStarted.has(item.itemId)
+                    ? [{ type: "reasoning-end", id: item.itemId }]
+                    : [];
+            if (summaries.length === 0)
+                return [];
+            return [
+                { type: "reasoning-start", id: item.itemId },
+                ...summaries.map((delta) => ({ type: "reasoning-delta", id: item.itemId, delta })),
+                { type: "reasoning-end", id: item.itemId },
+            ];
+        }
+        if (item.kind !== "agentMessage")
+            return [];
+        const parts = [];
+        if (!this.itemStarted.has(item.itemId)) {
+            this.itemStarted.add(item.itemId);
+            parts.push({ type: "text-start", id: item.itemId });
+        }
+        if (typeof item.text === "string") {
+            const observed = this.itemText.get(item.itemId) ?? "";
+            if (observed.length === 0 && item.text.length > 0) {
+                this.itemText.set(item.itemId, item.text);
+                this.textParts.push({ type: "text", text: item.text });
+                parts.push({ type: "text-delta", id: item.itemId, delta: item.text });
+            }
+            else if (observed.length > 0 && item.text.startsWith(observed)) {
+                const suffix = item.text.slice(observed.length);
+                if (suffix.length > 0) {
+                    this.itemText.set(item.itemId, item.text);
+                    this.textParts.push({ type: "text", text: suffix });
+                    parts.push({ type: "text-delta", id: item.itemId, delta: suffix });
+                }
+            }
+            else if (observed !== item.text) {
+                this.failure = new MspProtocolError("item/completed");
+                return [{ type: "error", error: this.failure }];
+            }
+        }
+        parts.push({ type: "text-end", id: item.itemId });
+        return parts;
+    }
+    tokenUsageEvent(params) {
+        if (params.turnId !== this.turnId || typeof params.viewCursor !== "string")
+            return;
+        if (this.seenUsageCursors.has(params.viewCursor))
+            return;
+        this.seenUsageCursors.add(params.viewCursor);
+        const raw = params.usage;
+        if (!raw)
+            return;
+        const inputTokens = isNumber(params.promptTokens)
+            ? params.promptTokens
+            : isNumber(raw.inputTokens) ? raw.inputTokens : 0;
+        const outputTokens = isNumber(raw.outputTokens) ? raw.outputTokens : 0;
+        const reasoningTokens = isNumber(raw.reasoningTokens) ? raw.reasoningTokens : 0;
+        const totalTokens = isNumber(params.totalTokens) ? params.totalTokens : inputTokens + outputTokens;
+        this.callUsage.inputTokens += inputTokens;
+        this.callUsage.outputTokens += outputTokens;
+        this.callUsage.totalTokens += totalTokens;
+        this.callUsage.reasoningTokens += reasoningTokens;
+        this.hasCallUsage = true;
+    }
+    turnCompleted(params) {
+        if (params.turnId !== this.turnId || typeof params.terminal !== "string")
+            return [];
+        this.terminal = params.terminal;
+        const unified = terminalFinishReason(params.terminal);
+        this.currentFinishReason = { unified, raw: params.terminal };
+        const terminalUsage = params.usage;
+        if (terminalUsage) {
+            const inputTokens = isNumber(terminalUsage.inputTokens) ? terminalUsage.inputTokens : undefined;
+            const outputTokens = isNumber(terminalUsage.outputTokens) ? terminalUsage.outputTokens : undefined;
+            const reasoningTokens = isNumber(terminalUsage.reasoningTokens) ? terminalUsage.reasoningTokens : undefined;
+            this.terminalUsage = {
+                inputTokens,
+                outputTokens,
+                totalTokens: inputTokens === undefined || outputTokens === undefined ? undefined : inputTokens + outputTokens,
+                reasoningTokens,
+            };
+        }
+        if (this.failure)
+            return this.finishWasSent ? [] : this.failAndFinish(this.failure, params.terminal);
+        if (params.terminal === "failed") {
+            const error = params.error;
+            this.failure = new MuseTurnFailedError(typeof error?.kind === "string" ? error.kind : "unknown", typeof error?.retryable === "boolean" ? error.retryable : undefined);
+            return this.finishWasSent ? [] : this.failAndFinish(this.failure, params.terminal);
+        }
+        return this.finishWasSent ? [] : [this.finishPart(terminalFinishReason(params.terminal), params.terminal)];
+    }
+    failAndFinish(error, terminal) {
+        this.finishWasSent = true;
+        const unified = error instanceof MspProtocolError ? "error" : terminalFinishReason(terminal);
+        return [{ type: "error", error }, this.finishPart(unified, terminal)];
+    }
+    finishPart(unified, raw) {
+        this.finishWasSent = true;
+        this.currentFinishReason = { unified, raw };
+        return {
+            type: "finish",
+            finishReason: this.currentFinishReason,
+            usage: this.usage ?? {
+                inputTokens: undefined,
+                outputTokens: undefined,
+                totalTokens: undefined,
+                reasoningTokens: undefined,
+            },
+        };
+    }
+}

package/dist/msp/client.d.ts

@@ -0,0 +1,49 @@
+import { type CommandOptions } from "@muse-code/sdk";
+import { MspProtocolError } from "../errors.js";
+export interface MspNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: Record<string, unknown>;
+    emittedAtMs?: number;
+}
+export interface MspConnectionLike {
+    readonly closed?: Promise<void>;
+    command(method: string, params: Record<string, unknown>, options?: CommandOptions): Promise<Record<string, unknown>>;
+    request(method: string, params?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    mintCommandId(): string;
+    onNotification(handler: (notification: MspNotification) => void): void;
+    onProtocolError?(handler: (error: unknown) => void): void;
+    close(): Promise<void>;
+}
+export interface MspClientOptions {
+    commandTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    closeConnection?: boolean;
+    onFatal?: () => void;
+}
+/** Thin typed facade over the SDK connection; it never logs or retains wire payloads. */
+export declare class MspClient {
+    private readonly connection;
+    private readonly subscribers;
+    private closePromise;
+    private closed;
+    private observedProtocolFailure;
+    private readonly commandTimeoutMs;
+    private readonly requestTimeoutMs;
+    private readonly closeConnection;
+    constructor(connection: MspConnectionLike, options?: MspClientOptions);
+    get isClosed(): boolean;
+    get protocolFailure(): MspProtocolError | undefined;
+    mintCommandId(): string;
+    command<TResult extends object = Record<string, unknown>>(method: string, paramsWithCommandId: Record<string, unknown> & {
+        commandId: string;
+    }, options?: Omit<CommandOptions, "commandId">): Promise<TResult>;
+    request<TResult extends object = Record<string, unknown>>(method: string, params?: Record<string, unknown>): Promise<TResult>;
+    /** Start/resume already attach at their returned head; `after` explicitly requests replay. */
+    subscribe(sessionId: string, after?: string, signal?: AbortSignal): AsyncIterable<MspNotification>;
+    /** Mark subscriptions ended after the owning process wrapper has shut down. */
+    dispose(): void;
+    close(): Promise<void>;
+    private assertOpen;
+    private publish;
+}

package/dist/msp/client.js

@@ -0,0 +1,229 @@
+import { MspError, ProtocolError as SdkProtocolError, } from "@muse-code/sdk";
+import { MspCommandRejectedError, MspCommandTimeoutError, MspHostClosedError, MspProtocolError, MspRequestTimeoutError, MspTransportError, } from "../errors.js";
+class AsyncQueue {
+    values = [];
+    readers = new Set();
+    ended = false;
+    failure;
+    push(value) {
+        if (this.ended)
+            return;
+        const reader = this.readers.values().next().value;
+        if (reader) {
+            this.readers.delete(reader);
+            if (reader.onAbort && reader.signal)
+                reader.signal.removeEventListener("abort", reader.onAbort);
+            reader.resolve({ value, done: false });
+            return;
+        }
+        this.values.push(value);
+    }
+    next(signal) {
+        if (this.failure !== undefined)
+            return Promise.reject(this.failure);
+        const value = this.values.shift();
+        if (value !== undefined)
+            return Promise.resolve({ value, done: false });
+        if (this.ended)
+            return Promise.resolve({ value: undefined, done: true });
+        if (signal?.aborted)
+            return Promise.reject(abortError());
+        return new Promise((resolve, reject) => {
+            const reader = { resolve, reject, signal };
+            if (signal) {
+                reader.onAbort = () => {
+                    this.readers.delete(reader);
+                    reject(abortError());
+                };
+                signal.addEventListener("abort", reader.onAbort, { once: true });
+            }
+            this.readers.add(reader);
+        });
+    }
+    end() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        for (const reader of this.readers) {
+            if (reader.onAbort && reader.signal)
+                reader.signal.removeEventListener("abort", reader.onAbort);
+            reader.resolve({ value: undefined, done: true });
+        }
+        this.readers.clear();
+    }
+    fail(error) {
+        if (this.ended)
+            return;
+        this.failure = error;
+        this.ended = true;
+        for (const reader of this.readers) {
+            if (reader.onAbort && reader.signal)
+                reader.signal.removeEventListener("abort", reader.onAbort);
+            reader.reject(error);
+        }
+        this.readers.clear();
+    }
+}
+function abortError() {
+    return new DOMException("MSP subscription aborted", "AbortError");
+}
+function withTimeout(promise, timeoutMs, timeout) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+        return promise;
+    let timer;
+    return Promise.race([
+        promise,
+        new Promise((_resolve, reject) => {
+            timer = setTimeout(() => reject(timeout()), timeoutMs);
+        }),
+    ]).finally(() => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    });
+}
+function safeRequestFailure(method, error) {
+    if (error instanceof MspError) {
+        return new MspCommandRejectedError(method, error.code, error.kind, error.retryable);
+    }
+    if (error instanceof SdkProtocolError)
+        return new MspProtocolError(method);
+    if (error instanceof Error && error.name === "MspRequestTimeoutError")
+        return error;
+    return new MspTransportError(method);
+}
+/** Thin typed facade over the SDK connection; it never logs or retains wire payloads. */
+export class MspClient {
+    connection;
+    subscribers = new Set();
+    closePromise;
+    closed = false;
+    observedProtocolFailure;
+    commandTimeoutMs;
+    requestTimeoutMs;
+    closeConnection;
+    constructor(connection, options = {}) {
+        this.connection = connection;
+        this.commandTimeoutMs = options.commandTimeoutMs ?? 30_000;
+        this.requestTimeoutMs = options.requestTimeoutMs ?? this.commandTimeoutMs;
+        this.closeConnection = options.closeConnection ?? true;
+        connection.onNotification((notification) => this.publish(notification));
+        connection.onProtocolError?.(() => {
+            if (this.observedProtocolFailure)
+                return;
+            this.observedProtocolFailure = new MspProtocolError();
+            this.closed = true;
+            for (const subscription of this.subscribers)
+                subscription.queue.fail(this.observedProtocolFailure);
+            this.subscribers.clear();
+            options.onFatal?.();
+        });
+        void connection.closed?.then(() => {
+            const unexpected = !this.closed;
+            this.dispose();
+            if (unexpected)
+                options.onFatal?.();
+        }, () => {
+            const unexpected = !this.closed;
+            this.dispose();
+            if (unexpected)
+                options.onFatal?.();
+        });
+    }
+    get isClosed() {
+        return this.closed;
+    }
+    get protocolFailure() {
+        return this.observedProtocolFailure;
+    }
+    mintCommandId() {
+        this.assertOpen();
+        return this.connection.mintCommandId();
+    }
+    command(method, paramsWithCommandId, options = {}) {
+        this.assertOpen();
+        if (typeof paramsWithCommandId.commandId !== "string" || paramsWithCommandId.commandId.length === 0) {
+            return Promise.reject(new MspProtocolError(method));
+        }
+        const request = this.connection.command(method, paramsWithCommandId, {
+            ...options,
+            commandId: paramsWithCommandId.commandId,
+        });
+        return withTimeout(request, this.commandTimeoutMs, () => new MspCommandTimeoutError(method, this.commandTimeoutMs)).catch((error) => {
+            if (error instanceof MspCommandTimeoutError)
+                throw error;
+            throw safeRequestFailure(method, error);
+        });
+    }
+    request(method, params) {
+        this.assertOpen();
+        const request = this.connection.request(method, params);
+        return withTimeout(request, this.requestTimeoutMs, () => new MspRequestTimeoutError(method, this.requestTimeoutMs)).catch((error) => {
+            if (error instanceof MspRequestTimeoutError)
+                throw error;
+            throw safeRequestFailure(method, error);
+        });
+    }
+    /** Start/resume already attach at their returned head; `after` explicitly requests replay. */
+    async *subscribe(sessionId, after, signal) {
+        this.assertOpen();
+        if (!sessionId)
+            throw new MspProtocolError("view/subscribe");
+        if (signal?.aborted)
+            throw abortError();
+        const subscription = { sessionId, queue: new AsyncQueue() };
+        this.subscribers.add(subscription);
+        try {
+            if (after !== undefined)
+                await this.request("view/subscribe", { sessionId, after });
+            while (!signal?.aborted) {
+                const next = await subscription.queue.next(signal);
+                if (next.done)
+                    return;
+                yield next.value;
+            }
+        }
+        finally {
+            this.subscribers.delete(subscription);
+            subscription.queue.end();
+        }
+    }
+    /** Mark subscriptions ended after the owning process wrapper has shut down. */
+    dispose() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const subscription of this.subscribers)
+            subscription.queue.end();
+        this.subscribers.clear();
+    }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.dispose();
+        this.closePromise = this.closeConnection
+            ? this.connection.close().catch(() => { throw new MspTransportError(); })
+            : Promise.resolve();
+        return this.closePromise;
+    }
+    assertOpen() {
+        if (this.observedProtocolFailure)
+            throw this.observedProtocolFailure;
+        if (this.closed)
+            throw new MspHostClosedError();
+    }
+    publish(notification) {
+        if (this.closed)
+            return;
+        const params = notification.params ?? {};
+        const item = params.item;
+        const sessionId = typeof params.sessionId === "string"
+            ? params.sessionId
+            : typeof item?.sessionId === "string" ? item.sessionId : undefined;
+        if (sessionId === undefined)
+            return;
+        for (const subscription of this.subscribers) {
+            if (subscription.sessionId === sessionId)
+                subscription.queue.push(notification);
+        }
+    }
+}

package/dist/msp/host.d.ts

@@ -0,0 +1,55 @@
+import { type MspHandshake, type SpawnMspConnectionOptions } from "@muse-code/sdk";
+import { MspClient, type MspConnectionLike, type MspNotification } from "./client.js";
+export interface MspHostRuntime {
+    connection: MspConnectionLike;
+    initializeResult: Record<string, unknown>;
+    close(): Promise<unknown>;
+    exited?: Promise<unknown>;
+}
+export interface MspHandshakeLike {
+    initialize(params: Parameters<MspHandshake["initialize"]>[0]): Promise<MspHostRuntime>;
+    close(): Promise<unknown>;
+}
+export interface MspHostOptions {
+    museBin?: string;
+    args?: readonly string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    startupTimeoutMs?: number;
+    commandTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    shutdownTimeoutMs?: number;
+    clientInfo?: {
+        name: string;
+        version: string;
+    };
+    capabilities?: Parameters<MspHandshake["initialize"]>[0]["capabilities"];
+}
+export interface MspHostDependencies {
+    createHandshake?: (options: SpawnMspConnectionOptions) => MspHandshakeLike;
+}
+export interface MspHostExit {
+    kind: string;
+    exitCode?: number | null;
+    exitSignal?: string | null;
+    retry?: string;
+}
+/** Owns one muse serve child and one MSP connection for one OpenCode session. */
+export declare class MspHost {
+    private readonly runtime;
+    readonly client: MspClient;
+    readonly initializeResult: Record<string, unknown>;
+    readonly exited: Promise<MspHostExit>;
+    private state;
+    private closePromise;
+    private constructor();
+    static start(options?: MspHostOptions, dependencies?: MspHostDependencies): Promise<MspHost>;
+    get isClosed(): boolean;
+    mintCommandId(): string;
+    command<TResult extends object = Record<string, unknown>>(method: string, paramsWithCommandId: Record<string, unknown> & {
+        commandId: string;
+    }): Promise<TResult>;
+    request<TResult extends object = Record<string, unknown>>(method: string, params?: Record<string, unknown>): Promise<TResult>;
+    subscribe(sessionId: string, after?: string, signal?: AbortSignal): AsyncIterable<MspNotification>;
+    close(): Promise<void>;
+}