opencode-muse 0.0.0-stage → 0.1.0

package/dist/model/language-model.js

@@ -0,0 +1,540 @@
+import { createHash } from "node:crypto";
+import { MspCommandRejectedError, MuseBridgeError, MuseTranscriptDivergedError, MuseUnsupportedInputError, MuseUnsupportedRequestError, MspProtocolError, MspTransportError } from "../errors.js";
+import { MUSE_CONTEXT_HEADERS, readRequestContext } from "./context.js";
+import { classifyMetaRequest, makeCompactionDigest, makeLocalTitle } from "./meta.js";
+import { promptContainsCompactionFingerprint } from "../session/fingerprint.js";
+import { extractTurnInput, validateModelOptions, } from "./prompt.js";
+import { MuseStreamMapper } from "./stream.js";
+const DEFAULT_VIDEO_CHUNK_BYTES = 6 * 1024 * 1024;
+function fingerprint(method, params) {
+    return createHash("sha256").update(JSON.stringify({ method, params })).digest("hex");
+}
+function sameSelection(current, next) {
+    return current !== undefined
+        && current.providerId === next.providerId
+        && current.modelId === next.modelId
+        && (current.profileId ?? null) === next.profileId;
+}
+async function submitCommand(session, method, commandId, params) {
+    const requestParams = { ...params, commandId };
+    const requestFingerprint = fingerprint(method, requestParams);
+    await session.recordPendingCommand?.({ commandId, method, fingerprint: requestFingerprint });
+    try {
+        const result = await session.host.command(method, requestParams);
+        if (method !== "turn/start") {
+            try {
+                await session.clearPendingCommand?.(commandId);
+            }
+            catch {
+                // The command ACK proves its outcome. Keep the conservative pending
+                // fingerprint; the manager clears acknowledged transaction commands at
+                // terminal completion. Never discard a successful model turn because a
+                // registry cleanup write failed after the remote side effect.
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        // A typed command rejection is an explicit refusal. Timeouts and transport
+        // loss leave the pending fingerprint for recovery; never retry with a new ID.
+        if (error instanceof MspCommandRejectedError)
+            await session.clearPendingCommand?.(commandId);
+        throw error;
+    }
+}
+async function mapVideoParts(session, parts, signal, chunkBytes = DEFAULT_VIDEO_CHUNK_BYTES) {
+    const result = [];
+    for (const part of parts) {
+        if (part.type !== "video") {
+            result.push(part);
+            continue;
+        }
+        if (signal?.aborted)
+            throw new DOMException("Muse request aborted before turn start", "AbortError");
+        const bytes = Buffer.from(part.base64Data, "base64");
+        if (bytes.byteLength !== part.totalBytes || bytes.byteLength === 0)
+            throw new MspProtocolError("media/upload");
+        const uploadId = session.host.mintCommandId();
+        const chunkCount = Math.ceil(bytes.byteLength / chunkBytes);
+        for (let chunkIndex = 0; chunkIndex < chunkCount; chunkIndex += 1) {
+            if (signal?.aborted)
+                throw new DOMException("Muse request aborted before turn start", "AbortError");
+            const chunk = bytes.subarray(chunkIndex * chunkBytes, Math.min(bytes.byteLength, (chunkIndex + 1) * chunkBytes));
+            const commandId = session.host.mintCommandId();
+            const receipt = await submitCommand(session, "media/upload", commandId, {
+                sessionId: session.sessionId,
+                uploadId,
+                mediaType: part.mediaType,
+                chunkIndex,
+                chunkCount,
+                totalBytes: bytes.byteLength,
+                chunkBase64: Buffer.from(chunk).toString("base64"),
+            });
+            if (receipt.uploadId !== uploadId)
+                throw new MspProtocolError("media/upload");
+        }
+        result.push({ type: "video", uploadId });
+    }
+    return result;
+}
+function eventTurnId(notification, itemTurnIds) {
+    const params = notification.params ?? {};
+    if (typeof params.turnId === "string")
+        return params.turnId;
+    const item = params.item;
+    if (typeof item?.itemId === "string" && typeof item.turnId === "string")
+        itemTurnIds.set(item.itemId, item.turnId);
+    if (typeof item?.turnId === "string")
+        return item.turnId;
+    if (notification.method === "item/delta" && typeof params.itemId === "string")
+        return itemTurnIds.get(params.itemId);
+    return undefined;
+}
+async function* pageGapNotifications(host, sessionId, gap) {
+    let cursor = gap.after;
+    const requestedCursors = new Set([gap.after]);
+    const eventCursors = new Set();
+    for (let pageNumber = 0; pageNumber < 100; pageNumber += 1) {
+        const requestCursor = cursor;
+        const page = await host.request("view/page", {
+            sessionId,
+            cursor,
+            direction: "forward",
+            limit: 1000,
+        });
+        if (!Array.isArray(page.events))
+            throw new MspProtocolError("view/page");
+        for (const event of page.events) {
+            if (typeof event !== "object" || event === null)
+                throw new MspProtocolError("view/page");
+            const record = event;
+            const params = record.params;
+            if (typeof record.method !== "string" || !params || params.sessionId !== sessionId || typeof params.viewCursor !== "string") {
+                throw new MspProtocolError("view/page");
+            }
+            if (params.viewCursor === gap.next)
+                return;
+            if (eventCursors.has(params.viewCursor))
+                throw new MspProtocolError("view/page");
+            eventCursors.add(params.viewCursor);
+            cursor = params.viewCursor;
+            yield { jsonrpc: "2.0", method: record.method, params };
+        }
+        if (page.nextCursor === null || typeof page.nextCursor !== "string"
+            || page.nextCursor === requestCursor || requestedCursors.has(page.nextCursor)) {
+            throw new MspProtocolError("view/page");
+        }
+        requestedCursors.add(page.nextCursor);
+        cursor = page.nextCursor;
+    }
+    throw new MspProtocolError("view/page");
+}
+export async function runMuseTurn(context, input, options, runtime, transcriptFingerprints) {
+    const session = await runtime.resolveSession(context);
+    let terminalSeen = false;
+    let accepted = false;
+    let abortRequested = options.abortSignal?.aborted ?? false;
+    let cancelPromise;
+    let turnId;
+    let disposition;
+    let subscription;
+    let firstNotification;
+    let subscriptionController;
+    const cancel = () => {
+        if (cancelPromise)
+            return cancelPromise;
+        if (!turnId || !disposition) {
+            abortRequested = true;
+            return Promise.resolve();
+        }
+        const unqueue = disposition === "queued";
+        const method = unqueue ? "turn/unqueue" : "turn/interrupt";
+        const params = unqueue
+            ? { sessionId: session.sessionId, turnId }
+            : { sessionId: session.sessionId, turnId, retract: true };
+        cancelPromise = submitCommand(session, method, session.host.mintCommandId(), params).then(() => { });
+        return cancelPromise;
+    };
+    const onAbort = () => { abortRequested = true; void cancel().catch(() => { }); };
+    options.abortSignal?.addEventListener("abort", onAbort, { once: true });
+    try {
+        if (!sameSelection(session.currentSelection, context.museSelection)) {
+            const model = {
+                providerId: context.museSelection.providerId,
+                modelId: context.museSelection.modelId,
+            };
+            if (context.museSelection.profileId !== null)
+                model.profileId = context.museSelection.profileId;
+            await submitCommand(session, "session/setModel", session.host.mintCommandId(), {
+                sessionId: session.sessionId,
+                model,
+            });
+        }
+        const inputParts = await mapVideoParts(session, input, options.abortSignal, runtime.videoChunkBytes);
+        if (options.abortSignal?.aborted)
+            throw new DOMException("Muse request aborted before turn start", "AbortError");
+        subscriptionController = new AbortController();
+        subscription = session.host.subscribe(session.sessionId, session.replayAfterCursor, subscriptionController.signal)[Symbol.asyncIterator]();
+        firstNotification = subscription.next();
+        const commandId = session.host.mintCommandId();
+        const params = {
+            sessionId: session.sessionId,
+            input: inputParts,
+        };
+        if (context.effort)
+            params.reasoningEffort = context.effort;
+        const ack = await submitCommand(session, "turn/start", commandId, params);
+        if (typeof ack.turnId !== "string" || typeof ack.disposition !== "string") {
+            throw new MspProtocolError("turn/start");
+        }
+        turnId = ack.turnId;
+        disposition = ack.disposition;
+        accepted = true;
+        await session.recordTurnAccepted?.(commandId, turnId);
+        if (abortRequested)
+            await cancel();
+        const events = {
+            [Symbol.asyncIterator]: async function* () {
+                const itemTurnIds = new Map();
+                const seenCursors = new Set();
+                const processNotification = async function* (notification) {
+                    const params = notification.params ?? {};
+                    if (params.sessionId !== session.sessionId)
+                        return;
+                    if (typeof params.viewCursor === "string")
+                        await session.updateCursor?.(params.viewCursor);
+                    const notificationTurnId = eventTurnId(notification, itemTurnIds);
+                    if (notificationTurnId !== turnId)
+                        return;
+                    yield notification;
+                    if (notification.method === "turn/completed" || notification.method === "turn/unqueued" || notification.method === "turn/retracted") {
+                        terminalSeen = true;
+                        const terminal = notification.method === "turn/completed" && typeof params.terminal === "string"
+                            ? params.terminal
+                            : notification.method === "turn/unqueued" ? "unqueued" : "retracted";
+                        await session.recordTurnCompleted?.(turnId, terminal, params.usage);
+                        if (terminal === "completed" && transcriptFingerprints) {
+                            await session.commitTranscriptFingerprints?.(transcriptFingerprints);
+                        }
+                    }
+                };
+                try {
+                    let next = await firstNotification;
+                    while (!next.done) {
+                        const notification = next.value;
+                        const params = notification.params ?? {};
+                        if (notification.method === "view/gap" && params.sessionId === session.sessionId) {
+                            if (typeof params.after !== "string" || typeof params.next !== "string")
+                                throw new MspProtocolError("view/gap");
+                            for await (const replay of pageGapNotifications(session.host, session.sessionId, { after: params.after, next: params.next })) {
+                                const replayCursor = replay.params?.viewCursor;
+                                if (typeof replayCursor === "string" && seenCursors.has(replayCursor))
+                                    continue;
+                                if (typeof replayCursor === "string")
+                                    seenCursors.add(replayCursor);
+                                for await (const output of processNotification(replay))
+                                    yield output;
+                                if (terminalSeen)
+                                    return;
+                            }
+                        }
+                        else {
+                            const viewCursor = params.viewCursor;
+                            if (typeof viewCursor === "string" && seenCursors.has(viewCursor)) {
+                                next = await subscription.next();
+                                continue;
+                            }
+                            if (typeof viewCursor === "string")
+                                seenCursors.add(viewCursor);
+                            for await (const output of processNotification(notification))
+                                yield output;
+                            if (terminalSeen)
+                                return;
+                        }
+                        next = await subscription.next();
+                    }
+                    if (!terminalSeen)
+                        throw new MspTransportError();
+                }
+                finally {
+                    options.abortSignal?.removeEventListener("abort", onAbort);
+                    subscriptionController?.abort();
+                    await subscription?.return?.();
+                    await session.release?.();
+                }
+            },
+        };
+        return { turnId, commandId, disposition, events, cancel };
+    }
+    catch (error) {
+        options.abortSignal?.removeEventListener("abort", onAbort);
+        if (accepted && subscription && firstNotification && turnId) {
+            // The turn was accepted but its local ack could not be durably recorded.
+            // Stop it, then keep draining until the terminal event before releasing
+            // the workspace lease; dropping this subscription would orphan a writer.
+            try {
+                await cancel();
+            }
+            catch { /* continue monitoring even if interrupt admission failed */ }
+            void (async () => {
+                const itemTurnIds = new Map();
+                try {
+                    let next = await firstNotification.catch(() => ({ done: true, value: undefined }));
+                    while (!next.done) {
+                        const notification = next.value;
+                        const params = notification.params ?? {};
+                        if (eventTurnId(notification, itemTurnIds) === turnId) {
+                            if (typeof params.viewCursor === "string") {
+                                await session.updateCursor?.(params.viewCursor).catch(() => { });
+                            }
+                            if (["turn/completed", "turn/unqueued", "turn/retracted"].includes(notification.method)) {
+                                const terminal = notification.method === "turn/completed" && typeof params.terminal === "string"
+                                    ? params.terminal
+                                    : notification.method === "turn/unqueued" ? "unqueued" : "retracted";
+                                await session.recordTurnCompleted?.(turnId, terminal, params.usage).catch(() => { });
+                                if (terminal === "completed" && transcriptFingerprints) {
+                                    await session.commitTranscriptFingerprints?.(transcriptFingerprints).catch(() => { });
+                                }
+                                break;
+                            }
+                        }
+                        next = await subscription.next();
+                    }
+                }
+                catch {
+                    // The host may have died; its manager will see the unreconciled state.
+                }
+                finally {
+                    subscriptionController?.abort();
+                    await subscription?.return?.().catch(() => { });
+                    await session.release?.().catch(() => { });
+                }
+            })();
+        }
+        else if (!accepted) {
+            subscriptionController?.abort();
+            await firstNotification?.catch(() => undefined);
+            await subscription?.return?.();
+            const commandMethod = error?.method;
+            const ambiguousTurnStart = commandMethod === "turn/start" && !(error instanceof MspCommandRejectedError);
+            if (!ambiguousTurnStart)
+                await session.release?.();
+        }
+        throw error;
+    }
+}
+function contextErrorToException(error) {
+    return new MuseBridgeError("MUSE_UNSUPPORTED_REQUEST", `Muse model request context is ${error.code} (${error.field})`, false);
+}
+function inputErrorToException(error) {
+    if (error.code === "transcript-diverged")
+        return new MuseTranscriptDivergedError();
+    return new MuseUnsupportedInputError(error.field ?? error.mediaType ?? error.code);
+}
+function ignoredOptionWarnings(ignoredOptions) {
+    return ignoredOptions.map((feature) => ({
+        type: "unsupported",
+        feature,
+        details: "Muse MSP does not expose this per-turn option; the setting was ignored.",
+    }));
+}
+function resultUsage(usage) {
+    return {
+        inputTokens: usage?.inputTokens,
+        outputTokens: usage?.outputTokens,
+        totalTokens: usage?.totalTokens,
+        reasoningTokens: usage?.reasoningTokens,
+    };
+}
+function requestKindFromHeaders(options) {
+    const headers = options.headers;
+    if (!headers)
+        return undefined;
+    const name = MUSE_CONTEXT_HEADERS.kind.toLowerCase();
+    for (const [key, value] of Object.entries(headers))
+        if (key.toLowerCase() === name)
+            return value;
+    return undefined;
+}
+function classifyCall(options) {
+    return classifyMetaRequest(requestKindFromHeaders(options), options.prompt);
+}
+function localMetaText(kind, options) {
+    return kind === "title"
+        ? makeLocalTitle(options.prompt)
+        : makeCompactionDigest(options.prompt, options.maxOutputTokens);
+}
+function localMetaGenerateResult(kind, text) {
+    return {
+        content: text ? [{ type: "text", text }] : [],
+        finishReason: { unified: "stop", raw: `local-${kind}` },
+        usage: resultUsage(undefined),
+        warnings: [],
+    };
+}
+function localMetaStream(kind, text) {
+    return new ReadableStream({
+        start(controller) {
+            controller.enqueue({ type: "stream-start", warnings: [] });
+            if (text) {
+                controller.enqueue({ type: "text-start", id: `local-${kind}` });
+                controller.enqueue({ type: "text-delta", id: `local-${kind}`, delta: text });
+                controller.enqueue({ type: "text-end", id: `local-${kind}` });
+            }
+            controller.enqueue({
+                type: "finish",
+                finishReason: { unified: "stop", raw: `local-${kind}` },
+                usage: resultUsage(undefined),
+            });
+            controller.close();
+        },
+    });
+}
+export function createMuseLanguageModel(runtime, modelID) {
+    const doPrepare = async (options) => {
+        const requestKind = classifyCall(options);
+        if (requestKind !== "agent")
+            throw new MuseUnsupportedRequestError(requestKind);
+        const context = readRequestContext(options, runtime.selectionIndex);
+        if ("type" in context)
+            throw contextErrorToException(context);
+        if (context.kind !== "primary")
+            throw new MuseUnsupportedRequestError(context.kind);
+        const supportedOptions = validateModelOptions(options);
+        if (!supportedOptions.ok)
+            throw inputErrorToException(supportedOptions.error);
+        const initialExtraction = extractTurnInput(options.prompt, [], [], { signal: options.abortSignal });
+        if (!initialExtraction.ok)
+            throw inputErrorToException(initialExtraction.error);
+        const session = await runtime.resolveSession(context);
+        if (session.contextError) {
+            await session.release?.();
+            throw new MuseUnsupportedRequestError(session.contextError);
+        }
+        const observedCompaction = (session.compactionFingerprints ?? []).some((candidate) => promptContainsCompactionFingerprint(options.prompt, candidate));
+        const extracted = extractTurnInput(options.prompt, observedCompaction ? [] : session.previousTranscriptFingerprints, session.contextAllowlist, { signal: options.abortSignal });
+        if (!extracted.ok) {
+            await session.release?.();
+            throw inputErrorToException(extracted.error);
+        }
+        const execution = await runMuseTurn(context, extracted.parts, options, {
+            ...runtime,
+            resolveSession: async () => session,
+        }, extracted.nextTranscriptFingerprints);
+        return { context, execution, mapper: new MuseStreamMapper(execution.turnId), warnings: ignoredOptionWarnings(supportedOptions.options.ignoredOptions) };
+    };
+    return {
+        specificationVersion: "v3",
+        // OpenCode 2.1.2's proven in-process hook consumes specVersion and flat
+        // usage; keep the official SDK type member as well for type-level V3.
+        specVersion: "v3",
+        provider: "muse",
+        modelId: modelID,
+        supportedUrls: {},
+        async doStream(options) {
+            const requestKind = classifyCall(options);
+            if (requestKind === "title" || requestKind === "compaction") {
+                return { stream: localMetaStream(requestKind, localMetaText(requestKind, options)) };
+            }
+            if (requestKind === "unsupported-generate")
+                throw new MuseUnsupportedRequestError("generate");
+            const prepared = await doPrepare(options);
+            let outputClosed = false;
+            let controllerRef;
+            const closeOutput = () => {
+                if (outputClosed)
+                    return;
+                outputClosed = true;
+                try {
+                    controllerRef?.close();
+                }
+                catch { /* stream was cancelled by OpenCode */ }
+            };
+            const stream = new ReadableStream({
+                start(controller) {
+                    controllerRef = controller;
+                    controller.enqueue({ type: "stream-start", warnings: prepared.warnings });
+                    void (async () => {
+                        try {
+                            for await (const notification of prepared.execution.events) {
+                                const parts = prepared.mapper.accept(notification);
+                                for (const part of parts) {
+                                    if (outputClosed)
+                                        continue;
+                                    if (part.type === "finish") {
+                                        controller.enqueue(part);
+                                        closeOutput();
+                                        continue;
+                                    }
+                                    controller.enqueue(part);
+                                }
+                            }
+                            if (!outputClosed)
+                                closeOutput();
+                        }
+                        catch (error) {
+                            if (outputClosed)
+                                return;
+                            const safeError = error instanceof MuseBridgeError ? error : new MspTransportError();
+                            controller.enqueue({ type: "error", error: safeError });
+                            controller.enqueue({
+                                type: "finish",
+                                finishReason: { unified: "error", raw: undefined },
+                                usage: resultUsage(prepared.mapper.usage),
+                            });
+                            closeOutput();
+                        }
+                    })();
+                },
+                async cancel() {
+                    outputClosed = true;
+                    await prepared.execution.cancel();
+                },
+            });
+            return { stream };
+        },
+        async doGenerate(options) {
+            const requestKind = classifyCall(options);
+            if (requestKind === "title" || requestKind === "compaction") {
+                return localMetaGenerateResult(requestKind, localMetaText(requestKind, options));
+            }
+            if (requestKind === "unsupported-generate")
+                throw new MuseUnsupportedRequestError("generate");
+            const prepared = await doPrepare(options);
+            let terminalError;
+            const iterator = prepared.execution.events[Symbol.asyncIterator]();
+            while (true) {
+                const next = await iterator.next();
+                if (next.done)
+                    break;
+                const parts = prepared.mapper.accept(next.value);
+                if (prepared.mapper.failure)
+                    terminalError = prepared.mapper.failure;
+                const foregroundFinished = parts.some((part) => part.type === "finish"
+                    && part.finishReason?.raw === "foregroundCompleted");
+                if (foregroundFinished) {
+                    void (async () => {
+                        try {
+                            while (!(await iterator.next()).done) {
+                                // Continue monitoring terminal state and release the workspace lease.
+                            }
+                        }
+                        catch {
+                            // The foreground response is already complete; terminal monitor
+                            // failure is recorded by the session manager's durable state.
+                        }
+                    })();
+                    break;
+                }
+            }
+            if (terminalError)
+                throw terminalError;
+            return {
+                content: prepared.mapper.content,
+                finishReason: prepared.mapper.finishReason ?? { unified: "other", raw: undefined },
+                usage: resultUsage(prepared.mapper.usage),
+                warnings: prepared.warnings,
+            };
+        },
+    };
+}

package/dist/model/meta.d.ts

@@ -0,0 +1,16 @@
+import type { LanguageModelV3Prompt } from "@ai-sdk/provider";
+export type MetaRequestClass = "title" | "compaction" | "unsupported-generate" | "agent";
+interface PromptMessageLike {
+    role?: string;
+    content?: unknown;
+}
+/** Prefer the correlated kind; prompt-shape fallback is intentionally narrow. */
+export declare function classifyMetaRequest(kind: string | undefined, prompt: readonly PromptMessageLike[] | LanguageModelV3Prompt): MetaRequestClass;
+/** Local, zero-model-call title from the first user-authored message only. */
+export declare function makeLocalTitle(prompt: readonly PromptMessageLike[] | LanguageModelV3Prompt): string;
+/**
+ * Deterministic local transcript digest. It is bookkeeping, not synthesis:
+ * no tools, system prompts, hidden reasoning, or inferred decisions are added.
+ */
+export declare function makeCompactionDigest(prompt: readonly PromptMessageLike[] | LanguageModelV3Prompt, maxOutputTokens?: number): string;
+export {};