opencode-muse 0.0.0-stage → 0.1.1

package/dist/model/meta.js

@@ -0,0 +1,171 @@
+const DEFAULT_TITLE = "Muse session";
+const MAX_TITLE_CODEPOINTS = 72;
+const MAX_DIGEST_CODEPOINTS = 12_000;
+const DIGEST_HEADER = "Transcript digest (local heuristic; not semantic):\n";
+const DIGEST_OMISSION = "[Omitted earlier content; no facts inferred.]";
+function promptMessages(prompt) {
+    return prompt;
+}
+function textFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (typeof part !== "object" || part === null)
+            return "";
+        const record = part;
+        return record.type === "text" && typeof record.text === "string" ? record.text : "";
+    })
+        .filter((text) => text.length > 0)
+        .join("\n");
+}
+function allText(prompt, role) {
+    return promptMessages(prompt)
+        .filter((message) => role === undefined || message.role === role)
+        .map((message) => textFromContent(message.content))
+        .filter((text) => text.length > 0)
+        .join("\n");
+}
+function detectPromptKind(prompt) {
+    const system = allText(prompt, "system").toLowerCase();
+    const user = allText(prompt, "user").toLowerCase();
+    if (system.includes("title generator")
+        || system.includes("generate a short title")
+        || system.includes("generate a concise title")
+        || system.includes("output only a thread title"))
+        return "title";
+    if (system.includes("anchored context summarization")
+        || system.includes("summarizing, compacting, or merging context")
+        || system.includes("tasked with summarizing conversations")
+        || system.includes("summarize what was done in this conversation")
+        || user.includes("this summary will be the only context available when the conversation continues")
+        || user.includes("create a detailed summary for continuing this coding session")
+        || user.includes("anchored summary below using the conversation history")
+        || user.includes("<previous-summary>"))
+        return "compaction";
+    return undefined;
+}
+/** Prefer the correlated kind; prompt-shape fallback is intentionally narrow. */
+export function classifyMetaRequest(kind, prompt) {
+    if (kind === "title")
+        return "title";
+    if (kind === "compaction")
+        return "compaction";
+    if (kind === "primary" || kind === "agent")
+        return "agent";
+    if (kind === "generate" || kind === undefined || kind.length === 0) {
+        const detected = detectPromptKind(prompt);
+        if (detected)
+            return detected;
+        return "unsupported-generate";
+    }
+    return "unsupported-generate";
+}
+/** Local, zero-model-call title from the first user-authored message only. */
+export function makeLocalTitle(prompt) {
+    const firstUser = promptMessages(prompt).find((message) => message.role === "user");
+    const text = textFromContent(firstUser?.content).replace(/\s+/g, " ").trim();
+    if (!text)
+        return DEFAULT_TITLE;
+    const points = Array.from(text);
+    if (points.length <= MAX_TITLE_CODEPOINTS)
+        return text;
+    const clipped = points.slice(0, MAX_TITLE_CODEPOINTS - 1).join("").trimEnd();
+    const wordBoundary = clipped.lastIndexOf(" ");
+    return `${(wordBoundary > MAX_TITLE_CODEPOINTS / 2 ? clipped.slice(0, wordBoundary) : clipped).trimEnd()}…`;
+}
+function digestMessages(prompt) {
+    return promptMessages(prompt)
+        .filter((message) => message.role === "user" || message.role === "assistant")
+        .map((message) => ({ role: message.role, text: textFromContent(message.content).trim() }))
+        .filter((message) => message.text.length > 0);
+}
+function codepoints(text) {
+    return Array.from(text);
+}
+function truncate(text, maxCodepoints) {
+    const points = codepoints(text);
+    if (points.length <= maxCodepoints)
+        return text;
+    if (maxCodepoints <= 1)
+        return "…".slice(0, maxCodepoints);
+    return `${points.slice(0, maxCodepoints - 1).join("")}…`;
+}
+function completeExchangePairs(messages, initialIndex) {
+    const pairs = [];
+    let user;
+    for (let index = initialIndex + 1; index < messages.length; index += 1) {
+        const message = messages[index];
+        if (message.role === "user") {
+            user = message;
+        }
+        else if (user) {
+            pairs.push([user, message]);
+            user = undefined;
+        }
+    }
+    return pairs;
+}
+/**
+ * Deterministic local transcript digest. It is bookkeeping, not synthesis:
+ * no tools, system prompts, hidden reasoning, or inferred decisions are added.
+ */
+export function makeCompactionDigest(prompt, maxOutputTokens) {
+    const tokenBudget = maxOutputTokens === undefined || !Number.isFinite(maxOutputTokens)
+        ? 1_024
+        : Math.floor(maxOutputTokens);
+    const maxCodepoints = Math.min(MAX_DIGEST_CODEPOINTS, tokenBudget);
+    const messages = digestMessages(prompt);
+    if (maxCodepoints < DIGEST_HEADER.length + DIGEST_OMISSION.length + 8) {
+        throw new Error("Compaction output budget is too small for a truthful labeled digest");
+    }
+    if (messages.length === 0) {
+        const empty = `${DIGEST_HEADER}No user/assistant text was available.`;
+        if (codepoints(empty).length > maxCodepoints)
+            throw new Error("Compaction output budget is too small for a truthful labeled digest");
+        return empty;
+    }
+    const initialIndex = messages.findIndex((message) => message.role === "user");
+    const firstIndex = initialIndex >= 0 ? initialIndex : 0;
+    const initial = messages[firstIndex];
+    const initialBlock = `${initialIndex >= 0 ? "Initial request" : "Initial visible message"}: ${initial.text}`;
+    const pairs = completeExchangePairs(messages, firstIndex);
+    const completeLines = [initialBlock, ...pairs.map(([user, assistant]) => `User: ${user.text}\nAssistant: ${assistant.text}`)];
+    const complete = `${DIGEST_HEADER}${completeLines.join("\n\n")}`;
+    if (codepoints(complete).length <= maxCodepoints)
+        return complete;
+    const fixedCost = codepoints(DIGEST_HEADER).length + codepoints(DIGEST_OMISSION).length + 2;
+    const bodyBudget = maxCodepoints - fixedCost;
+    const initialLabel = `${initialIndex >= 0 ? "Initial request" : "Initial visible message"}: `;
+    const initialContentBudget = Math.min(codepoints(initial.text).length, Math.max(1, Math.floor(bodyBudget * 0.2)));
+    const selected = [initialLabel + truncate(initial.text, initialContentBudget)];
+    let remaining = bodyBudget - codepoints(selected[0]).length;
+    const selectedPairs = [];
+    for (let index = pairs.length - 1; index >= 0; index -= 1) {
+        const [user, assistant] = pairs[index];
+        const block = `User: ${user.text}\nAssistant: ${assistant.text}`;
+        const separatorCost = 2;
+        const cost = codepoints(block).length + separatorCost;
+        if (cost > remaining) {
+            if (selectedPairs.length === 0 && remaining > 32) {
+                const prefixCost = codepoints("User: \nAssistant: ").length + separatorCost;
+                const textBudget = remaining - prefixCost;
+                const userBudget = Math.floor(textBudget / 2);
+                const assistantBudget = textBudget - userBudget;
+                selectedPairs.unshift(`User: ${truncate(user.text, userBudget)}\nAssistant: ${truncate(assistant.text, assistantBudget)}`);
+                remaining = 0;
+            }
+            break;
+        }
+        selectedPairs.unshift(block);
+        remaining -= cost;
+    }
+    selected.push(...selectedPairs);
+    const result = `${DIGEST_HEADER}${selected.join("\n\n")}\n${DIGEST_OMISSION}`;
+    if (codepoints(result).length > maxCodepoints) {
+        throw new Error("Compaction output budget is too small for a truthful labeled digest");
+    }
+    return result;
+}

package/dist/model/prompt.d.ts

@@ -0,0 +1,68 @@
+import type { LanguageModelV3Prompt } from "@ai-sdk/provider";
+export interface ContextFragment {
+    label: string;
+    text: string;
+}
+export type ExtractedTurnPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    base64Data: string;
+    mediaType: string;
+} | {
+    type: "video";
+    base64Data: string;
+    mediaType: "video/mp4" | "video/quicktime";
+    totalBytes: number;
+};
+export interface ExtractedTurnInput {
+    parts: ExtractedTurnPart[];
+    nextTranscriptFingerprints: string[];
+}
+export type PromptInputErrorCode = "transcript-diverged" | "no-new-user-input" | "invalid-context" | "invalid-media" | "remote-media" | "unsupported-media" | "media-too-large" | "aborted" | "unsupported-response-format" | "required-opencode-tool" | "unsupported-generation-option";
+export interface PromptInputError {
+    type: "prompt-error";
+    code: PromptInputErrorCode;
+    field?: string;
+    mediaType?: string;
+}
+export type ExtractTurnInputResult = ({
+    ok: true;
+} & ExtractedTurnInput) | {
+    ok: false;
+    error: PromptInputError;
+};
+export interface ExtractTurnInputOptions {
+    maxMediaBytes?: number;
+    maxInlineImageBytes?: number;
+    signal?: AbortSignal;
+}
+export interface ModelOptionsInput {
+    responseFormat?: {
+        type?: string;
+        [key: string]: unknown;
+    };
+    toolChoice?: string | {
+        type?: string;
+        toolName?: string;
+        [key: string]: unknown;
+    };
+    tools?: readonly unknown[];
+    [key: string]: unknown;
+}
+export type ModelOptionsResult = {
+    ok: true;
+    options: {
+        toolsIgnored: boolean;
+        ignoredOptions: string[];
+    };
+} | {
+    ok: false;
+    error: PromptInputError;
+};
+export declare const DEFAULT_MAX_MEDIA_BYTES: number;
+export declare const DEFAULT_MAX_INLINE_IMAGE_BYTES: number;
+export declare function fingerprintVisibleTranscript(prompt: LanguageModelV3Prompt): string[];
+export declare function extractTurnInput(prompt: LanguageModelV3Prompt, previousTranscriptFingerprints: readonly string[], contextAllowlist: readonly ContextFragment[], options?: ExtractTurnInputOptions): ExtractTurnInputResult;
+export declare function validateModelOptions(options: ModelOptionsInput): ModelOptionsResult;

package/dist/model/prompt.js

@@ -0,0 +1,175 @@
+import { fingerprintTranscript } from "../session/fingerprint.js";
+export const DEFAULT_MAX_MEDIA_BYTES = 64 * 1024 * 1024;
+export const DEFAULT_MAX_INLINE_IMAGE_BYTES = 7 * 1024 * 1024;
+function inputError(code, fields = {}) {
+    return { type: "prompt-error", code, ...fields };
+}
+function safeMediaType(value) {
+    const normalized = value.toLowerCase();
+    return /^[a-z0-9.+*-]+\/[a-z0-9.+*-]+$/.test(normalized) ? normalized : "unknown";
+}
+export function fingerprintVisibleTranscript(prompt) {
+    return fingerprintTranscript(prompt);
+}
+function visibleMessages(prompt) {
+    const result = [];
+    for (const message of prompt) {
+        const fingerprint = fingerprintTranscript([message])[0];
+        if (fingerprint)
+            result.push({ message, fingerprint });
+    }
+    return result;
+}
+function decodeBase64(value) {
+    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value) || value.length % 4 === 1)
+        return undefined;
+    const bytes = Buffer.from(value, "base64");
+    const canonical = bytes.toString("base64").replace(/=+$/, "");
+    return canonical === value.replace(/=+$/, "") ? bytes : undefined;
+}
+function fileBytes(part) {
+    let data = part.data;
+    if (data instanceof URL) {
+        if (data.protocol !== "data:")
+            return inputError("remote-media", { mediaType: safeMediaType(part.mediaType) });
+        data = data.href;
+    }
+    if (typeof data !== "string")
+        return { bytes: data, mediaType: part.mediaType };
+    if (/^https?:\/\//i.test(data))
+        return inputError("remote-media", { mediaType: safeMediaType(part.mediaType) });
+    let encoded = data;
+    let mediaType = part.mediaType;
+    if (data.startsWith("data:")) {
+        const match = /^data:([^;,]+);base64,(.*)$/s.exec(data);
+        if (!match)
+            return inputError("invalid-media", { mediaType: safeMediaType(part.mediaType) });
+        if (match[1] !== part.mediaType && part.mediaType !== "*/*") {
+            return inputError("invalid-media", { mediaType: safeMediaType(part.mediaType) });
+        }
+        mediaType = match[1];
+        encoded = match[2];
+    }
+    const bytes = decodeBase64(encoded);
+    if (!bytes || bytes.byteLength === 0)
+        return inputError("invalid-media", { mediaType: safeMediaType(mediaType) });
+    return { bytes, mediaType };
+}
+function extractFilePart(part, limits) {
+    const mediaType = part.mediaType.toLowerCase();
+    if (mediaType.startsWith("audio/") || mediaType === "application/pdf") {
+        return inputError("unsupported-media", { mediaType: safeMediaType(mediaType) });
+    }
+    const decoded = fileBytes(part);
+    if ("type" in decoded)
+        return decoded;
+    if (decoded.bytes.byteLength > limits.maxMediaBytes)
+        return inputError("media-too-large", { mediaType: safeMediaType(mediaType) });
+    if (mediaType.startsWith("image/")) {
+        if (!new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]).has(mediaType)) {
+            return inputError("unsupported-media", { mediaType: safeMediaType(mediaType) });
+        }
+        if (decoded.bytes.byteLength > limits.maxInlineImageBytes)
+            return inputError("media-too-large", { mediaType: safeMediaType(mediaType) });
+        return { type: "image", base64Data: Buffer.from(decoded.bytes).toString("base64"), mediaType };
+    }
+    if (mediaType === "video/mp4" || mediaType === "video/quicktime") {
+        return {
+            type: "video",
+            base64Data: Buffer.from(decoded.bytes).toString("base64"),
+            mediaType,
+            totalBytes: decoded.bytes.byteLength,
+        };
+    }
+    if (mediaType.startsWith("text/")) {
+        return { type: "text", text: Buffer.from(decoded.bytes).toString("utf8") };
+    }
+    return inputError("unsupported-media", { mediaType: safeMediaType(mediaType) });
+}
+export function extractTurnInput(prompt, previousTranscriptFingerprints, contextAllowlist, options = {}) {
+    if (options.signal?.aborted)
+        return { ok: false, error: inputError("aborted") };
+    const current = visibleMessages(prompt);
+    const currentFingerprints = current.map((entry) => entry.fingerprint);
+    let newMessages = current;
+    if (previousTranscriptFingerprints.length > 0) {
+        if (previousTranscriptFingerprints.length > currentFingerprints.length
+            || previousTranscriptFingerprints.some((fingerprint, index) => currentFingerprints[index] !== fingerprint)) {
+            return { ok: false, error: inputError("transcript-diverged") };
+        }
+        newMessages = current.slice(previousTranscriptFingerprints.length);
+    }
+    else {
+        // On first use in an existing OpenCode session, send only the final user
+        // turn; never replay its previous transcript into a new Muse session.
+        let lastUserIndex = -1;
+        for (let index = 0; index < current.length; index += 1) {
+            if (current[index].message.role === "user")
+                lastUserIndex = index;
+        }
+        if (lastUserIndex >= 0)
+            newMessages = current.slice(lastUserIndex);
+        else
+            newMessages = [];
+    }
+    const currentUserMessages = newMessages.filter((entry) => entry.message.role === "user");
+    if (currentUserMessages.length === 0)
+        return { ok: false, error: inputError("no-new-user-input") };
+    const parts = [];
+    for (const fragment of contextAllowlist) {
+        if (options.signal?.aborted)
+            return { ok: false, error: inputError("aborted") };
+        if (!fragment.label.trim() || !fragment.text.trim())
+            return { ok: false, error: inputError("invalid-context") };
+        parts.push({ type: "text", text: `[${fragment.label.trim()}]\n${fragment.text}` });
+    }
+    const limits = {
+        maxMediaBytes: options.maxMediaBytes ?? DEFAULT_MAX_MEDIA_BYTES,
+        maxInlineImageBytes: options.maxInlineImageBytes ?? DEFAULT_MAX_INLINE_IMAGE_BYTES,
+    };
+    for (const entry of currentUserMessages) {
+        if (entry.message.role !== "user")
+            continue;
+        for (const part of entry.message.content) {
+            if (options.signal?.aborted)
+                return { ok: false, error: inputError("aborted") };
+            if (part.type === "text") {
+                parts.push({ type: "text", text: part.text });
+            }
+            else if (part.type === "file") {
+                const mapped = extractFilePart(part, limits);
+                if ("code" in mapped)
+                    return { ok: false, error: mapped };
+                parts.push(mapped);
+            }
+        }
+    }
+    if (options.signal?.aborted)
+        return { ok: false, error: inputError("aborted") };
+    if (parts.length === 0)
+        return { ok: false, error: inputError("no-new-user-input") };
+    return { ok: true, parts, nextTranscriptFingerprints: currentFingerprints };
+}
+export function validateModelOptions(options) {
+    if (options.responseFormat?.type === "json") {
+        return { ok: false, error: inputError("unsupported-response-format", { field: "responseFormat" }) };
+    }
+    if (options.responseFormat !== undefined && options.responseFormat.type !== "text") {
+        return { ok: false, error: inputError("unsupported-response-format", { field: "responseFormat" }) };
+    }
+    const toolChoice = options.toolChoice;
+    if (typeof toolChoice === "object" && toolChoice !== null
+        && (toolChoice.type === "tool" || toolChoice.type === "required")) {
+        return { ok: false, error: inputError("required-opencode-tool", { field: "toolChoice" }) };
+    }
+    if (toolChoice === "required")
+        return { ok: false, error: inputError("required-opencode-tool", { field: "toolChoice" }) };
+    const samplingOptions = [
+        "maxOutputTokens", "temperature", "topP", "topK", "presencePenalty", "frequencyPenalty", "stopSequences", "seed", "providerOptions",
+    ];
+    const ignoredOptions = samplingOptions.filter((name) => options[name] !== undefined);
+    return {
+        ok: true,
+        options: { toolsIgnored: (options.tools?.length ?? 0) > 0, ignoredOptions },
+    };
+}

package/dist/model/stream.d.ts

@@ -0,0 +1,46 @@
+import type { MspNotification } from "../msp/client.js";
+export interface FlatMuseUsage {
+    inputTokens: number | undefined;
+    outputTokens: number | undefined;
+    totalTokens: number | undefined;
+    reasoningTokens: number | undefined;
+}
+export type MuseStreamPart = Record<string, unknown>;
+/** Maps typed Muse view facts to text/reasoning-only V3 events and safe usage. */
+export declare class MuseStreamMapper {
+    readonly turnId: string;
+    private readonly itemKinds;
+    private readonly itemStarted;
+    private readonly reasoningStarted;
+    private readonly itemDeltaCounts;
+    private readonly itemText;
+    private readonly seenUsageCursors;
+    private readonly textParts;
+    private terminalUsage;
+    private callUsage;
+    private hasCallUsage;
+    private finishWasSent;
+    private currentFinishReason;
+    terminal?: string;
+    failure?: Error;
+    constructor(turnId: string);
+    get generatedText(): string;
+    get content(): Array<{
+        type: "text";
+        text: string;
+    }>;
+    get usage(): FlatMuseUsage | undefined;
+    get finishWasSentToOpenCode(): boolean;
+    get finishReason(): {
+        unified: "stop" | "error" | "other";
+        raw: string;
+    } | undefined;
+    accept(notification: MspNotification): MuseStreamPart[];
+    private itemStartedEvent;
+    private itemDeltaEvent;
+    private itemCompletedEvent;
+    private tokenUsageEvent;
+    private turnCompleted;
+    private failAndFinish;
+    private finishPart;
+}