@bubblebrain-ai/bubble 0.0.63 → 0.0.65

package/dist/prompt/environment.js

@@ -0,0 +1,55 @@
+import { cwd } from "node:process";
+export const defaultToolSnippets = {
+    read: "Read the contents of a file",
+    bash: "Execute a bash command",
+    edit: "Apply targeted string replacements to a file",
+    write: "Write a new file or overwrite an existing one",
+    ls: "List directory contents, including hidden files and subdirectories",
+    grep: "Search file contents using regex",
+    web_search: "Search the public web for current information",
+    web_fetch: "Fetch and extract the contents of a specific webpage",
+    spawn_agent: "Start a child subagent thread and return its agent id plus nickname",
+    wait_agent: "Wait for one or more spawned subagents to finish",
+    send_input: "Send follow-up input to an existing subagent thread",
+    question: "Ask the user structured questions when clarification or preference choices would materially improve the work",
+    skill_search: "Search available skills by name, description, tags, and source",
+    skill: "Load a named skill with specialized instructions and bundled resources",
+};
+export const defaultToolNames = [
+    "read",
+    "ls",
+    "bash",
+    "edit",
+    "write",
+    "grep",
+    "web_search",
+    "web_fetch",
+    "spawn_agent",
+    "wait_agent",
+    "send_input",
+    "question",
+    "skill_search",
+    "skill",
+];
+export function buildEnvironmentPrompt(options = {}) {
+    const configuredProvider = options.configuredProvider ?? "unknown";
+    const configuredModel = options.configuredModel ?? "unknown";
+    const configuredModelId = options.configuredModelId ?? "unknown";
+    const workingDir = options.workingDir ?? cwd().replace(/\\/g, "/");
+    const currentDate = options.currentDate ?? new Date().toISOString().slice(0, 10);
+    const tools = options.tools ?? defaultToolNames;
+    const snippets = { ...defaultToolSnippets, ...(options.toolSnippets ?? {}) };
+    const visibleTools = tools.filter((name) => snippets[name]);
+    const toolList = visibleTools.length > 0
+        ? visibleTools.map((name) => `- ${name}: ${snippets[name]}`).join("\n")
+        : "(none)";
+    return `Configured provider: ${configuredProvider}
+Configured model: ${configuredModel}
+Configured model id: ${configuredModelId}
+
+Available tools:
+${toolList}
+
+Current date: ${currentDate}
+Current working directory: ${workingDir}`;
+}

package/dist/prompt/provider-prompts/anthropic.d.ts

@@ -0,0 +1 @@
+export declare function buildAnthropicProviderPrompt(agentName: string): string;

package/dist/prompt/provider-prompts/anthropic.js

@@ -0,0 +1,5 @@
+export function buildAnthropicProviderPrompt(agentName) {
+    return `You are ${agentName}, a careful coding assistant operating in a terminal workspace.
+
+Reason step by step when needed, but keep visible responses concise. Use tools to ground decisions in the codebase and avoid guessing about file contents or command output.`;
+}

package/dist/prompt/provider-prompts/codex.d.ts

@@ -0,0 +1 @@
+export declare function buildCodexProviderPrompt(agentName: string): string;

package/dist/prompt/provider-prompts/codex.js

@@ -0,0 +1,5 @@
+export function buildCodexProviderPrompt(agentName) {
+    return `You are ${agentName}, a terminal-native coding assistant optimized for iterative coding work.
+
+Focus on concrete progress: inspect the repository, use tools deliberately, keep answers short, and preserve momentum across tool calls and follow-up turns.`;
+}

package/dist/prompt/provider-prompts/deepseek.d.ts

@@ -0,0 +1 @@
+export declare function buildDeepSeekProviderPrompt(agentName: string): string;

package/dist/prompt/provider-prompts/deepseek.js

@@ -0,0 +1,7 @@
+export function buildDeepSeekProviderPrompt(agentName) {
+    return `You are ${agentName}, a direct coding agent running on a DeepSeek model.
+
+Prefer short plans followed by concrete tool use. Avoid broad speculation.
+After each tool result, update your understanding before choosing the next action.
+Do not repeat equivalent searches unless the previous result changed the search space.`;
+}

package/dist/prompt/provider-prompts/default.d.ts

@@ -0,0 +1 @@
+export declare function buildDefaultProviderPrompt(agentName: string): string;

package/dist/prompt/provider-prompts/default.js

@@ -0,0 +1,6 @@
+export function buildDefaultProviderPrompt(agentName) {
+    return `You are ${agentName}, an expert coding assistant operating in a terminal environment.
+
+Work directly, stay concise, and prefer concrete actions over abstract discussion.
+Use the available tools to inspect files, run commands, edit code, and verify results.`;
+}

package/dist/prompt/provider-prompts/gemini.d.ts

@@ -0,0 +1 @@
+export declare function buildGeminiProviderPrompt(agentName: string): string;

package/dist/prompt/provider-prompts/gemini.js

@@ -0,0 +1,5 @@
+export function buildGeminiProviderPrompt(agentName) {
+    return `You are ${agentName}, a coding assistant running inside a terminal workspace.
+
+Be efficient and explicit. Prefer quick repository inspection, concise execution plans, and direct code changes supported by tool output.`;
+}

package/dist/prompt/provider-prompts/glm.d.ts

@@ -0,0 +1 @@
+export declare function buildGlmProviderPrompt(agentName: string): string;

package/dist/prompt/provider-prompts/glm.js

@@ -0,0 +1,7 @@
+export function buildGlmProviderPrompt(agentName) {
+    return `You are ${agentName}, a pragmatic coding agent running on a GLM/Z.AI model.
+
+Be specific and evidence-driven. Prefer source inspection and verification over generic recommendations.
+When debugging, identify the failing boundary before editing.
+When implementing, finish the requested change end to end and verify the relevant path.`;
+}

package/dist/prompt/provider-prompts/gpt.d.ts

@@ -0,0 +1 @@
+export declare function buildGptProviderPrompt(agentName: string): string;

package/dist/prompt/provider-prompts/gpt.js

@@ -0,0 +1,5 @@
+export function buildGptProviderPrompt(agentName) {
+    return `You are ${agentName}, a terminal-native coding assistant working with GPT-style models.
+
+Be accurate, concise, and tool-oriented. Prefer reading the codebase before making changes, keep outputs compact, and verify important edits when possible.`;
+}

package/dist/prompt/provider-prompts/kimi.d.ts

@@ -0,0 +1 @@
+export declare function buildKimiProviderPrompt(agentName: string): string;

package/dist/prompt/provider-prompts/kimi.js

@@ -0,0 +1,8 @@
+export function buildKimiProviderPrompt(agentName) {
+    return `You are ${agentName}, a terminal coding agent running on a Kimi/Moonshot model.
+
+Keep tool use disciplined: pursue one concrete hypothesis at a time, read results carefully, and converge after evidence is sufficient.
+Do not fan out into many parallel search directions unless the task truly requires it.
+
+Evidence-first project exploration: use observed filesystem evidence as the source of truth. Do not assume conventional project files or directories exist. Before reading or operating on a path, ensure it was observed, directly derived from an observed path, or explicitly provided by the user. If a path is missing, adapt to the observed structure instead of probing more conventional paths.`;
+}

package/dist/prompt/reminders.d.ts

@@ -0,0 +1,33 @@
+/**
+ * System reminders - short, runtime-variable instructions injected into the
+ * message stream as hidden meta messages.
+ *
+ * Rationale: the static system prompt is stable and cacheable. Mode transitions
+ * and other ephemeral state are signaled via reminders so we do not invalidate
+ * the prompt cache every time something changes.
+ */
+import type { PermissionMode } from "../types.js";
+export declare function wrapInSystemReminder(content: string): string;
+export declare function isPermissionModeReminder(content: unknown): boolean;
+/** Picks the correct reminder text for a transition TO a given mode. */
+export declare function reminderForMode(mode: PermissionMode): string;
+export declare const PLAN_MODE_ENTER_REMINDER: string;
+export declare const PLAN_MODE_EXIT_REMINDER: string;
+/**
+ * Announce the set of deferred tools. Their schemas are not in the tool list
+ * sent to the model — the model must call `tool_search` to load them before
+ * they can be invoked.
+ */
+export declare function buildDeferredToolsReminder(names: string[]): string;
+export declare function buildToolFreezeReminder(reason: string): string;
+/**
+ * Modified-existing-tests disclosure (docs/harness-thinning.md): a fact from
+ * git ground truth — bash writes and subagent worktree merges do not appear
+ * in the model's own tool memory. Disclosure, not accusation: legitimate
+ * test updates are normal engineering; the rule is that they must be
+ * declared, never silent.
+ */
+export declare function buildModifiedTestsDisclosure(modifiedExistingTests: Array<{
+    path: string;
+    deletedLines: number;
+}>): string;

package/dist/prompt/reminders.js

@@ -0,0 +1,135 @@
+/**
+ * System reminders - short, runtime-variable instructions injected into the
+ * message stream as hidden meta messages.
+ *
+ * Rationale: the static system prompt is stable and cacheable. Mode transitions
+ * and other ephemeral state are signaled via reminders so we do not invalidate
+ * the prompt cache every time something changes.
+ */
+export function wrapInSystemReminder(content) {
+    return content.trim();
+}
+/**
+ * Headlines of the mode reminders below. Identity is content-based because a
+ * reminder is just text once it lands in the message stream; keeping the
+ * headlines in one place stops the matcher from drifting when the bodies are
+ * reworded.
+ */
+const MODE_REMINDER_HEADLINES = [
+    "Plan mode is now ACTIVE",
+    "Permission mode is now: bypassPermissions",
+    "Permission mode is now: default Build mode",
+];
+export function isPermissionModeReminder(content) {
+    if (typeof content !== "string")
+        return false;
+    return MODE_REMINDER_HEADLINES.some((headline) => content.includes(headline));
+}
+const PLAN_MODE_ENTER = `
+Plan mode is now ACTIVE.
+
+Rules while in plan mode:
+- Only read-only tools are allowed, including read, ls, grep, web_search, web_fetch, spawn_agent, wait_agent, send_input, skill_search, skill, tool_search, question, and exit_plan_mode.
+- Writes, edits, and shell commands WILL be rejected by the harness; do not try them.
+- Do not edit files or claim implementation is complete while plan mode is active.
+- Investigate the codebase, then use the question tool to clarify important ambiguities, tradeoffs, requirements, or preference choices that would materially change the plan.
+- Call exit_plan_mode with a concrete step-by-step plan after the important questions are resolved.
+- Do not use the question tool to ask whether the plan is approved; exit_plan_mode is the approval step.
+- The user will approve, edit, or reject your plan. On approval the harness switches back to default mode and you may execute.
+- On rejection, remain in plan mode and iterate.
+`;
+const BYPASS_ENTER = `
+Permission mode is now: bypassPermissions.
+
+This replaces every earlier mode reminder in this conversation. Plan mode is NOT active; exit_plan_mode does not exist in your tool list and must not be called or searched for.
+ALL tool calls auto-approve with no user confirmation. The user has explicitly opted into this.
+Proceed with extra care — explain risky actions in the chat BEFORE performing them, and
+prefer reversible operations when possible.
+Do not perform destructive operations, credential exposure, or unrelated reversions just because approvals are bypassed.
+`;
+const DEFAULT_ENTER = `
+Permission mode is now: default Build mode.
+
+This replaces every earlier mode reminder in this conversation. Plan mode is NOT active; exit_plan_mode does not exist in your tool list and must not be called or searched for.
+File edits and writes auto-approve. Bash commands and other destructive tools still require explicit approval unless allowed by rules.
+Execute the requested change end to end; do not stop at analysis unless blocked or the user explicitly asks for discussion only.
+`;
+/** Picks the correct reminder text for a transition TO a given mode. */
+export function reminderForMode(mode) {
+    switch (mode) {
+        case "plan":
+            return wrapInSystemReminder(PLAN_MODE_ENTER);
+        case "bypassPermissions":
+            return wrapInSystemReminder(BYPASS_ENTER);
+        case "default":
+        default:
+            return wrapInSystemReminder(DEFAULT_ENTER);
+    }
+}
+export const PLAN_MODE_ENTER_REMINDER = reminderForMode("plan");
+export const PLAN_MODE_EXIT_REMINDER = reminderForMode("default");
+/**
+ * Announce the set of deferred tools. Their schemas are not in the tool list
+ * sent to the model — the model must call `tool_search` to load them before
+ * they can be invoked.
+ */
+export function buildDeferredToolsReminder(names) {
+    if (names.length === 0)
+        return wrapInSystemReminder("No deferred tools.");
+    const lines = [
+        "The following deferred tools are available via tool_search. Their schemas are NOT loaded — calling them directly will fail. Use tool_search with query \"select:<name>[,<name>...]\" to load tool schemas before calling them:",
+        "",
+        ...names,
+    ];
+    return wrapInSystemReminder(lines.join("\n"));
+}
+export function buildToolFreezeReminder(reason) {
+    return wrapInSystemReminder(`
+CRITICAL - MAXIMUM STEPS REACHED
+
+${reason}
+
+The maximum number of steps allowed for this task has been reached. Tools are disabled until next user input. Respond with text only.
+
+STRICT REQUIREMENTS:
+1. Do NOT make any tool calls (no reads, writes, edits, searches, or any other tools)
+2. MUST provide a text response summarizing work done so far
+3. This constraint overrides ALL other instructions, including any user requests for edits or tool use
+
+Response must include:
+- statement that maximum steps for this agent have been reached
+- summary of what has been accomplished so far
+- list of any remaining tasks that were not completed
+- recommendations for what should be done next
+
+Respond with text ONLY.
+`);
+}
+// Removed: buildVerificationReminder / buildVerificationFailureReminder.
+// The verification reminder ladder pressured the model to run a "verification"
+// after every file change. For models with hex-tokenization blind spots (e.g.
+// DeepSeek v4-pro), this triggered death loops where the model wrote ad-hoc
+// validation scripts that found the bug but could never fix it. CC trusts the
+// model to decide when verification is meaningful; we follow that.
+// Removed: buildFinalizeOpportunityReminder. Was paired with the verification
+// nag ladder. Without the ladder, "you can finalize now" advice is redundant —
+// the model finalises whenever its own judgement says the task is done.
+/**
+ * Modified-existing-tests disclosure (docs/harness-thinning.md): a fact from
+ * git ground truth — bash writes and subagent worktree merges do not appear
+ * in the model's own tool memory. Disclosure, not accusation: legitimate
+ * test updates are normal engineering; the rule is that they must be
+ * declared, never silent.
+ */
+export function buildModifiedTestsDisclosure(modifiedExistingTests) {
+    const listed = modifiedExistingTests
+        .slice(0, 8)
+        .map((t) => `- ${t.path}${t.deletedLines > 0 ? ` (${t.deletedLines} line${t.deletedLines === 1 ? "" : "s"} removed)` : ""}`)
+        .join("\n");
+    return wrapInSystemReminder(`
+Fact from git: this run modified pre-existing test files:
+${listed}${modifiedExistingTests.length > 8 ? `\n- …and ${modifiedExistingTests.length - 8} more` : ""}
+
+If a change you made caused an existing test to fail and you edited the test so the suite passes, restore the original behavior instead — weakening a test to make it pass is never acceptable. If the test changes are intentional (the request requires new expected behavior, or the test itself was wrong), keep them and state each modified test and the reason in your final summary. Then finish normally.
+`);
+}

package/dist/prompt/routing.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Subagent model-routing menu for the parent agent's system prompt
+ * (docs/model-routing-design.md §4).
+ *
+ * Wording rules: the prompt must never promise more enforcement than the
+ * runtime delivers at any later moment. Absolute "choose only from this
+ * list" wording is used only for a models.json allowlist (the one catalog
+ * that cannot silently expire); every other membership source gets the
+ * conservative lag disclaimer, matching §7.1's warn-and-allow validation.
+ * Gated on spawn_agent alongside the delegation policy — children never
+ * see it.
+ */
+import type { AgentRoutingConfig, RoutingSnapshot } from "../agent/routing-catalog.js";
+export declare function buildModelRoutingPrompt(snapshot: RoutingSnapshot, agentRouting: AgentRoutingConfig): string;

package/dist/prompt/routing.js

@@ -0,0 +1,71 @@
+/**
+ * Subagent model-routing menu for the parent agent's system prompt
+ * (docs/model-routing-design.md §4).
+ *
+ * Wording rules: the prompt must never promise more enforcement than the
+ * runtime delivers at any later moment. Absolute "choose only from this
+ * list" wording is used only for a models.json allowlist (the one catalog
+ * that cannot silently expire); every other membership source gets the
+ * conservative lag disclaimer, matching §7.1's warn-and-allow validation.
+ * Gated on spawn_agent alongside the delegation policy — children never
+ * see it.
+ */
+const MENU_MODEL_LIMIT = 12;
+export function buildModelRoutingPrompt(snapshot, agentRouting) {
+    const lines = ["## Subagent model routing"];
+    const parentTier = snapshot.parent.tier ? ` (${snapshot.parent.tier} tier)` : "";
+    lines.push(`Parent model: ${snapshot.parent.providerId} ${snapshot.parent.model}${parentTier}.`);
+    const categories = snapshot.resolvedCategories
+        .map((category) => {
+        const effort = category.thinkingLevel ? ` + ${category.thinkingLevel}` : "";
+        return `${category.name} → ${category.model}${effort}`;
+    })
+        .join(" · ");
+    if (categories) {
+        lines.push("Categories (category → what a spawn actually gets):");
+        lines.push(`  ${categories}`);
+    }
+    // Tiered models first, then untiered; cap with an explicit remainder note
+    // so truncation never reads as "nothing else exists".
+    const ordered = [...snapshot.models].sort((a, b) => {
+        const aTiered = a.tier ? 0 : 1;
+        const bTiered = b.tier ? 0 : 1;
+        return aTiered - bTiered;
+    });
+    const shown = ordered.slice(0, MENU_MODEL_LIMIT);
+    const remainder = ordered.length - shown.length;
+    const modelList = shown
+        .map((model) => (model.tier ? `${model.id} (${model.tier})` : model.id))
+        .join(" · ");
+    if (modelList) {
+        lines.push("Models on this provider, usable via per-call `model`:");
+        lines.push(`  ${modelList}`);
+        if (remainder > 0) {
+            lines.push(snapshot.authoritative
+                ? `  … and ${remainder} more in the configured allowlist (not shown); ids outside the allowlist are rejected.`
+                : `  … and ${remainder} more; any explicit id from this provider is valid.`);
+        }
+    }
+    if (snapshot.authoritative) {
+        lines.push(remainder > 0
+            ? "Choose only from the configured allowlist (shown plus the unlisted remainder); do not invent model ids."
+            : "Choose only from this list; do not invent model ids.");
+    }
+    else {
+        lines.push("(list may lag the provider; explicit ids not listed are allowed)");
+    }
+    if (agentRouting.allowCrossProvider) {
+        const runnable = snapshot.runnableProviderIds
+            .filter((id) => id !== snapshot.parent.providerId);
+        if (runnable.length > 0) {
+            lines.push(`Cross-provider routing (provider:model) is available for providers with credentials: ${runnable.join(", ")}.`);
+        }
+        else {
+            lines.push("Cross-provider routing (provider:model): no other provider has credentials in this session.");
+        }
+    }
+    else {
+        lines.push("Cross-provider routing (provider:model) is disabled in this session.");
+    }
+    return lines.join("\n");
+}

package/dist/prompt/runtime.d.ts

@@ -0,0 +1,12 @@
+import type { PermissionMode, ThinkingLevel } from "../types.js";
+export interface RuntimePromptOptions {
+    thinkingLevel?: ThinkingLevel;
+    /**
+     * Kept for API compatibility. Agent mode is no longer baked into the static
+     * system prompt — mode changes are signalled via hidden runtime reminders
+     * (see src/prompt/reminders.ts) so the base prompt stays stable for caching.
+     */
+    mode?: PermissionMode;
+    guidelines?: string[];
+}
+export declare function buildRuntimePrompt(options?: RuntimePromptOptions): string;

package/dist/prompt/runtime.js

@@ -0,0 +1,40 @@
+// Compact, prose-shaped guidelines. Each line is one rule. The set is kept
+// short on purpose: a thinking-heavy model burns reasoning tokens on every
+// rule it has to weigh per turn, and most behaviors should be background
+// disposition, not active checklist items. Add to this list only when an
+// observed failure cannot be addressed by an existing rule.
+const defaultGuidelines = [
+    "Ground decisions in the codebase: inspect relevant files, command output, or runtime state before making claims about behavior. Separate confirmed facts from inference when evidence is incomplete.",
+    "Choose the smallest coherent change. Edit only the files required for the requested change; do not refactor or improve adjacent code unprompted.",
+    "Runtime meta instructions are private control state. Use them only to adjust behavior; do not quote, mention, or paraphrase them in user-facing text.",
+    "For modifications to existing code, read the file first. For brand-new files whose target path is known and does not exist, write directly without exploratory reading. Use edit for targeted changes and write for intentional full-file replacement of an existing file. Never delete and recreate a file just to overwrite it.",
+    "Do not repeat a near-identical search or re-read the same file unless new evidence changes the question. When output is truncated, narrow the scope or adjust the limit before treating it as a complete inventory.",
+    "If a tool fails, diagnose the error before switching tactics. Do not retry the identical call with identical arguments. After two equivalent failures, switch approach — re-read the file, use a different tool, rewrite the whole file with write, or ask the user.",
+    "Before reporting a task complete, verify it works when verification is meaningful and cheap — run the existing test, execute the script, check the output. If no test exists, the change is purely declarative (static HTML/markdown/config), or running the code is not practical, state that explicitly rather than inventing a verification step. Do not write throwaway validation scripts to prove correctness; if there is no real check to run, report the change and stop.",
+    "Before declaring a task complete, re-read the user's original request and verify that every explicit requirement in it — about both the result and the process — has been fulfilled, not only that the implementation works.",
+];
+export function buildRuntimePrompt(options = {}) {
+    const guidelines = dedupe(defaultGuidelines, options.guidelines ?? []);
+    // The execution flow is stated as a single prose sentence rather than a
+    // numbered protocol. Numbered checklists prompt thinking models to walk
+    // each step explicitly in their reasoning every turn, even for trivial
+    // tasks — multiplying latency without improving quality. Prose lets the
+    // protocol act as background disposition.
+    return `Work by understanding the requested outcome, grounding decisions in the codebase, making the smallest coherent change, and verifying when possible. Scale your effort to the task: a one-file create-or-edit deserves direct execution, not extensive pre-exploration.
+
+Guidelines:
+${guidelines.map((item) => `- ${item}`).join("\n")}`;
+}
+function dedupe(...groups) {
+    const seen = new Set();
+    const result = [];
+    for (const group of groups) {
+        for (const item of group) {
+            if (!seen.has(item)) {
+                seen.add(item);
+                result.push(item);
+            }
+        }
+    }
+    return result;
+}

package/dist/prompt/task-reminders.d.ts

@@ -0,0 +1,12 @@
+import { type RoutableModelEntry } from "../agent/routing-catalog.js";
+/**
+ * User-named model resolution (model-routing design v3.6): when the user's
+ * message names a model that exists in the routable catalog, hand the main
+ * agent the EXACT provider:model id at the decision point. The catalog is a
+ * closed set, so matching is deterministic — the model must never retype an
+ * id from priors when the harness can resolve it ("gpt 5.6 sol" ->
+ * openai:gpt-5.6-sol; a Grok-4.5 parent invented "openai:gpt-5.6" without
+ * this, 2026-07-12 live case). Silent on no match: zero standing noise.
+ */
+export declare function userNamedModelReminder(input: string | import("../types.js").ContentPart[], routableModels: RoutableModelEntry[] | undefined, canSpawn: boolean): string | undefined;
+export declare function orchestrationRequestReminder(input: string | import("../types.js").ContentPart[], canRunWorkflow: boolean): string | undefined;

package/dist/prompt/task-reminders.js

@@ -0,0 +1,64 @@
+import { normalizeModelToken } from "../agent/routing-catalog.js";
+/**
+ * User-named model resolution (model-routing design v3.6): when the user's
+ * message names a model that exists in the routable catalog, hand the main
+ * agent the EXACT provider:model id at the decision point. The catalog is a
+ * closed set, so matching is deterministic — the model must never retype an
+ * id from priors when the harness can resolve it ("gpt 5.6 sol" ->
+ * openai:gpt-5.6-sol; a Grok-4.5 parent invented "openai:gpt-5.6" without
+ * this, 2026-07-12 live case). Silent on no match: zero standing noise.
+ */
+export function userNamedModelReminder(input, routableModels, canSpawn) {
+    if (!canSpawn || !routableModels || routableModels.length === 0)
+        return undefined;
+    const text = typeof input === "string"
+        ? input
+        : input.map((part) => ("text" in part ? String(part.text ?? "") : "")).join(" ");
+    if (!text.trim())
+        return undefined;
+    const normalizedInput = normalizeModelToken(text);
+    // Group by model id so multi-provider models (glm-5.2 on four providers)
+    // produce one line listing the routable providers.
+    const hitsByModel = new Map();
+    for (const entry of routableModels) {
+        const keys = [normalizeModelToken(entry.id), normalizeModelToken(entry.name)];
+        // Short keys ("o1", "glm") would match prose; require some substance.
+        if (!keys.some((key) => key.length >= 5 && normalizedInput.includes(key)))
+            continue;
+        const hit = hitsByModel.get(entry.id);
+        if (hit) {
+            if (!hit.providerIds.includes(entry.providerId))
+                hit.providerIds.push(entry.providerId);
+        }
+        else {
+            hitsByModel.set(entry.id, { entry, providerIds: [entry.providerId] });
+        }
+    }
+    if (hitsByModel.size === 0)
+        return undefined;
+    const lines = [...hitsByModel.values()].slice(0, 6).map(({ entry, providerIds }) => {
+        const primary = `${providerIds[0]}:${entry.id}`;
+        const alternates = providerIds.length > 1 ? ` (also on: ${providerIds.slice(1).join(", ")})` : "";
+        return `- "${entry.name}" → ${primary}${alternates}`;
+    });
+    return [
+        "The user's message names these configured models. Exact routable ids:",
+        ...lines,
+        "Use these exact ids in spawn_agent / run_workflow `model` params; do not retype model ids from memory.",
+    ].join("\n");
+}
+const ORCHESTRATION_REQUEST = /\b(?:workflows?|orchestrat\w*|agent[ -]?teams?|fan[ -]?out)\b|工作流|编排|(?:智能体|代理|agent)\s*(?:团队|小队)/i;
+export function orchestrationRequestReminder(input, canRunWorkflow) {
+    if (!canRunWorkflow)
+        return undefined;
+    const text = typeof input === "string"
+        ? input
+        : input.map((part) => ("text" in part ? String(part.text ?? "") : "")).join(" ");
+    if (!ORCHESTRATION_REQUEST.test(text))
+        return undefined;
+    return [
+        "- This message explicitly asks for a coordinated multi-agent run (a workflow / orchestration / agent team).",
+        "Honor it with ONE run_workflow call whose script covers the whole fan-out.",
+        "Do not substitute parallel spawn_agent calls this turn — the user named the mechanism.",
+    ].join(" ");
+}

package/dist/provider-ai-sdk.d.ts

@@ -0,0 +1,59 @@
+/**
+ * AI SDK provider backend ("ai-sdk" protocol).
+ *
+ * Consumes AI SDK provider packages at the LanguageModelV3 spec layer
+ * (`model.doStream`) rather than through the high-level `streamText` API:
+ * pre-stream HTTP errors throw natively (which our retry/rate-limit contract
+ * needs), tool-call inputs arrive as JSON strings (matching `argumentsFull`),
+ * and no step machinery or extra dependencies come along.
+ *
+ * Registered providers: google (Gemini native API). Adding another AI SDK
+ * provider is one entry in AI_SDK_PROVIDER_FACTORIES.
+ */
+import { type ProviderFetch } from "./network/provider-transport.js";
+import type { Provider, ReasoningEffort, ThinkingLevel } from "./types.js";
+export interface AiSdkProviderOptions {
+    providerId?: string;
+    apiKey: string;
+    baseURL?: string;
+    thinkingLevel?: ThinkingLevel;
+    /** User-configured extra headers, merged last (client-identity gates). */
+    headers?: Record<string, string>;
+    /** Transport override for tests; defaults to the shared provider fetch. */
+    fetch?: ProviderFetch;
+}
+export declare function isAiSdkProviderId(providerId: string | undefined): boolean;
+export declare function createAiSdkProvider(options: AiSdkProviderOptions): Provider;
+export interface GeminiModelDescriptor {
+    id: string;
+    name: string;
+    contextWindow?: number;
+    reasoningLevels: ReasoningEffort[];
+    defaultReasoningLevel?: ReasoningEffort;
+}
+interface GeminiModelListEntry {
+    name?: string;
+    displayName?: string;
+    inputTokenLimit?: number;
+    supportedGenerationMethods?: string[];
+}
+/**
+ * Fetch Google's model list and keep the newest general-purpose text models.
+ * Newly released Gemini versions appear without a catalog change; the static
+ * BUILTIN_MODELS entries stay as the offline/no-key fallback.
+ */
+export declare function fetchGeminiModels(options: {
+    apiKey: string;
+    baseURL?: string;
+    fetch?: ProviderFetch;
+    limit?: number;
+}): Promise<GeminiModelDescriptor[]>;
+/**
+ * Ranking: one entry per (version, tier) family — GA ids beat dated previews —
+ * then newest version first, pro/argon before carbon before hydrogen before
+ * flash before flash-lite, top N.
+ */
+export declare function selectLatestGeminiModels(entries: GeminiModelListEntry[], limit?: number): GeminiModelDescriptor[];
+/** Mirrors the static catalog's per-family thinking support. */
+export declare function geminiReasoningLevels(modelId: string): ReasoningEffort[];
+export {};