opencode-muse 0.0.0-stage → 0.1.0

package/dist/model/agent-context.js

@@ -0,0 +1,35 @@
+const STOCK_AGENT_PROMPT = /^\s*You are (?:an AI agent running in OpenCode|OpenCode|opencode)\b/i;
+const MODEL_IDENTITY_HEADING = /^# Your Model[\t ]*$/im;
+const KNOWN_BUILTIN_AGENTS = new Set(["build", "plan", "general", "explore"]);
+function systemText(systemParts) {
+    return systemParts
+        .map((part) => {
+        if (typeof part !== "object" || part === null)
+            return "";
+        const value = part;
+        return value.type === "text" && typeof value.text === "string" ? value.text : "";
+    })
+        .filter((text) => text.length > 0)
+        .join("\n");
+}
+/**
+ * Forward only a custom agent's bounded prompt prefix. Stock OpenCode prompts,
+ * tool catalogs, and unknown system layouts are never copied into Muse input.
+ */
+export function extractAllowedAgentContext(agent, systemParts) {
+    const system = systemText(systemParts);
+    const identity = MODEL_IDENTITY_HEADING.exec(system);
+    if (identity) {
+        const prefix = system.slice(0, identity.index).trim();
+        if (!prefix || STOCK_AGENT_PROMPT.test(prefix))
+            return { supported: true, fragments: [] };
+        return {
+            supported: true,
+            fragments: [{ label: "OpenCode agent instructions", text: prefix }],
+        };
+    }
+    if (STOCK_AGENT_PROMPT.test(system) || KNOWN_BUILTIN_AGENTS.has(agent)) {
+        return { supported: true, fragments: [] };
+    }
+    return { supported: false, fragments: [] };
+}

package/dist/model/context.d.ts

@@ -0,0 +1,26 @@
+import type { MuseModelSelection, RequestContext, ContextError } from "../types.js";
+export declare const MUSE_CONTEXT_HEADERS: Readonly<{
+    sessionID: "x-opencode-muse-session-id";
+    directory: "x-opencode-muse-directory";
+    kind: "x-opencode-muse-kind";
+    modelID: "x-opencode-muse-model-id";
+    providerID: "x-opencode-muse-provider-id";
+    variant: "x-opencode-muse-variant";
+}>;
+export interface ModelRequestHookInput {
+    sessionID: string;
+    kind: string;
+    model: {
+        id: string;
+        providerID: string;
+        variant?: string;
+    };
+    headers: Record<string, string>;
+}
+export interface LanguageModelCallContext {
+    headers?: Record<string, string | undefined>;
+}
+/** Stamp per-call metadata into headers proven to survive model.request → V3 call options. */
+export declare function addRequestContextHeaders(headers: Record<string, string>, request: ModelRequestHookInput, directory: string): boolean;
+/** Decode only the namespaced, per-call carrier; never guess from global request state. */
+export declare function readRequestContext(callOptions: LanguageModelCallContext, selectionIndex: ReadonlyMap<string, MuseModelSelection>): RequestContext | ContextError;

package/dist/model/context.js

@@ -0,0 +1,87 @@
+export const MUSE_CONTEXT_HEADERS = Object.freeze({
+    sessionID: "x-opencode-muse-session-id",
+    directory: "x-opencode-muse-directory",
+    kind: "x-opencode-muse-kind",
+    modelID: "x-opencode-muse-model-id",
+    providerID: "x-opencode-muse-provider-id",
+    variant: "x-opencode-muse-variant",
+});
+const REQUEST_KINDS = new Set(["primary", "title", "compaction", "generate"]);
+function readHeader(headers, target) {
+    if (!headers)
+        return undefined;
+    const direct = headers[target];
+    if (typeof direct === "string")
+        return direct;
+    const normalized = target.toLowerCase();
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() === normalized && typeof value === "string")
+            return value;
+    }
+    return undefined;
+}
+function contextError(code, field) {
+    return { type: "context-error", code, field };
+}
+/** Stamp per-call metadata into headers proven to survive model.request → V3 call options. */
+export function addRequestContextHeaders(headers, request, directory) {
+    if (request.model.providerID !== "muse")
+        return false;
+    headers[MUSE_CONTEXT_HEADERS.sessionID] = request.sessionID;
+    headers[MUSE_CONTEXT_HEADERS.directory] = directory;
+    headers[MUSE_CONTEXT_HEADERS.kind] = request.kind;
+    headers[MUSE_CONTEXT_HEADERS.modelID] = request.model.id;
+    headers[MUSE_CONTEXT_HEADERS.providerID] = request.model.providerID;
+    if (request.model.variant)
+        headers[MUSE_CONTEXT_HEADERS.variant] = request.model.variant;
+    else
+        delete headers[MUSE_CONTEXT_HEADERS.variant];
+    return true;
+}
+/** Decode only the namespaced, per-call carrier; never guess from global request state. */
+export function readRequestContext(callOptions, selectionIndex) {
+    const headers = callOptions.headers;
+    if (!headers)
+        return contextError("missing", "headers");
+    const sessionID = readHeader(headers, MUSE_CONTEXT_HEADERS.sessionID);
+    if (!sessionID)
+        return contextError("missing", "sessionID");
+    const directory = readHeader(headers, MUSE_CONTEXT_HEADERS.directory);
+    if (!directory)
+        return contextError("missing", "directory");
+    const kind = readHeader(headers, MUSE_CONTEXT_HEADERS.kind);
+    if (!kind)
+        return contextError("missing", "kind");
+    if (!REQUEST_KINDS.has(kind))
+        return contextError("invalid", "kind");
+    const modelID = readHeader(headers, MUSE_CONTEXT_HEADERS.modelID);
+    if (!modelID)
+        return contextError("missing", "modelID");
+    const providerID = readHeader(headers, MUSE_CONTEXT_HEADERS.providerID);
+    if (!providerID)
+        return contextError("missing", "providerID");
+    if (providerID !== "muse")
+        return contextError("invalid", "providerID");
+    const museSelection = selectionIndex.get(modelID);
+    if (!museSelection)
+        return contextError("unknown-model", "modelID");
+    const rawVariant = readHeader(headers, MUSE_CONTEXT_HEADERS.variant);
+    const variant = rawVariant || undefined;
+    // OpenCode's default agent sends the synthetic "default" variant when the user
+    // did not choose one; resolve it to the catalog row's default reasoning effort.
+    const resolvedVariant = variant === "default"
+        ? (museSelection.defaultReasoningEffort ?? undefined)
+        : variant;
+    if (resolvedVariant && (!museSelection.variantsKnown || !museSelection.variants.includes(resolvedVariant))) {
+        return contextError("unsupported-variant", "variant");
+    }
+    return {
+        sessionID,
+        directory,
+        kind: kind,
+        modelID,
+        providerID,
+        ...(resolvedVariant ? { variant: resolvedVariant, effort: resolvedVariant } : {}),
+        museSelection,
+    };
+}

package/dist/model/language-model.d.ts

@@ -0,0 +1,48 @@
+import type { LanguageModelV3, LanguageModelV3CallOptions } from "@ai-sdk/provider";
+import type { MspNotification } from "../msp/client.js";
+import { type ContextFragment, type ExtractedTurnPart } from "./prompt.js";
+import type { MuseModelSelection, RequestContext } from "../types.js";
+export interface MuseTurnHost {
+    mintCommandId(): string;
+    command<TResult extends object = Record<string, unknown>>(method: string, params: 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>;
+}
+export interface MuseTurnSession {
+    host: MuseTurnHost;
+    sessionId: string;
+    previousTranscriptFingerprints: readonly string[];
+    compactionFingerprints?: readonly string[];
+    commitTranscriptFingerprints?(fingerprints: readonly string[]): Promise<void>;
+    contextAllowlist: readonly ContextFragment[];
+    contextError?: string;
+    replayAfterCursor?: string;
+    currentSelection?: Pick<MuseModelSelection, "providerId" | "modelId" | "profileId">;
+    recordPendingCommand?(input: {
+        commandId: string;
+        method: string;
+        fingerprint: string;
+    }): Promise<void>;
+    clearPendingCommand?(commandId: string): Promise<void>;
+    recordTurnAccepted?(commandId: string, turnId: string): Promise<void>;
+    updateCursor?(cursor: string): Promise<void>;
+    recordTurnCompleted?(turnId: string, terminal: string, usage?: Record<string, unknown>): Promise<void>;
+    release?(): Promise<void>;
+}
+export interface MuseLanguageRuntime {
+    selectionIndex: ReadonlyMap<string, MuseModelSelection>;
+    resolveSession(context: RequestContext): Promise<MuseTurnSession>;
+    videoChunkBytes?: number;
+}
+export interface MuseTurnExecution {
+    turnId: string;
+    commandId: string;
+    disposition: string;
+    events: AsyncIterable<MspNotification>;
+    cancel(): Promise<void>;
+}
+export declare function runMuseTurn(context: RequestContext, input: readonly ExtractedTurnPart[], options: Pick<LanguageModelV3CallOptions, "abortSignal">, runtime: MuseLanguageRuntime, transcriptFingerprints?: readonly string[]): Promise<MuseTurnExecution>;
+export declare function createMuseLanguageModel(runtime: MuseLanguageRuntime, modelID: string): LanguageModelV3;