opencode-muse 0.0.0-stage → 0.1.0

package/dist/msp/host.js

@@ -0,0 +1,173 @@
+import { MspError, EXPECTED_SCHEMA_FINGERPRINT, MuseHostStartError as SdkHostStartError, spawnMspConnection, } from "@muse-code/sdk";
+import { MspCommandTimeoutError, MspHostClosedError, MspHostStartError, MspInitializeRejectedError, MspSchemaMismatchError, MspStartupTimeoutError, MspTransportError, } from "../errors.js";
+import { MspClient } from "./client.js";
+function defaultHandshake(options) {
+    const handshake = spawnMspConnection(options);
+    return {
+        async initialize(params) {
+            const spawned = await handshake.initialize(params);
+            return {
+                connection: spawned.connection,
+                initializeResult: { ...spawned.initializeResult },
+                exited: spawned.child.exit,
+                close: async () => spawned.close(),
+            };
+        },
+        close: async () => handshake.close(),
+    };
+}
+function sanitizeExit(value) {
+    if (typeof value !== "object" || value === null)
+        return { kind: "unknown" };
+    const record = value;
+    const safe = {
+        kind: typeof record.kind === "string" ? record.kind : "unknown",
+    };
+    if (typeof record.exitCode === "number" || record.exitCode === null)
+        safe.exitCode = record.exitCode;
+    if (typeof record.exitSignal === "string" || record.exitSignal === null)
+        safe.exitSignal = record.exitSignal;
+    if (typeof record.retry === "string")
+        safe.retry = record.retry;
+    // Deliberately omit stderrTail, raw messages, and arbitrary child properties.
+    return safe;
+}
+function withTimeout(promise, timeoutMs) {
+    let timer;
+    return Promise.race([
+        promise,
+        new Promise((_resolve, reject) => {
+            timer = setTimeout(() => reject(new MspStartupTimeoutError(timeoutMs)), timeoutMs);
+        }),
+    ]).finally(() => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    });
+}
+async function closeQuietly(close) {
+    try {
+        await close();
+    }
+    catch {
+        // Shutdown diagnostics may contain arbitrary CLI stderr; do not log them.
+    }
+}
+/** Owns one muse serve child and one MSP connection for one OpenCode session. */
+export class MspHost {
+    runtime;
+    client;
+    initializeResult;
+    exited;
+    state = "open";
+    closePromise;
+    constructor(runtime, options) {
+        this.runtime = runtime;
+        this.initializeResult = runtime.initializeResult;
+        this.client = new MspClient(runtime.connection, {
+            commandTimeoutMs: options.commandTimeoutMs,
+            requestTimeoutMs: options.requestTimeoutMs,
+            closeConnection: false,
+            onFatal: () => {
+                queueMicrotask(() => { void this.close().catch(() => { }); });
+            },
+        });
+        this.exited = runtime.exited
+            ? runtime.exited.then((value) => {
+                this.state = "closed";
+                this.client.dispose();
+                return sanitizeExit(value);
+            }, () => {
+                this.state = "closed";
+                this.client.dispose();
+                return { kind: "unknown" };
+            })
+            : new Promise(() => { });
+    }
+    static async start(options = {}, dependencies = {}) {
+        const spawnOptions = {
+            command: options.museBin ?? "muse",
+            args: options.args,
+            cwd: options.cwd,
+            env: options.env,
+            // No stderr callback: the SDK's bounded diagnostic tail is never forwarded to plugin logs.
+            shutdownTimeoutMs: options.shutdownTimeoutMs ?? 30_000,
+        };
+        let handshake;
+        try {
+            handshake = (dependencies.createHandshake ?? defaultHandshake)(spawnOptions);
+        }
+        catch {
+            throw new MspHostStartError("spawn-failed");
+        }
+        const initializeParams = {
+            clientInfo: options.clientInfo ?? { name: "opencode_muse", version: "0.1.0" },
+            ...(options.capabilities ? { capabilities: options.capabilities } : {}),
+        };
+        const timeoutMs = options.startupTimeoutMs ?? 20_000;
+        const initializing = handshake.initialize(initializeParams);
+        try {
+            const runtime = await withTimeout(initializing, timeoutMs);
+            const schema = runtime.initializeResult.schema;
+            const servedFingerprint = typeof schema?.fingerprint === "string" ? schema.fingerprint : "missing";
+            if (servedFingerprint !== EXPECTED_SCHEMA_FINGERPRINT) {
+                await closeQuietly(runtime.close.bind(runtime));
+                throw new MspSchemaMismatchError(EXPECTED_SCHEMA_FINGERPRINT, servedFingerprint);
+            }
+            return new MspHost(runtime, options);
+        }
+        catch (error) {
+            if (error instanceof MspSchemaMismatchError)
+                throw error;
+            if (error instanceof MspStartupTimeoutError) {
+                void initializing.then((runtime) => closeQuietly(runtime.close.bind(runtime))).catch(() => { });
+                await closeQuietly(handshake.close.bind(handshake));
+                throw error;
+            }
+            await closeQuietly(handshake.close.bind(handshake));
+            if (error instanceof MspError)
+                throw new MspInitializeRejectedError(error.code, error.kind);
+            if (error instanceof SdkHostStartError) {
+                throw new MspHostStartError(error.failure.kind === "spawnFailed" ? "spawn-failed" : "host-exited");
+            }
+            throw new MspHostStartError("unknown");
+        }
+    }
+    get isClosed() {
+        return this.state !== "open";
+    }
+    mintCommandId() {
+        if (this.state !== "open")
+            throw new MspHostClosedError();
+        return this.client.mintCommandId();
+    }
+    command(method, paramsWithCommandId) {
+        if (this.state !== "open")
+            return Promise.reject(new MspHostClosedError());
+        return this.client.command(method, paramsWithCommandId).catch((error) => {
+            if (error instanceof MspCommandTimeoutError)
+                void this.close().catch(() => { });
+            throw error;
+        });
+    }
+    request(method, params) {
+        if (this.state !== "open")
+            return Promise.reject(new MspHostClosedError());
+        return this.client.request(method, params);
+    }
+    subscribe(sessionId, after, signal) {
+        if (this.state !== "open")
+            throw new MspHostClosedError();
+        return this.client.subscribe(sessionId, after, signal);
+    }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.state = "closing";
+        this.client.dispose();
+        this.closePromise = this.runtime.close().then(() => { this.state = "closed"; }, () => {
+            this.state = "closed";
+            throw new MspTransportError();
+        });
+        return this.closePromise;
+    }
+}

package/dist/provider.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "@opencode/plugin";
+import { CatalogCache, type MuseCatalogSnapshot } from "./catalog.js";
+import { MuseSessionManager } from "./session/manager.js";
+export type MuseProviderContext = Pick<Plugin.Context, "provider" | "session" | "aisdk"> & {
+    location: Pick<Plugin.Context["location"], "directory">;
+};
+export interface ProviderPluginDependencies {
+    fetchCatalog?: (directory: string) => Promise<MuseCatalogSnapshot>;
+    createSessionManager?: () => MuseSessionManager;
+}
+export interface MuseProviderRuntime {
+    catalog: CatalogCache;
+    refreshTask: Promise<boolean>;
+    sessions: MuseSessionManager;
+    dispose(): Promise<void>;
+}
+/** Register the disabled offline row first, then refresh only from a live MSP provider catalog. */
+export declare function createProviderPlugin(ctx: MuseProviderContext, moduleUrl: string, dependencies?: ProviderPluginDependencies): Promise<MuseProviderRuntime>;

package/dist/provider.js

@@ -0,0 +1,112 @@
+import { MspHost } from "./msp/host.js";
+import { CatalogCache, MUSE_PROVIDER_ID, } from "./catalog.js";
+import { addRequestContextHeaders } from "./model/context.js";
+import { createMuseLanguageModel } from "./model/language-model.js";
+import { MuseSessionManager } from "./session/manager.js";
+import { SessionRegistry } from "./session/registry.js";
+import { WorkspaceLock } from "./session/workspace-lock.js";
+import { MuseBridgeError } from "./errors.js";
+import { makeCompactionDigest, makeLocalTitle } from "./model/meta.js";
+import { fingerprintCompactionOutput } from "./session/fingerprint.js";
+import { extractAllowedAgentContext } from "./model/agent-context.js";
+function providerInfo(moduleUrl) {
+    return {
+        id: MUSE_PROVIDER_ID,
+        name: "Muse Code",
+        activation: "enabled",
+        package: `aisdk:${moduleUrl}`,
+        settings: {},
+    };
+}
+async function fetchMuseCatalog(directory) {
+    const host = await MspHost.start({
+        args: ["serve", "--provider", "meta", "--disable-shell", "--disable-write"],
+        cwd: directory,
+        startupTimeoutMs: 10_000,
+        requestTimeoutMs: 10_000,
+        shutdownTimeoutMs: 5_000,
+    });
+    try {
+        return await host.request("model/list");
+    }
+    finally {
+        await host.close();
+    }
+}
+/** Register the disabled offline row first, then refresh only from a live MSP provider catalog. */
+export async function createProviderPlugin(ctx, moduleUrl, dependencies = {}) {
+    const catalog = new CatalogCache();
+    const stateDirectory = SessionRegistry.resolveStateDirectory();
+    const sessions = dependencies.createSessionManager?.() ?? new MuseSessionManager({
+        stateDirectory,
+        registry: new SessionRegistry({ stateDirectory }),
+        workspaceLock: new WorkspaceLock({ stateDirectory }),
+    });
+    const registration = await ctx.provider.transform((providers) => {
+        providers.add({ info: providerInfo(moduleUrl), models: catalog.models });
+    });
+    let sessionHookRegistration;
+    let languageHookRegistration;
+    const localMetaRegistrations = [];
+    try {
+        sessionHookRegistration = await ctx.session.hook("model.request", async (request) => {
+            addRequestContextHeaders(request.headers, request, ctx.location.directory);
+        }, { providerID: MUSE_PROVIDER_ID });
+        localMetaRegistrations.push(await ctx.session.hook("context", async (input) => {
+            sessions.setContextForSession(input.sessionID, extractAllowedAgentContext(input.agent, input.system));
+        }, { providerID: MUSE_PROVIDER_ID }));
+        languageHookRegistration = await ctx.aisdk.hook("language", async (input) => {
+            if (input.model.providerID !== MUSE_PROVIDER_ID)
+                return;
+            const selection = catalog.selectionIndex.get(input.model.id);
+            if (!selection) {
+                throw new MuseBridgeError("MUSE_UNSUPPORTED_REQUEST", "Muse model selection is unavailable; refresh the provider catalog", false);
+            }
+            input.language = createMuseLanguageModel({
+                selectionIndex: catalog.selectionIndex,
+                resolveSession: (context) => sessions.resolveSession(context),
+            }, input.model.modelID);
+        }, { providerID: MUSE_PROVIDER_ID });
+        localMetaRegistrations.push(await ctx.session.hook("title", async (input) => {
+            input.result = makeLocalTitle(input.messages);
+        }, { providerID: MUSE_PROVIDER_ID }));
+        localMetaRegistrations.push(await ctx.session.hook("compaction", async (input) => {
+            const summary = makeCompactionDigest(input.messages, typeof input.options.maxOutputTokens === "number" ? input.options.maxOutputTokens : undefined);
+            await sessions.recordCompactionCandidate(input.sessionID, fingerprintCompactionOutput(summary));
+            input.result = { summary };
+        }, { providerID: MUSE_PROVIDER_ID }));
+    }
+    catch (error) {
+        await sessions.close();
+        await registration.dispose();
+        // The session hook may have been registered before the language hook failed.
+        await sessionHookRegistration?.dispose();
+        await Promise.all(localMetaRegistrations.map((hook) => hook.dispose()));
+        throw error;
+    }
+    let disposed = false;
+    const refreshTask = new Promise((resolve) => setTimeout(resolve, 0)).then(() => {
+        if (disposed)
+            return false;
+        return catalog.refresh(() => (dependencies.fetchCatalog ?? fetchMuseCatalog)(ctx.location.directory), async () => {
+            if (!disposed)
+                await ctx.provider.reload();
+        });
+    });
+    return {
+        catalog,
+        refreshTask,
+        sessions,
+        async dispose() {
+            disposed = true;
+            await refreshTask;
+            await Promise.all([
+                registration.dispose(),
+                sessionHookRegistration?.dispose(),
+                languageHookRegistration?.dispose(),
+                ...localMetaRegistrations.map((hook) => hook.dispose()),
+                sessions.close(),
+            ]);
+        },
+    };
+}

package/dist/session/fingerprint.d.ts

@@ -0,0 +1,9 @@
+export interface VisiblePromptMessage {
+    role?: string;
+    content?: unknown;
+}
+export declare function fingerprintTranscript(prompt: readonly VisiblePromptMessage[]): string[];
+export declare function fingerprintCompactionOutput(summary: string): string;
+export declare function promptContainsCompactionFingerprint(prompt: readonly VisiblePromptMessage[], candidateFingerprint: string): boolean;
+export type TranscriptReconciliation = "same" | "compacted" | "diverged";
+export declare function reconcileTranscript(previous: readonly string[], current: readonly string[], pendingCompactionFingerprints: readonly string[], prompt?: readonly VisiblePromptMessage[]): TranscriptReconciliation;

package/dist/session/fingerprint.js

@@ -0,0 +1,83 @@
+import { createHash } from "node:crypto";
+function normalizeText(text) {
+    return text.replace(/\r\n?/g, "\n").normalize("NFC");
+}
+function hash(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function bytesForFileData(data) {
+    if (typeof data === "string")
+        return data;
+    if (data instanceof Uint8Array)
+        return data;
+    if (data instanceof URL)
+        return data.href;
+    return undefined;
+}
+function visibleParts(content) {
+    const parts = typeof content === "string" ? [{ type: "text", text: content }] : content;
+    if (!Array.isArray(parts))
+        return [];
+    const result = [];
+    for (const rawPart of parts) {
+        if (typeof rawPart !== "object" || rawPart === null)
+            continue;
+        const part = rawPart;
+        if (part.type === "text" && typeof part.text === "string") {
+            result.push({ type: "text", digest: hash(normalizeText(part.text)) });
+        }
+        else if (part.type === "file" && typeof part.mediaType === "string") {
+            const bytes = bytesForFileData(part.data);
+            if (bytes !== undefined)
+                result.push({ type: "file", mediaType: part.mediaType, digest: hash(bytes) });
+        }
+        // Reasoning, tool calls/results, and system boilerplate are not visible
+        // user/assistant transcript lineage.
+    }
+    return result;
+}
+export function fingerprintTranscript(prompt) {
+    const fingerprints = [];
+    for (const message of prompt) {
+        if (message.role !== "user" && message.role !== "assistant")
+            continue;
+        const parts = visibleParts(message.content);
+        if (parts.length === 0)
+            continue;
+        fingerprints.push(hash(JSON.stringify({ role: message.role, parts })));
+    }
+    return fingerprints;
+}
+export function fingerprintCompactionOutput(summary) {
+    return hash(normalizeText(summary));
+}
+export function promptContainsCompactionFingerprint(prompt, candidateFingerprint) {
+    if (!/^[a-f0-9]{64}$/.test(candidateFingerprint))
+        return false;
+    for (const message of prompt) {
+        if (message.role !== "user" && message.role !== "assistant")
+            continue;
+        const parts = typeof message.content === "string"
+            ? [{ type: "text", text: message.content }]
+            : message.content;
+        if (!Array.isArray(parts))
+            continue;
+        for (const rawPart of parts) {
+            if (typeof rawPart !== "object" || rawPart === null)
+                continue;
+            const part = rawPart;
+            if (part.type === "text" && typeof part.text === "string"
+                && fingerprintCompactionOutput(part.text) === candidateFingerprint)
+                return true;
+        }
+    }
+    return false;
+}
+export function reconcileTranscript(previous, current, pendingCompactionFingerprints, prompt) {
+    if (previous.length <= current.length && previous.every((fingerprint, index) => current[index] === fingerprint))
+        return "same";
+    if (prompt && pendingCompactionFingerprints.some((candidate) => promptContainsCompactionFingerprint(prompt, candidate))) {
+        return "compacted";
+    }
+    return "diverged";
+}

package/dist/session/manager.d.ts

@@ -0,0 +1,40 @@
+import type { MspHandshake } from "@muse-code/sdk";
+import type { RequestContext } from "../types.js";
+import { MspHost } from "../msp/host.js";
+import type { SessionRegistry } from "./registry.js";
+import type { WorkspaceLock } from "./workspace-lock.js";
+import type { MuseTurnSession } from "../model/language-model.js";
+import type { AgentContextResult } from "../model/agent-context.js";
+export interface MuseSessionHost extends Pick<MspHost, "command" | "request" | "subscribe" | "mintCommandId" | "close"> {
+    initializeResult: Record<string, unknown>;
+}
+export interface MuseSessionManagerOptions {
+    stateDirectory?: string;
+    registry: SessionRegistry;
+    workspaceLock: WorkspaceLock;
+    museBin?: string;
+    createHost?(options: {
+        museBin?: string;
+        cwd: string;
+        args: readonly string[];
+        capabilities?: Parameters<MspHandshake["initialize"]>[0]["capabilities"];
+    }): Promise<MuseSessionHost>;
+    videoChunkBytes?: number;
+}
+export declare function workspaceFingerprint(directory: string): string;
+export declare class MuseSessionManager {
+    private readonly options;
+    private readonly bindings;
+    private readonly contextBySession;
+    private readonly createHost;
+    private closed;
+    constructor(options: MuseSessionManagerOptions);
+    setContextForSession(openCodeSessionId: string, context: AgentContextResult): void;
+    resolveSession(context: RequestContext): Promise<MuseTurnSession>;
+    close(): Promise<void>;
+    recordCompactionCandidate(openCodeSessionId: string, fingerprint: string): Promise<void>;
+    private applySelectionIfChanged;
+    private readonly bindingSessionIDs;
+    private openCodeSessionIdFor;
+    private persistBinding;
+}