gsd-pi 2.75.0 → 2.76.0-dev.b072ebb73

package/dist/resources/extensions/remote-questions/commands.js

@@ -0,0 +1,380 @@
+/**
+ * Telegram Command Handler
+ *
+ * Handles slash-commands sent by the user via Telegram chat:
+ *   /help     — list all commands
+ *   /status   — current auto-mode state (milestone, unit, cost)
+ *   /progress — roadmap overview (done / open milestones)
+ *   /budget   — token and cost usage this session
+ *   /pause    — pause auto-mode via a stop capture
+ *   /resume   — clear pending stop captures so auto-mode can proceed
+ *   /log [n]  — last n activity log entries (default: 5)
+ *
+ * Only Telegram is supported here. Other channels (Slack, Discord) use
+ * webhook models and do not share the same polling loop.
+ */
+import { existsSync, readdirSync, statSync, readFileSync } from "node:fs";
+import { join, basename } from "node:path";
+// ─── Command Detection ────────────────────────────────────────────────────────
+/**
+ * Returns true when the message text is a bot command (starts with `/`
+ * followed by at least one word character).
+ */
+export function isCommand(text) {
+    return /^\/\w/.test(text);
+}
+// ─── Dispatch ─────────────────────────────────────────────────────────────────
+/**
+ * Parse and execute a Telegram command.
+ *
+ * @param text   Raw message text, e.g. "/log 10"
+ * @param sender Interface used to reply into the chat
+ * @param basePath Project root (process.cwd() in normal operation)
+ */
+export async function handleCommand(text, sender, basePath) {
+    const [rawCmd, ...argParts] = text.trim().split(/\s+/);
+    const cmd = (rawCmd ?? "").toLowerCase();
+    const args = argParts.join(" ");
+    switch (cmd) {
+        case "/help":
+            await sender.send(withProject(basePath, buildHelp()));
+            break;
+        case "/status":
+            await sender.send(withProject(basePath, await buildStatus(basePath)));
+            break;
+        case "/progress":
+            await sender.send(withProject(basePath, await buildProgress(basePath)));
+            break;
+        case "/budget":
+            await sender.send(withProject(basePath, await buildBudget(basePath)));
+            break;
+        case "/pause":
+            await sender.send(withProject(basePath, await buildPause(basePath)));
+            break;
+        case "/resume":
+            await sender.send(withProject(basePath, await buildResume(basePath)));
+            break;
+        case "/log":
+            await sender.send(withProject(basePath, buildLog(basePath, args)));
+            break;
+        default:
+            await sender.send(withProject(basePath, buildUnknown(cmd)));
+    }
+}
+// ─── Project Prefix Helper ────────────────────────────────────────────────────
+function withProject(basePath, body) {
+    const name = basename(basePath);
+    return `📁 ${name}\n\n${body}`;
+}
+// ─── Command Builders ─────────────────────────────────────────────────────────
+function buildHelp() {
+    return [
+        "GSD Remote Commands:",
+        "",
+        "/status   — current milestone, unit, and cost",
+        "/progress — roadmap overview (done / open milestones)",
+        "/budget   — token and cost usage this session",
+        "/pause    — pause auto-mode after the current unit",
+        "/resume   — clear pause directive so auto-mode continues",
+        "/log <n>  — last n activity log entries (default: 5)",
+        "/help     — show this message",
+    ].join("\n");
+}
+function buildUnknown(cmd) {
+    return `Unknown command: ${cmd}\n\nType /help to see available commands.`;
+}
+// ─── /status ─────────────────────────────────────────────────────────────────
+/**
+ * Build the /status reply.
+ *
+ * NOTE: basePath only controls disk-based fallbacks (e.g. reading paused-session.json).
+ * In-process module resolution via dynamic import() is fixed at build time by ESM
+ * semantics and is unaffected by basePath.
+ */
+async function buildStatus(basePath) {
+    let autoData = null;
+    try {
+        const autoMod = await tryImportModule("../gsd/auto.js");
+        if (autoMod) {
+            autoData = autoMod.getAutoDashboardData();
+        }
+    }
+    catch {
+        // auto.ts not loaded or available — fall through to disk-based status
+    }
+    const lines = ["GSD Status"];
+    lines.push("");
+    if (autoData && (autoData.active || autoData.paused)) {
+        // In-process auto-mode is active or paused — use live data
+        lines.push(autoData.active ? "State: running" : "State: paused");
+        if (autoData.currentUnit) {
+            lines.push(`Unit:  ${autoData.currentUnit.type} / ${autoData.currentUnit.id}`);
+        }
+        if (autoData.totalCost > 0) {
+            lines.push(`Cost:  $${autoData.totalCost.toFixed(4)}`);
+        }
+        if (autoData.totalTokens > 0) {
+            lines.push(`Tokens: ${formatTokens(autoData.totalTokens)}`);
+        }
+        if (autoData.pendingCaptureCount > 0) {
+            lines.push(`Captures pending: ${autoData.pendingCaptureCount}`);
+        }
+    }
+    else {
+        // No active in-process session — check disk for a cross-process paused session
+        const pausedMeta = readPausedSession(basePath);
+        if (pausedMeta) {
+            lines.push("State: paused (from disk)");
+            if (pausedMeta.milestoneId)
+                lines.push(`Milestone: ${pausedMeta.milestoneId}`);
+            if (pausedMeta.unitType && pausedMeta.unitId) {
+                lines.push(`Unit: ${pausedMeta.unitType} / ${pausedMeta.unitId}`);
+            }
+            if (pausedMeta.pausedAt)
+                lines.push(`Paused at: ${pausedMeta.pausedAt}`);
+        }
+        else {
+            lines.push("State: idle (no active session)");
+        }
+    }
+    return lines.join("\n");
+}
+// ─── /progress ───────────────────────────────────────────────────────────────
+/**
+ * Build the /progress reply.
+ *
+ * NOTE: basePath only controls disk-based fallbacks. In-process module resolution
+ * via dynamic import() is fixed at build time by ESM semantics and is unaffected
+ * by basePath.
+ */
+async function buildProgress(basePath) {
+    const milestones = await readMilestonesFromDb();
+    if (milestones.length === 0) {
+        return "No milestones found in .gsd database.\n\nRun /gsd to start GSD first.";
+    }
+    const done = milestones.filter(m => m.status === "complete");
+    const active = milestones.filter(m => m.status === "active" || m.status === "in_progress");
+    const open = milestones.filter(m => !done.includes(m) && !active.includes(m) && m.status !== "parked");
+    const parked = milestones.filter(m => m.status === "parked");
+    const lines = ["GSD Progress"];
+    lines.push(`${done.length}/${milestones.length} milestones complete`);
+    lines.push("");
+    if (active.length > 0) {
+        lines.push("Active:");
+        for (const m of active)
+            lines.push(`  ${m.id}: ${m.title}`);
+        lines.push("");
+    }
+    if (open.length > 0) {
+        lines.push("Open:");
+        for (const m of open)
+            lines.push(`  ${m.id}: ${m.title}`);
+        lines.push("");
+    }
+    if (done.length > 0) {
+        lines.push(`Done (${done.length}):`);
+        for (const m of done)
+            lines.push(`  ${m.id}: ${m.title}`);
+        lines.push("");
+    }
+    if (parked.length > 0) {
+        lines.push(`Parked (${parked.length}):`);
+        for (const m of parked)
+            lines.push(`  ${m.id}: ${m.title}`);
+    }
+    return lines.join("\n").trimEnd();
+}
+// ─── /budget ─────────────────────────────────────────────────────────────────
+async function buildBudget(basePath) {
+    let totals = null;
+    try {
+        const metricsMod = await tryImportModule("../gsd/metrics.js");
+        if (metricsMod) {
+            const ledger = metricsMod.getLedger();
+            if (ledger) {
+                totals = metricsMod.getProjectTotals(ledger.units);
+            }
+        }
+    }
+    catch {
+        // metrics module not available — fall through to disk
+    }
+    if (!totals) {
+        totals = readMetricsFromDisk(basePath);
+    }
+    if (!totals) {
+        return "No metrics data available yet.\n\nMetrics are collected during auto-mode runs.";
+    }
+    const lines = ["GSD Budget"];
+    lines.push("");
+    lines.push(`Cost:    $${totals.cost.toFixed(4)}`);
+    lines.push(`Tokens:  ${formatTokens(totals.tokens.total)}`);
+    lines.push(`  Input:      ${formatTokens(totals.tokens.input)}`);
+    lines.push(`  Output:     ${formatTokens(totals.tokens.output)}`);
+    if (totals.tokens.cacheRead > 0) {
+        lines.push(`  Cache read: ${formatTokens(totals.tokens.cacheRead)}`);
+    }
+    lines.push(`Units:   ${totals.units}`);
+    return lines.join("\n");
+}
+// ─── /pause ──────────────────────────────────────────────────────────────────
+async function buildPause(basePath) {
+    try {
+        const capturesMod = await import("../gsd/captures.js");
+        const id = capturesMod.appendCapture(basePath, "Remote pause via Telegram /pause command");
+        capturesMod.markCaptureResolved(basePath, id, "stop", "Pause requested via Telegram", "User sent /pause command via Telegram remote channel");
+        return "Pause directive written. Auto-mode will stop after the current unit completes.";
+    }
+    catch (err) {
+        return `Failed to write pause directive: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+// ─── /resume ─────────────────────────────────────────────────────────────────
+async function buildResume(basePath) {
+    try {
+        const capturesMod = await import("../gsd/captures.js");
+        const stopCaptures = capturesMod.loadStopCaptures(basePath);
+        if (stopCaptures.length === 0) {
+            return "No pending pause directives found. Auto-mode is not paused (or paused for another reason).";
+        }
+        for (const cap of stopCaptures) {
+            capturesMod.markCaptureExecuted(basePath, cap.id);
+        }
+        return `Cleared ${stopCaptures.length} pause directive(s). Auto-mode will continue on next iteration.`;
+    }
+    catch (err) {
+        return `Failed to clear pause directives: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
+// ─── /log ─────────────────────────────────────────────────────────────────────
+function buildLog(basePath, args) {
+    const n = args.trim() ? parseInt(args.trim(), 10) : 5;
+    const count = Number.isFinite(n) && n > 0 ? Math.min(n, 50) : 5;
+    const activityDir = resolveActivityDir(basePath);
+    if (!existsSync(activityDir)) {
+        return "No activity logs found.\n\nActivity logs are created during auto-mode runs.";
+    }
+    let files = [];
+    try {
+        files = readdirSync(activityDir)
+            .filter(f => f.endsWith(".jsonl"))
+            .sort();
+    }
+    catch {
+        return "Could not read activity log directory.";
+    }
+    if (files.length === 0) {
+        return "No activity logs found.\n\nActivity logs are created during auto-mode runs.";
+    }
+    // Take the last `count` files (most recent)
+    const recent = files.slice(-count);
+    const lines = [`Last ${recent.length} activity log entries:`];
+    lines.push("");
+    for (const file of recent) {
+        const match = file.match(/^(\d+)-([\w-]+?)-(M\d[\w-]*)\.jsonl$/);
+        if (!match)
+            continue;
+        const [, seq, unitType, unitId] = match;
+        const safePath = join(activityDir, file);
+        let size = "?";
+        try {
+            const st = statSync(safePath);
+            size = formatSize(st.size);
+        }
+        catch { /* non-fatal */ }
+        lines.push(`#${seq} ${unitType} / ${unitId.replace(/-/g, "/")}  (${size})`);
+    }
+    return lines.join("\n");
+}
+// ─── Helpers: lazy dynamic imports ────────────────────────────────────────────
+// Dynamic import() is used for optional runtime modules (auto, metrics, gsd-db)
+// that have side effects and may not be present in every execution context.
+// The ESM module hook (dist-redirect.mjs) rewrites .js → .ts for test runs.
+/**
+ * Attempt a dynamic import, returning null if the module cannot be loaded.
+ * Used for optional modules like auto.js and metrics.js that may not be
+ * available outside a full GSD process context.
+ */
+async function tryImportModule(specifier) {
+    try {
+        return (await import(specifier));
+    }
+    catch {
+        return null;
+    }
+}
+async function readMilestonesFromDb() {
+    try {
+        const dbMod = await tryImportModule("../gsd/gsd-db.js");
+        return dbMod?.getAllMilestones() ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+function gsdRootPath(basePath) {
+    // Inline resolution: .gsd lives directly under basePath.
+    // Avoids importing paths.ts to keep this module's dependency surface small.
+    return join(basePath, ".gsd");
+}
+function readPausedSession(basePath) {
+    try {
+        const p = join(gsdRootPath(basePath), "runtime", "paused-session.json");
+        if (!existsSync(p))
+            return null;
+        return JSON.parse(readFileSync(p, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function readMetricsFromDisk(basePath) {
+    try {
+        const p = join(gsdRootPath(basePath), "metrics.json");
+        if (!existsSync(p))
+            return null;
+        const raw = JSON.parse(readFileSync(p, "utf-8"));
+        if (!Array.isArray(raw.units))
+            return null;
+        let cost = 0;
+        const tokens = {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            total: 0,
+        };
+        for (const u of raw.units) {
+            cost += u.cost ?? 0;
+            if (u.tokens) {
+                tokens.input += u.tokens.input ?? 0;
+                tokens.output += u.tokens.output ?? 0;
+                tokens.cacheRead += u.tokens.cacheRead ?? 0;
+                tokens.cacheWrite += u.tokens.cacheWrite ?? 0;
+                tokens.total += u.tokens.total ?? 0;
+            }
+        }
+        return { units: raw.units.length, cost, tokens };
+    }
+    catch {
+        return null;
+    }
+}
+function resolveActivityDir(basePath) {
+    return join(gsdRootPath(basePath), "activity");
+}
+// ─── Formatting helpers ───────────────────────────────────────────────────────
+function formatTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(2)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}K`;
+    return String(n);
+}
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}

package/dist/resources/extensions/remote-questions/manager.js

@@ -8,6 +8,30 @@ import { SlackAdapter } from "./slack-adapter.js";
 import { TelegramAdapter } from "./telegram-adapter.js";
 import { createPromptRecord, writePromptRecord, markPromptAnswered, markPromptDispatched, markPromptStatus, updatePromptRecord } from "./store.js";
 import { sanitizeError } from "../shared/sanitize.js";
+const COMMAND_POLLING_INTERVAL_MS = 5000;
+/**
+ * Start background polling for incoming slash commands on the configured
+ * remote channel. Only Telegram supports command polling — other channels
+ * are no-ops that return an inert cleanup function immediately.
+ *
+ * @param basePath - Project root, forwarded to command handlers (e.g. /status).
+ * @param intervalMs - Polling interval in milliseconds (default 5 s).
+ * @returns A cleanup function that stops the polling interval.
+ */
+export function startCommandPolling(basePath, intervalMs = COMMAND_POLLING_INTERVAL_MS) {
+    const config = resolveRemoteConfig();
+    if (!config || config.channel !== "telegram") {
+        // Non-Telegram channels have no command polling support — return a no-op cleanup.
+        return () => { };
+    }
+    const adapter = new TelegramAdapter(config.token, config.channelId, basePath);
+    const timer = setInterval(() => {
+        void adapter.pollAndHandleCommands(basePath).catch(() => {
+            // Non-fatal: network hiccup or rate-limit — best-effort polling
+        });
+    }, intervalMs);
+    return () => clearInterval(timer);
+}
 /**
  * Check whether a remote channel is configured without triggering any
  * side effects (no HTTP requests, no prompt records). Used by the race
@@ -16,13 +40,13 @@ import { sanitizeError } from "../shared/sanitize.js";
 export function isRemoteConfigured() {
     return resolveRemoteConfig() !== null;
 }
-export async function tryRemoteQuestions(questions, signal) {
+export async function tryRemoteQuestions(questions, signal, basePath) {
     const config = resolveRemoteConfig();
     if (!config)
         return null;
     const prompt = createPrompt(questions, config);
     writePromptRecord(createPromptRecord(prompt));
-    const adapter = createAdapter(config);
+    const adapter = createAdapter(config, basePath ?? process.cwd());
     try {
         await adapter.validate();
     }
@@ -79,11 +103,21 @@ export async function tryRemoteQuestions(questions, signal) {
             promptId: prompt.id,
             threadUrl: dispatch.ref.threadUrl ?? null,
             questions,
-            response: answer,
+            response: toRoundResultResponse(answer),
             status: "answered",
         },
     };
 }
+/** Normalize a RemoteAnswer to the RoundResult shape consumed by the gsd write-gate hook. */
+export function toRoundResultResponse(answer) {
+    const normalized = {};
+    for (const [id, data] of Object.entries(answer.answers)) {
+        const list = data.answers ?? [];
+        const selected = list.length <= 1 ? (list[0] ?? "") : list;
+        normalized[id] = { selected, notes: data.user_note ?? "" };
+    }
+    return { endInterview: false, answers: normalized };
+}
 function createPrompt(questions, config) {
     const createdAt = Date.now();
     return {
@@ -102,11 +136,11 @@ function createPrompt(questions, config) {
         })),
     };
 }
-function createAdapter(config) {
+function createAdapter(config, basePath) {
     if (config.channel === "slack")
         return new SlackAdapter(config.token, config.channelId);
     if (config.channel === "telegram")
-        return new TelegramAdapter(config.token, config.channelId);
+        return new TelegramAdapter(config.token, config.channelId, basePath);
     return new DiscordAdapter(config.token, config.channelId);
 }
 async function pollUntilDone(adapter, prompt, ref, signal) {

package/dist/resources/extensions/remote-questions/telegram-adapter.js

@@ -3,6 +3,7 @@
  */
 import { formatForTelegram, parseTelegramResponse } from "./format.js";
 import { apiRequest } from "./http-client.js";
+import { isCommand, handleCommand } from "./commands.js";
 const TELEGRAM_API = "https://api.telegram.org";
 export class TelegramAdapter {
     name = "telegram";
@@ -11,9 +12,11 @@ export class TelegramAdapter {
     lastSentText = "";
     token;
     chatId;
-    constructor(token, chatId) {
+    basePath;
+    constructor(token, chatId, basePath) {
         this.token = token;
         this.chatId = chatId;
+        this.basePath = basePath;
     }
     async validate() {
         const res = await this.telegramApi("getMe");
@@ -82,17 +85,74 @@ export class TelegramAdapter {
             // Handle text reply (reply_to_message)
             if (update.message) {
                 const msg = update.message;
+                // Defensive: ensure command replies go back to our configured chat, not an unvalidated chat ID.
+                // ref.channelId is always set from this.chatId in sendPrompt, so this guard enforces that.
+                const replyChatId = String(msg.chat?.id) === this.chatId ? this.chatId : null;
+                if (!replyChatId)
+                    continue; // skip messages not from our configured chat
                 if (String(msg.chat?.id) === ref.channelId &&
-                    msg.reply_to_message &&
-                    String(msg.reply_to_message.message_id) === ref.messageId &&
                     msg.from?.id !== this.botUserId &&
                     msg.text) {
-                    return parseTelegramResponse(null, msg.text, prompt.questions, prompt.id);
+                    // Intercept slash commands — handle and continue polling for the answer
+                    if (isCommand(msg.text)) {
+                        const sender = this.makeCommandSender(replyChatId);
+                        try {
+                            await handleCommand(msg.text, sender, this.basePath);
+                        }
+                        catch { /* best-effort — command errors must not disrupt polling */ }
+                        continue;
+                    }
+                    if (msg.reply_to_message &&
+                        String(msg.reply_to_message.message_id) === ref.messageId) {
+                        return parseTelegramResponse(null, msg.text, prompt.questions, prompt.id);
+                    }
                 }
             }
         }
         return null;
     }
+    /**
+     * Poll Telegram for incoming slash commands and handle them.
+     * Intended for idle-time polling when no question prompt is active.
+     * Returns the number of commands handled.
+     */
+    async pollAndHandleCommands(basePath) {
+        if (!this.botUserId) {
+            try {
+                await this.validate();
+            }
+            catch {
+                return 0;
+            }
+        }
+        const res = await this.telegramApi("getUpdates", {
+            offset: this.lastUpdateId + 1,
+            timeout: 0,
+            allowed_updates: ["message"],
+        });
+        if (!res.ok || !Array.isArray(res.result))
+            return 0;
+        let handled = 0;
+        for (const update of res.result) {
+            if (update.update_id > this.lastUpdateId) {
+                this.lastUpdateId = update.update_id;
+            }
+            const msg = update.message;
+            if (msg &&
+                String(msg.chat?.id) === this.chatId &&
+                msg.from?.id !== this.botUserId &&
+                msg.text &&
+                isCommand(msg.text)) {
+                const sender = this.makeCommandSender(msg.chat?.id ?? this.chatId);
+                try {
+                    await handleCommand(msg.text, sender, basePath);
+                    handled++;
+                }
+                catch { /* best-effort */ }
+            }
+        }
+        return handled;
+    }
     /**
      * Acknowledge receipt by editing the original message to append a checkmark.
      * Best-effort — failures are silently ignored.
@@ -110,6 +170,21 @@ export class TelegramAdapter {
             // Best-effort — don't let acknowledgement failures affect the flow
         }
     }
+    makeCommandSender(chatId) {
+        const targetChatId = String(chatId);
+        return {
+            send: async (text) => {
+                try {
+                    await this.telegramApi("sendMessage", {
+                        chat_id: targetChatId,
+                        text,
+                        parse_mode: "Markdown",
+                    });
+                }
+                catch { /* best-effort — command replies must not disrupt polling */ }
+            },
+        };
+    }
     buildMessageUrl(chatId, messageId) {
         // Supergroups have chat IDs starting with -100
         if (chatId.startsWith("-100")) {

package/dist/resources/extensions/search-the-web/command-search-provider.js

@@ -7,6 +7,7 @@
  *
  * All provider logic lives in provider.ts (S01) — this is pure UI wiring.
  */
+import { isAnthropicApi } from '@gsd/pi-ai';
 import { getTavilyApiKey, getBraveApiKey, getOllamaApiKey, getSearchProviderPreference, setSearchProviderPreference, resolveSearchProvider, } from './provider.js';
 const VALID_PREFERENCES = ['tavily', 'brave', 'ollama', 'auto'];
 function keyStatus(provider) {
@@ -71,7 +72,9 @@ export function registerSearchProviderCommand(pi) {
             }
             setSearchProviderPreference(chosen);
             const effective = resolveSearchProvider();
-            const isAnthropic = ctx.model?.provider === 'anthropic';
+            // Gate on api (#4478 / ADR-012): covers claude-code, anthropic-vertex, and
+            // other Anthropic-fronting transports — not just the plain `anthropic` provider.
+            const isAnthropic = isAnthropicApi(ctx.model);
             const nativeNote = isAnthropic ? '\nNote: Native Anthropic web search is also active (automatic, no API key needed).' : '';
             ctx.ui.notify(`Search provider set to ${chosen}. Effective provider: ${effective ?? 'none (no API keys)'}${nativeNote}`, 'info');
         },

package/dist/resources/extensions/search-the-web/native-search.js

@@ -4,6 +4,7 @@
  * Extracted from index.ts so it can be unit-tested without importing
  * the heavy tool-registration modules.
  */
+import { isAnthropicApi } from "@gsd/pi-ai";
 import { resolveSearchProviderFromPreferences } from "../gsd/preferences.js";
 /** Tool names for the Brave-backed custom search tools */
 export const BRAVE_TOOL_NAMES = ["search-the-web", "search_and_read"];
@@ -75,7 +76,10 @@ export function registerNativeSearchHooks(pi) {
     pi.on("model_select", async (event, ctx) => {
         modelSelectFired = true;
         const wasAnthropic = isAnthropicProvider;
-        isAnthropicProvider = event.model.provider === "anthropic";
+        // Gate on `api` not `provider` (#4478 / ADR-012): covers claude-code OAuth,
+        // anthropic-vertex, and Vercel-gateway-hosted Anthropic — all serve the
+        // Messages API and accept the native web_search tool.
+        isAnthropicProvider = isAnthropicApi(event.model);
         const hasBrave = !!process.env.BRAVE_API_KEY;
         // When Anthropic (and not preferring Brave): disable custom search tools —
         // native web_search is server-side and more reliable.
@@ -116,7 +120,14 @@ export function registerNativeSearchHooks(pi) {
         // modelsAreEqual suppresses model_select AND the SDK doesn't pass model.
         const eventModel = event.model;
         let isAnthropic;
-        if (eventModel?.provider) {
+        if (eventModel?.api) {
+            // Preferred path: gate on wire protocol (#4478 / ADR-012).
+            isAnthropic = isAnthropicApi(eventModel);
+        }
+        else if (eventModel?.provider) {
+            // Fallback for event shapes that carry provider but not api — only plain
+            // `anthropic` maps unambiguously without the api field. Other Anthropic
+            // transports will arrive via the modelSelectFired or model-name branch.
             isAnthropic = eventModel.provider === "anthropic";
         }
         else if (modelSelectFired) {