opencode-agent-variants 0.1.0

package/dist/config.js

@@ -0,0 +1,227 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { parse, stringify } from "comment-json";
+import { z } from "zod";
+export const BUILTIN_AGENT_DESCRIPTIONS = {
+    build: "The default agent. Executes tools based on configured permissions.",
+    plan: "Plan mode. Disallows all edit tools.",
+    general: "General-purpose agent for researching complex questions and executing multi-step tasks. Use this agent to execute multiple units of work in parallel.",
+    explore: "Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. \"src/components/**/*.tsx\"), search code for keywords (eg. \"API endpoints\"), or answer questions about the codebase (eg. \"how do API endpoints work?\"). When calling this agent, specify the desired thoroughness level: \"quick\" for basic searches, \"medium\" for moderate exploration, or \"very thorough\" for comprehensive analysis across multiple locations and naming conventions.",
+    scout: "Docs and dependency-source specialist. Use this when you need to inspect external documentation, clone dependency repositories into the managed cache, and research library implementation details without modifying the user's workspace.",
+};
+const Color = z.union([
+    z.string().regex(/^#[0-9a-fA-F]{6}$/),
+    z.enum(["primary", "secondary", "accent", "success", "warning", "error", "info"]),
+]);
+const Patch = z.object({
+    model: z.string().optional(),
+    variant: z.string().optional(),
+    temperature: z.number().finite().optional(),
+    top_p: z.number().finite().optional(),
+    prompt: z.string().optional(),
+    prompt_prepend: z.string().optional(),
+    prompt_append: z.string().optional(),
+    description: z.string().optional(),
+    description_prepend: z.string().optional(),
+    description_append: z.string().optional(),
+    options: z.record(z.string(), z.unknown()).optional(),
+    color: Color.optional(),
+    disable: z.boolean().optional(),
+});
+const Variant = Patch.extend({
+    name: z.string().min(1).optional(),
+});
+export const SidecarConfig = z.object({
+    debug: z.boolean().default(false),
+    models: z.record(z.string(), z.object({
+        model: z.string().min(1),
+        label: z.string().min(1).optional(),
+    })).default({}),
+    agents: z.record(z.string(), z.object({
+        disable: z.boolean().optional(),
+        parent: Patch.default({}),
+        variants: z.record(z.string(), Variant).default({}),
+    })).default({}),
+});
+export function defaultConfigDir() {
+    return join(homedir(), ".config", "opencode");
+}
+export function defaultSidecarPath(configDir = defaultConfigDir()) {
+    return join(configDir, "agent-variants.jsonc");
+}
+export function debugLogPath(configDir = defaultConfigDir()) {
+    return join(configDir, "agent-variants.debug.log");
+}
+export function emptyConfig() {
+    return { debug: false, models: {}, agents: {} };
+}
+export function loadSidecar(filePath = defaultSidecarPath()) {
+    if (!existsSync(filePath))
+        return emptyConfig();
+    return SidecarConfig.parse(parse(readFileSync(filePath, "utf8")));
+}
+export function saveSidecar(config, filePath = defaultSidecarPath()) {
+    const parsed = SidecarConfig.parse(config);
+    mkdirSync(dirname(filePath), { recursive: true });
+    if (existsSync(filePath)) {
+        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+        writeFileSync(`${filePath}.${stamp}.bak`, readFileSync(filePath));
+    }
+    const temp = `${filePath}.tmp`;
+    writeFileSync(temp, `${stringify(parsed, null, 2)}\n`);
+    renameSync(temp, filePath);
+}
+export function renderTemplate(input, context) {
+    if (!input || !context)
+        return input;
+    const values = {
+        parent: context.parent,
+        alias: context.alias ?? "",
+        variant_key: context.variant_key ?? "",
+        model: context.model ?? "",
+        model_label: context.model_label ?? context.model ?? "",
+        routed_agent: context.routed_agent ?? context.parent,
+    };
+    return input.replace(/\{(parent|alias|variant_key|model|model_label|routed_agent)\}/g, (_, key) => values[key] ?? "");
+}
+export function applyTextPatch(base, patch, context) {
+    const text = patch.description ?? base ?? "";
+    return [patch.description_prepend, text, patch.description_append]
+        .map((item) => renderTemplate(item, context))
+        .filter((item) => item && item.length > 0)
+        .join(" ")
+        .trim();
+}
+export function applyPromptPatch(base, patch, context) {
+    const text = patch.prompt ?? base ?? "";
+    return [patch.prompt_prepend, text, patch.prompt_append]
+        .map((item) => renderTemplate(item, context))
+        .filter((item) => item && item.length > 0)
+        .join("\n\n")
+        .trim();
+}
+export function resolveModel(input, config) {
+    if (!input)
+        return;
+    return config.models[input]?.model ?? input;
+}
+export function modelLabel(input, config) {
+    if (!input)
+        return "the configured model";
+    return config.models[input]?.label ?? config.models[input]?.model ?? input;
+}
+export function splitModelRef(model) {
+    if (!model)
+        return;
+    const [providerID, ...modelParts] = model.split("/");
+    if (!providerID || modelParts.length === 0)
+        return;
+    return { providerID, modelID: modelParts.join("/") };
+}
+export function variantName(parent, key, variant) {
+    return variant.name?.trim() || `${parent}-${key}`;
+}
+export function templateContext(parent, key, variant, config) {
+    const model = resolveModel(variant.model, config);
+    const alias = key ? variantName(parent, key, variant) : parent;
+    return {
+        parent,
+        alias,
+        variant_key: key,
+        model,
+        model_label: modelLabel(variant.model, config),
+        routed_agent: parent,
+    };
+}
+export function generatedVariantDescription(parent, key, variant, config) {
+    const context = templateContext(parent, key, variant, config);
+    const base = variant.description ?? `Copy of the ${parent} agent using ${modelLabel(variant.model, config)}.`;
+    return [variant.description_prepend, base, variant.description_append]
+        .map((item) => renderTemplate(item, context))
+        .filter((item) => item && item.length > 0)
+        .join(" ")
+        .trim();
+}
+export function modelCatalogFromProviders(providers) {
+    const catalog = { providers: new Set(), providersWithModelList: new Set(), refs: new Set() };
+    const list = Array.isArray(providers) ? providers : Object.entries((providers ?? {})).map(([id, value]) => ({ id, ...value }));
+    for (const provider of list) {
+        const providerID = typeof provider.id === "string" ? provider.id : undefined;
+        if (!providerID)
+            continue;
+        catalog.providers.add(providerID);
+        const models = provider.models;
+        if (!models || Object.keys(models).length === 0)
+            continue;
+        catalog.providersWithModelList.add(providerID);
+        for (const [key, value] of Object.entries(models)) {
+            catalog.refs.add(`${providerID}/${key}`);
+            if (typeof value.id === "string")
+                catalog.refs.add(`${providerID}/${value.id}`);
+        }
+    }
+    return catalog;
+}
+export function validateModel(modelInput, config, catalog) {
+    const model = resolveModel(modelInput, config);
+    if (!model)
+        return;
+    const split = splitModelRef(model);
+    if (!split)
+        return `Model "${model}" must use provider/model format.`;
+    if (!catalog.providers.has(split.providerID))
+        return `Provider "${split.providerID}" is not configured for model "${model}".`;
+    if (catalog.providersWithModelList.has(split.providerID) && !catalog.refs.has(model))
+        return `Model "${model}" was not found in provider "${split.providerID}".`;
+}
+export function diagnoseConfig(config, input) {
+    const diagnostics = [];
+    const catalog = modelCatalogFromProviders(input.providers);
+    const knownAgents = new Set([...Object.keys(BUILTIN_AGENT_DESCRIPTIONS), ...input.agents]);
+    const generated = new Map();
+    if (!input.pluginEntries?.some((entry) => String(Array.isArray(entry) ? entry[0] : entry).includes("agent-variants"))) {
+        diagnostics.push({ level: "warning", message: "Agent Variants plugin was not found in loaded plugin entries." });
+    }
+    diagnostics.push({ level: "info", message: `Debug mode is ${config.debug ? "enabled" : "disabled"}.` });
+    for (const [agent, entry] of Object.entries(config.agents)) {
+        if (!knownAgents.has(agent))
+            diagnostics.push({ level: "warning", agent, message: `Parent agent "${agent}" is not a known built-in or configured agent.` });
+        if (entry.disable)
+            diagnostics.push({ level: "info", agent, message: `Parent "${agent}" is disabled in sidecar config.` });
+        for (const [key, variant] of Object.entries(entry.variants)) {
+            const alias = variantName(agent, key, variant);
+            const issue = validateModel(variant.model, config, catalog);
+            if (issue)
+                diagnostics.push({ level: "warning", agent, variant: key, alias, message: `Variant "${alias}" disabled at runtime: ${issue}` });
+            if (alias === agent)
+                diagnostics.push({ level: "error", agent, variant: key, alias, message: `Variant "${alias}" uses the same name as its parent.` });
+            const existing = generated.get(alias);
+            if (existing)
+                diagnostics.push({ level: "error", agent, variant: key, alias, message: `Variant alias "${alias}" duplicates ${existing.agent}.${existing.variant}.` });
+            if (!existing)
+                generated.set(alias, { agent, variant: key });
+            if (knownAgents.has(alias) && alias !== agent)
+                diagnostics.push({ level: "error", agent, variant: key, alias, message: `Variant alias "${alias}" conflicts with an existing agent.` });
+        }
+    }
+    return diagnostics;
+}
+export function fingerprint(input) {
+    return createHash("sha256")
+        .update(input.parentSessionID)
+        .update("\0")
+        .update(input.agent)
+        .update("\0")
+        .update(input.description ?? "")
+        .update("\0")
+        .update(input.prompt)
+        .digest("hex");
+}
+export function hasPromptPatch(patch) {
+    return patch.prompt !== undefined || patch.prompt_prepend !== undefined || patch.prompt_append !== undefined;
+}
+export function hasRequestPatch(patch) {
+    return patch.temperature !== undefined || patch.top_p !== undefined || patch.options !== undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+declare const plugin: Plugin;
+export default plugin;

package/dist/index.js

@@ -0,0 +1,406 @@
+import { randomUUID } from "node:crypto";
+import { appendFileSync } from "node:fs";
+import { applyPromptPatch, applyTextPatch, BUILTIN_AGENT_DESCRIPTIONS, defaultConfigDir, defaultSidecarPath, debugLogPath, fingerprint, generatedVariantDescription, hasPromptPatch, hasRequestPatch, loadSidecar, modelCatalogFromProviders, resolveModel, splitModelRef, templateContext, validateModel, variantName, } from "./config.js";
+const BUILTIN_AGENTS = new Set(Object.keys(BUILTIN_AGENT_DESCRIPTIONS));
+const ROUTE_TTL = 10 * 60 * 1000;
+const MARKER_PREFIX = "<!-- agent-variants-route:";
+const MARKER_SUFFIX = " -->";
+function marker(token) {
+    return `${MARKER_PREFIX}${token}${MARKER_SUFFIX}`;
+}
+function attr(value) {
+    return (value ?? "").replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function routeModel(route) {
+    return route.model ?? "inherit";
+}
+function routeSummary(route) {
+    return `${route.alias} selected; native agent=${route.parent}; effective model=${routeModel(route)}; variant=${route.variant ?? "default"}`;
+}
+function debugEnabled() {
+    try {
+        return loadSidecar(defaultSidecarPath()).debug;
+    }
+    catch {
+        return false;
+    }
+}
+function mergeOptions(target, source) {
+    return { ...(target ?? {}), ...(source ?? {}) };
+}
+function applyPatch(target, patch, config, base, context) {
+    const next = target;
+    const model = resolveModel(patch.model, config);
+    if (model)
+        next.model = model;
+    if (patch.variant !== undefined)
+        next.variant = patch.variant;
+    if (patch.temperature !== undefined)
+        next.temperature = patch.temperature;
+    if (patch.top_p !== undefined)
+        next.top_p = patch.top_p;
+    if (patch.options !== undefined)
+        next.options = mergeOptions(next.options, patch.options);
+    if (patch.color !== undefined)
+        next.color = patch.color;
+    if (patch.description !== undefined || patch.description_prepend !== undefined || patch.description_append !== undefined) {
+        next.description = applyTextPatch(next.description ?? base?.description, patch, context);
+    }
+    if (patch.prompt !== undefined || patch.prompt_prepend !== undefined || patch.prompt_append !== undefined) {
+        next.prompt = applyPromptPatch(next.prompt ?? base?.prompt, patch, context);
+    }
+    return next;
+}
+function applyConfigPatch(target, patch, config, base, builtin, context) {
+    const safePatch = builtin && patch.prompt === undefined ? { ...patch, prompt_prepend: undefined, prompt_append: undefined } : patch;
+    return applyPatch(target, safePatch, config, base, context);
+}
+function virtualPatch(alias, description, patch, config) {
+    const result = {
+        mode: "subagent",
+        description,
+    };
+    const model = resolveModel(patch.model, config);
+    if (model)
+        result.model = model;
+    if (patch.variant !== undefined)
+        result.variant = patch.variant;
+    if (patch.temperature !== undefined)
+        result.temperature = patch.temperature;
+    if (patch.top_p !== undefined)
+        result.top_p = patch.top_p;
+    if (patch.options !== undefined)
+        result.options = patch.options;
+    if (patch.color !== undefined)
+        result.color = patch.color;
+    result.prompt = `Virtual alias generated by opencode-agent-variants for ${alias}. Runtime routing should execute the parent agent instead.`;
+    return result;
+}
+function assembleAgents(cfg, sidecar) {
+    cfg.agent = cfg.agent ?? {};
+    const virtualRoutes = new Map();
+    const parentPromptPatches = new Map();
+    const parentRequestPatches = new Map();
+    const diagnostics = [];
+    const catalog = modelCatalogFromProviders(cfg.provider);
+    const originalAgents = new Set([...Object.keys(cfg.agent), ...Object.keys(BUILTIN_AGENT_DESCRIPTIONS)]);
+    const generatedAliases = new Map();
+    for (const [parent, entry] of Object.entries(sidecar.agents)) {
+        const parentConfig = cfg.agent[parent];
+        if (entry.disable) {
+            diagnostics.push({ level: "info", agent: parent, message: `Parent "${parent}" is disabled in sidecar config.` });
+            continue;
+        }
+        if (parentConfig?.disable === true) {
+            diagnostics.push({ level: "info", agent: parent, message: `Parent "${parent}" is disabled in OpenCode config; variants skipped.` });
+            continue;
+        }
+        const enabledVariants = Object.entries(entry.variants).filter(([, variant]) => variant.disable !== true);
+        if (enabledVariants.length === 0)
+            continue;
+        const isBuiltin = BUILTIN_AGENTS.has(parent);
+        const base = parentConfig ?? (isBuiltin ? { description: BUILTIN_AGENT_DESCRIPTIONS[parent] } : undefined);
+        if (!base && !isBuiltin) {
+            diagnostics.push({ level: "warning", agent: parent, message: `Parent agent "${parent}" was not found; variants skipped.` });
+            continue;
+        }
+        cfg.agent[parent] = applyConfigPatch({ ...(parentConfig ?? {}) }, entry.parent, sidecar, base, isBuiltin, templateContext(parent, undefined, {}, sidecar));
+        if (isBuiltin && hasPromptPatch(entry.parent))
+            parentPromptPatches.set(parent, entry.parent);
+        if (isBuiltin && hasRequestPatch(entry.parent))
+            parentRequestPatches.set(parent, entry.parent);
+        for (const [key, variant] of enabledVariants) {
+            const alias = variantName(parent, key, variant);
+            const modelIssue = validateModel(variant.model, sidecar, catalog);
+            if (modelIssue) {
+                diagnostics.push({ level: "warning", agent: parent, variant: key, alias, message: `Variant "${alias}" disabled at runtime: ${modelIssue}` });
+                continue;
+            }
+            if (alias === parent) {
+                diagnostics.push({ level: "error", agent: parent, variant: key, alias, message: `Variant "${alias}" uses the same name as its parent and was skipped.` });
+                continue;
+            }
+            const existing = generatedAliases.get(alias);
+            if (existing) {
+                diagnostics.push({ level: "error", agent: parent, variant: key, alias, message: `Variant "${alias}" duplicates ${existing} and was skipped.` });
+                continue;
+            }
+            if (originalAgents.has(alias)) {
+                diagnostics.push({ level: "error", agent: parent, variant: key, alias, message: `Variant "${alias}" conflicts with an existing agent and was skipped.` });
+                continue;
+            }
+            generatedAliases.set(alias, `${parent}.${key}`);
+            const description = generatedVariantDescription(parent, key, variant, sidecar);
+            if (isBuiltin) {
+                cfg.agent[alias] = virtualPatch(alias, description, variant, sidecar);
+                virtualRoutes.set(alias, {
+                    alias,
+                    parent,
+                    key,
+                    patch: variant,
+                    model: resolveModel(variant.model, sidecar),
+                    variant: variant.variant,
+                });
+                continue;
+            }
+            const copy = applyPatch({ ...(cfg.agent[parent] ?? {}) }, variant, sidecar, cfg.agent[parent], templateContext(parent, key, variant, sidecar));
+            copy.description = description;
+            delete copy.disable;
+            cfg.agent[alias] = copy;
+        }
+    }
+    return { virtualRoutes, parentPromptPatches, parentRequestPatches, diagnostics };
+}
+function textFromParts(parts) {
+    const primary = parts.filter((part) => part?.type === "text" && !part.synthetic).map((part) => part.text).join("\n\n");
+    if (primary.trim())
+        return primary;
+    return parts.filter((part) => part?.type === "text").map((part) => part.text).join("\n\n");
+}
+function takeMarkerRoute(parts, routes) {
+    for (const part of parts) {
+        if (part?.type !== "text" || typeof part.text !== "string")
+            continue;
+        const start = part.text.indexOf(MARKER_PREFIX);
+        if (start < 0)
+            continue;
+        const end = part.text.indexOf(MARKER_SUFFIX, start);
+        if (end < 0)
+            continue;
+        const token = part.text.slice(start + MARKER_PREFIX.length, end);
+        const route = routes.get(token);
+        part.text = `${part.text.slice(0, start)}${part.text.slice(end + MARKER_SUFFIX.length)}`.trim();
+        routes.delete(token);
+        if (route)
+            return { token, route };
+    }
+}
+function removePendingToken(list, token) {
+    const index = list.findIndex((item) => item.token === token);
+    if (index >= 0)
+        list.splice(index, 1);
+}
+function cleanupPending(list, routes) {
+    const cutoff = Date.now() - ROUTE_TTL;
+    while (list[0] && list[0].createdAt < cutoff) {
+        const item = list.shift();
+        if (item)
+            routes?.delete(item.token);
+    }
+}
+function takePending(list, input) {
+    const exact = list.findIndex((item) => item.parentSessionID === input.parentSessionID && item.targetAgent === input.agent && item.fingerprint === input.fingerprint);
+    if (exact >= 0)
+        return list.splice(exact, 1)[0];
+    const fallback = list.findIndex((item) => item.parentSessionID === input.parentSessionID && item.targetAgent === input.agent);
+    if (fallback >= 0)
+        return list.splice(fallback, 1)[0];
+}
+function getData(value) {
+    if (value && typeof value === "object" && "data" in value)
+        return value.data;
+    return value;
+}
+async function getSession(client, sessionID) {
+    return getData(await client.session.get({ path: { id: sessionID } }).catch(() => undefined));
+}
+async function debugToast(client, enabled, title, message) {
+    if (!enabled && !debugEnabled())
+        return;
+    try {
+        appendFileSync(debugLogPath(defaultConfigDir()), `${new Date().toISOString()} ${title}: ${message}\n`);
+    }
+    catch {
+        // Debug logging should never affect routing.
+    }
+    await client.tui?.showToast?.({
+        body: {
+            title,
+            message,
+            variant: "info",
+            duration: 12000,
+        },
+    }).catch(() => undefined);
+}
+async function warningToast(client, diagnostic) {
+    try {
+        appendFileSync(debugLogPath(defaultConfigDir()), `${new Date().toISOString()} ${diagnostic.level.toUpperCase()}: ${diagnostic.message}\n`);
+    }
+    catch {
+        // Diagnostics should never affect startup.
+    }
+    if (diagnostic.level === "info")
+        return;
+    await client.tui?.showToast?.({
+        body: {
+            title: diagnostic.level === "error" ? "Agent variant skipped" : "Agent variant disabled",
+            message: diagnostic.message,
+            variant: diagnostic.level === "error" ? "error" : "warning",
+            duration: 15000,
+        },
+    }).catch(() => undefined);
+}
+function applyRequestPatch(output, patch) {
+    if (patch.temperature !== undefined)
+        output.temperature = patch.temperature;
+    if (patch.top_p !== undefined)
+        output.topP = patch.top_p;
+    if (patch.options !== undefined)
+        Object.assign(output.options, patch.options);
+}
+function applySystemPatch(system, patch, context) {
+    if (!hasPromptPatch(patch))
+        return;
+    const current = system[0] ?? "";
+    system[0] = applyPromptPatch(current, patch, context);
+}
+function annotateTaskOutput(text, route) {
+    const annotated = text.replace(/^<task\b([^>]*)>/, `<task$1 agent_variant="${attr(route.alias)}" routed_agent="${attr(route.parent)}" effective_model="${attr(routeModel(route))}" model_variant="${attr(route.variant ?? "default")}">`);
+    if (annotated !== text)
+        return annotated;
+    return [`<agent_variant alias="${attr(route.alias)}" routed_agent="${attr(route.parent)}" effective_model="${attr(routeModel(route))}" model_variant="${attr(route.variant ?? "default")}" />`, text].join("\n");
+}
+const plugin = async (input) => {
+    const sidecar = loadSidecar(defaultSidecarPath());
+    let virtualRoutes = new Map();
+    let parentPromptPatches = new Map();
+    let parentRequestPatches = new Map();
+    const pending = [];
+    const tokenRoutes = new Map();
+    const bySession = new Map();
+    const byCall = new Map();
+    return {
+        config: async (cfg) => {
+            const assembled = assembleAgents(cfg, sidecar);
+            virtualRoutes = assembled.virtualRoutes;
+            parentPromptPatches = assembled.parentPromptPatches;
+            parentRequestPatches = assembled.parentRequestPatches;
+            for (const diagnostic of assembled.diagnostics)
+                await warningToast(input.client, diagnostic);
+        },
+        "tool.execute.before": async (hookInput, output) => {
+            if (hookInput.tool !== "task")
+                return;
+            const args = output.args;
+            if (!args?.subagent_type || !args.prompt)
+                return;
+            const route = virtualRoutes.get(args.subagent_type);
+            if (!route)
+                return;
+            cleanupPending(pending, tokenRoutes);
+            const token = randomUUID();
+            tokenRoutes.set(token, route);
+            byCall.set(hookInput.callID, route);
+            pending.push({
+                ...route,
+                token,
+                parentSessionID: hookInput.sessionID,
+                targetAgent: route.parent,
+                fingerprint: fingerprint({
+                    parentSessionID: hookInput.sessionID,
+                    agent: route.parent,
+                    prompt: args.prompt,
+                    description: args.description,
+                }),
+                createdAt: Date.now(),
+            });
+            args.prompt = `${args.prompt}\n\n${marker(token)}`;
+            args.subagent_type = route.parent;
+            await debugToast(input.client, sidecar.debug, "Agent variant routed", `${routeSummary(route)}; token=${token.slice(0, 8)}`);
+        },
+        "tool.execute.after": async (hookInput, output) => {
+            if (hookInput.tool !== "task")
+                return;
+            const route = byCall.get(hookInput.callID);
+            if (!route)
+                return;
+            byCall.delete(hookInput.callID);
+            output.title = `${output.title} (@${route.alias} variant)`;
+            output.metadata = {
+                ...output.metadata,
+                agentVariant: {
+                    alias: route.alias,
+                    routedAgent: route.parent,
+                    effectiveModel: routeModel(route),
+                    modelVariant: route.variant ?? "default",
+                },
+                model: splitModelRef(route.model) ?? output.metadata?.model,
+            };
+            output.output = annotateTaskOutput(output.output, route);
+            await debugToast(input.client, sidecar.debug, "Agent variant result annotated", routeSummary(route));
+        },
+        "chat.message": async (hookInput, output) => {
+            const markerRoute = takeMarkerRoute(output.parts, tokenRoutes);
+            if (markerRoute) {
+                removePendingToken(pending, markerRoute.token);
+                bySession.set(hookInput.sessionID, markerRoute.route);
+                const model = splitModelRef(markerRoute.route.model);
+                if (model) {
+                    output.message.model = {
+                        providerID: model.providerID,
+                        modelID: model.modelID,
+                    };
+                    if (markerRoute.route.variant)
+                        output.message.model.variant = markerRoute.route.variant;
+                }
+                else if (markerRoute.route.variant) {
+                    output.message.model.variant = markerRoute.route.variant;
+                }
+                await debugToast(input.client, sidecar.debug, "Agent variant model applied", `${routeSummary(markerRoute.route)}; session=${hookInput.sessionID}; token=${markerRoute.token.slice(0, 8)}`);
+                return;
+            }
+            const session = await getSession(input.client, hookInput.sessionID);
+            const fp = fingerprint({
+                parentSessionID: session?.parentID ?? "",
+                agent: output.message.agent,
+                prompt: textFromParts(output.parts),
+            });
+            const route = takePending(pending, {
+                parentSessionID: session?.parentID,
+                agent: output.message.agent,
+                fingerprint: fp,
+            });
+            if (!route)
+                return;
+            bySession.set(hookInput.sessionID, route);
+            const model = splitModelRef(route.model);
+            if (model) {
+                output.message.model = {
+                    providerID: model.providerID,
+                    modelID: model.modelID,
+                };
+                if (route.variant)
+                    output.message.model.variant = route.variant;
+            }
+            else if (route.variant) {
+                output.message.model.variant = route.variant;
+            }
+            await debugToast(input.client, sidecar.debug, "Agent variant model applied (fallback)", `${routeSummary(route)}; session=${hookInput.sessionID}`);
+        },
+        "chat.params": async (hookInput, output) => {
+            const routed = bySession.get(hookInput.sessionID);
+            const parent = parentRequestPatches.get(hookInput.agent);
+            if (parent)
+                applyRequestPatch(output, parent);
+            if (routed)
+                applyRequestPatch(output, routed.patch);
+        },
+        "experimental.chat.system.transform": async (hookInput, output) => {
+            if (!hookInput.sessionID)
+                return;
+            const routed = bySession.get(hookInput.sessionID);
+            if (routed) {
+                const parent = parentPromptPatches.get(routed.parent);
+                if (parent)
+                    applySystemPatch(output.system, parent, templateContext(routed.parent, undefined, {}, sidecar));
+                applySystemPatch(output.system, routed.patch, templateContext(routed.parent, routed.key, routed.patch, sidecar));
+                return;
+            }
+            const session = await getSession(input.client, hookInput.sessionID);
+            const parent = session?.agent ? parentPromptPatches.get(session.agent) : undefined;
+            if (parent && session?.agent)
+                applySystemPatch(output.system, parent, templateContext(session.agent, undefined, {}, sidecar));
+        },
+    };
+};
+export default plugin;

package/dist/server.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    id: string;
+    server: import("@opencode-ai/plugin").Plugin;
+};
+export default _default;

package/dist/server.js

@@ -0,0 +1,5 @@
+import plugin from "./index.js";
+export default {
+    id: "agent-variants",
+    server: plugin,
+};

package/dist/tui.d.ts

@@ -0,0 +1,6 @@
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+declare const _default: {
+    id: string;
+    tui: TuiPlugin;
+};
+export default _default;