cartethyia 2.7.5 → 2.7.7

package/src/console/cli-tools/injectors/codex.ts

@@ -1,5 +1,5 @@
 import type {} from "../contracts";
-import { ensureV1Suffix, homeDir, readJsonFile, readTextFile, removeFile, textGet, textHas, textRemove, textUpsert, writeJsonFile, writeTextFile } from "../fs-ops";
+import { ensureV1Suffix, homeDir, readJsonFile, readTextFile, removeFile, textGet, textHas, textRemove, textUpsert, writeJsonFileWithBackup, writeTextFileWithBackup } from "../fs-ops";
 import type { InjectorSpec } from "../contracts";
 
 
@@ -93,12 +93,12 @@ export const codexSpec: InjectorSpec = {
         `  refresh_interval_ms = 0`,
       ].join("\n"),
     );
-    await writeTextFile(path, text);
+    await writeTextFileWithBackup(path, text);
 
     const auth = ((await readJsonFile(codexAuthPath())) as Record<string, string> | null) ?? {};
     auth[CODEX_PROVIDER] = input.apiKey;
-    await writeJsonFile(codexAuthPath(), auth);
-    await writeTextFile(codexAuthHelperPath(), CODEX_AUTH_HELPER_SOURCE);
+    await writeJsonFileWithBackup(codexAuthPath(), auth);
+    await writeTextFileWithBackup(codexAuthHelperPath(), CODEX_AUTH_HELPER_SOURCE);
   },
 
   async reset(path) {
@@ -118,12 +118,12 @@ export const codexSpec: InjectorSpec = {
     if (textGet(text, { kind: "flat", key: "model_provider" }) === CODEX_PROVIDER) {
       text = textUpsert(text, { kind: "flat", key: "model_provider", insertAtTop: true }, "openai");
     }
-    await writeTextFile(path, text);
+    await writeTextFileWithBackup(path, text);
 
     const auth = (await readJsonFile(codexAuthPath())) as Record<string, string> | null;
     if (auth?.[CODEX_PROVIDER]) {
       delete auth[CODEX_PROVIDER];
-      await writeJsonFile(codexAuthPath(), auth);
+      await writeJsonFileWithBackup(codexAuthPath(), auth);
     }
     await removeFile(codexAuthHelperPath());
   },

package/src/console/cli-tools/injectors/driver.ts

@@ -6,25 +6,15 @@ import type {
   ApplyResult,
   DownloadResult,
   InjectorSpec,
-  ToolDef,
   ToolId,
   ToolInjector,
   ToolStatus,
 } from "../contracts";
-import { TOOL_IDS, TOOL_REGISTRY } from "../contracts";
-import { checkBinaryInstalled, ensureDir, ensureV1Suffix, fileExists, keyPrefix } from "../fs-ops";
+import { TOOL_IDS } from "../contracts";
+import { checkBinaryInstalled, ensureDir, fileExists, keyPrefix } from "../fs-ops";
 import { claudeSpec } from './claude';
-import { clineSpec } from './cline';
 import { codexSpec } from './codex';
-import { copilotSpec } from './copilot';
-import { coworkSpec } from './cowork';
-import { deepseekTuiSpec } from './deepseek-tui';
-import { droidSpec } from './droid';
-import { grokBuildSpec } from './grok-build';
-import { hermesSpec } from './hermes';
-import { jcodeSpec } from './jcode';
 import { kiloSpec } from './kilo';
-import { openclawSpec } from './openclaw';
 import { opencodeSpec } from './opencode';
 
 // ── injectors/driver.ts ──
@@ -92,11 +82,12 @@ export function createFileInjector(spec: InjectorSpec): ToolInjector {
       const path = spec.resolvePath();
       const dir = spec.resolveDir ? spec.resolveDir() : dirname(path);
       await ensureDir(dir);
-      await spec.apply(input, path);
+      const warnings = await spec.apply(input, path);
       return {
         success: true,
         settingsPath: path,
         message: spec.messages?.applied ?? `${spec.displayName ?? spec.toolId} settings applied`,
+        ...(Array.isArray(warnings) && warnings.length > 0 ? { warnings } : {}),
       };
     },
 
@@ -131,114 +122,26 @@ export function createFileInjector(spec: InjectorSpec): ToolInjector {
   };
 }
 
-/** Create a guide injector for a specific tool definition (any `configType: "guide"` entry). */
-function guideInjectorFor(def: ToolDef): ToolInjector {
-  return {
-    toolId: def.id,
-
-    async getStatus(): Promise<ToolStatus> {
-      // Guide tools are always "not installed" from an injection standpoint —
-      // we can't detect the binary reliably, and config is manual.
-      return {
-        toolId: def.id,
-        installed: false,
-        configured: false,
-        settingsPath: null,
-        currentEndpoint: null,
-        currentApiKeyPrefix: null,
-        currentModels: null,
-        message: "Guide-only tool — use Download Config to get setup instructions",
-      };
-    },
-
-    async apply(): Promise<ApplyResult> {
-      return { success: false, message: `${def.name} is a guide-only tool — use Download Config` };
-    },
-
-    async reset(): Promise<ApplyResult> {
-      return { success: true, message: `${def.name} has no injected config to reset` };
-    },
-
-    async download(input: ApplyInput): Promise<DownloadResult> {
-      const baseUrl = ensureV1Suffix(input.endpoint);
-      const model = input.activeModel ?? input.modelIds[0] ?? "";
-      const apiKey = input.apiKey;
-      const codeBlock = def.codeBlock;
-
-      if (codeBlock) {
-        const content = codeBlock.code
-          .replace(/\{\{baseUrl\}\}/g, baseUrl)
-          .replace(/\{\{apiKey\}\}/g, apiKey)
-          .replace(/\{\{model\}\}/g, model);
-        const ext =
-          codeBlock.language === "json" ? "json" : codeBlock.language === "bash" ? "sh" : "txt";
-        return {
-          content,
-          filename: `${def.id}-config.${ext}`,
-          mimeType: codeBlock.language === "json" ? "application/json" : "text/plain",
-        };
-      }
-
-      // No code block — generate a simple guide summary.
-      const steps = def.guideSteps ?? [];
-      const lines = [`# ${def.name} — Setup Guide`, ""];
-      for (const step of steps) {
-        lines.push(`## Step ${step.step}: ${step.title}`);
-        if (step.desc) lines.push(step.desc);
-        if (step.value) {
-          lines.push("```");
-          lines.push(
-            step.value
-              .replace(/\{\{baseUrl\}\}/g, baseUrl)
-              .replace(/\{\{apiKey\}\}/g, apiKey)
-              .replace(/\{\{model\}\}/g, model),
-          );
-          lines.push("```");
-        }
-        lines.push("");
-      }
-      lines.push(`Endpoint: ${baseUrl}`);
-      lines.push(`API Key: ${apiKey}`);
-      lines.push(`Model: ${model}`);
-      return { content: lines.join("\n"), filename: `${def.id}-guide.txt`, mimeType: "text/plain" };
-    },
-  };
-}
-
 // ── injectors/index.ts ──
 /**
  * Single dispatch point for CliToolService: given a toolId, look up the
  * injector and call getStatus/apply/reset/download.
  *
  * File-based injectors are driven by a generic driver (createFileInjector)
- * configured via declarative specs. Guide-only tools (registry `configType:
- * "guide"`) are all built from `guideInjectorFor` — no per-tool constant
- * needed; the registry itself is the single source of the list. The map is
- * built exhaustively from that registry so a non-guide tool without an
- * injector fails loudly at import, never silently at lookup time.
+ * configured via declarative specs. The map is built exhaustively from that
+ * registry so a tool without an injector fails loudly at import, never
+ * silently at lookup time.
  */
 const FILE_INJECTORS: Partial<Record<ToolId, ToolInjector>> = {
   claude: createFileInjector(claudeSpec),
   codex: createFileInjector(codexSpec),
-  cline: createFileInjector(clineSpec),
   opencode: createFileInjector(opencodeSpec),
-  droid: createFileInjector(droidSpec),
-  hermes: createFileInjector(hermesSpec),
-  "grok-build": createFileInjector(grokBuildSpec),
-  copilot: createFileInjector(copilotSpec),
-  "deepseek-tui": createFileInjector(deepseekTuiSpec),
-  jcode: createFileInjector(jcodeSpec),
   kilo: createFileInjector(kiloSpec),
-  openclaw: createFileInjector(openclawSpec),
-  cowork: createFileInjector(coworkSpec),
 };
 
 export const INJECTORS: Record<ToolId, ToolInjector> = Object.fromEntries(
   TOOL_IDS.map((id) => {
-    const injector =
-      TOOL_REGISTRY[id].configType === "guide"
-        ? guideInjectorFor(TOOL_REGISTRY[id])
-        : FILE_INJECTORS[id];
+    const injector = FILE_INJECTORS[id];
     if (injector === undefined) {
       throw new Error(`No injector registered for tool: ${id}`);
     }

package/src/console/cli-tools/injectors/kilo.ts

@@ -1,13 +1,36 @@
 import { platform } from "node:os";
 import type {} from "../contracts";
-import { resolveApplyTarget, jsonDownload } from "../contracts";
-import { homeDir, isLocalEndpoint, join, readJsonFile, writeJsonFile } from "../fs-ops";
+import { jsonDownload } from "../contracts";
+import { homeDir, isLocalEndpoint, join, readJsonFile, writeJsonFileWithBackup } from "../fs-ops";
 import type { InjectorSpec } from "../contracts";
 
 const IS_WIN = platform() === "win32";
 const IS_MAC = platform() === "darwin";
 
 // Kilo Code injector spec.
+//
+// Kilo Code is a fork of OpenCode, but it now reads its own config file —
+// `~/.config/kilo/kilo.jsonc` (Windows: `%USERPROFILE%\.config\kilo\kilo.jsonc`)
+// — with the same provider shape as OpenCode: `provider.<id>.npm/options/models`
+// plus a top-level `model`. Unlike OpenCode, Kilo runs on the AI SDK, so the
+// `npm` value must be an `@ai-sdk/*` package (default `@ai-sdk/openai-compatible`).
+//
+// The older VS Code extension also keeps a credential store at
+// `~/.local/share/kilo/auth.json`; we still write the endpoint there for
+// backward compatibility, but the canonical config is now `kilo.jsonc`.
+
+const KILO_PROVIDER_ID = "cartethyia";
+
+function resolveKiloConfigDirectory(): string {
+  if (IS_WIN) return join(process.env.USERPROFILE ?? homeDir(), ".config", "kilo");
+  if (IS_MAC) return join(homeDir(), ".config", "kilo");
+  return join(homeDir(), ".config", "kilo");
+}
+
+function kiloConfigPath(): string {
+  return join(resolveKiloConfigDirectory(), "kilo.jsonc");
+}
+
 function resolveKiloDataDirectory(): string {
   if (IS_WIN) return join(process.env.LOCALAPPDATA ?? homeDir(), "kilo");
   if (IS_MAC) return join(homeDir(), "Library", "Application Support", "kilo");
@@ -21,15 +44,52 @@ function kiloVscodeSettingsPath(): string {
   return join(homeDir(), ".config", "Code", "User", "settings.json");
 }
 
+function kiloModelDef(model: string): unknown {
+  return {
+    name: model,
+    limit: { context: 128000, output: 64000 },
+  };
+}
+
+function buildKiloModels(models: readonly string[]): Record<string, unknown> {
+  const map: Record<string, unknown> = {};
+  for (const m of models) {
+    if (!m) continue;
+    map[m] = kiloModelDef(m);
+  }
+  return map;
+}
+
 export const kiloSpec: InjectorSpec = {
   toolId: "kilo",
   displayName: "Kilo Code",
   binary: "kilo",
-  resolveDir: resolveKiloDataDirectory,
-  resolvePath: () => join(resolveKiloDataDirectory(), "auth.json"),
+  resolveDir: resolveKiloConfigDirectory,
+  resolvePath: kiloConfigPath,
 
   async readStatus(path) {
-    const auth = (await readJsonFile(path)) as Record<
+    const config = (await readJsonFile(path)) as {
+      provider?: Record<string, { npm?: string; options?: { baseURL?: string; apiKey?: string }; models?: Record<string, unknown> }>;
+      model?: string;
+    } | null;
+    const provider = config?.provider?.[KILO_PROVIDER_ID];
+    const endpoint = provider?.options?.baseURL ?? null;
+    const models = provider?.models ? Object.keys(provider.models) : null;
+    const active =
+      typeof config?.model === "string" && config.model.startsWith(`${KILO_PROVIDER_ID}/`)
+        ? config.model.split("/").slice(1).join("/")
+        : null;
+    if (endpoint) {
+      return {
+        configured: isLocalEndpoint(endpoint),
+        currentEndpoint: endpoint,
+        rawApiKey: provider?.options?.apiKey ?? null,
+        currentModels: active && models ? [active, ...models.filter((m) => m !== active)] : models,
+      };
+    }
+
+    // Fallback to the legacy auth.json store (older VS Code extension).
+    const auth = (await readJsonFile(join(resolveKiloDataDirectory(), "auth.json"))) as Record<
       string,
       { baseUrl?: string; baseURL?: string; apiKey?: string; model?: string }
     > | null;
@@ -47,22 +107,77 @@ export const kiloSpec: InjectorSpec = {
   },
 
   async apply(input, path) {
-    const { model, baseUrl } = resolveApplyTarget(input);
-    const auth = ((await readJsonFile(path)) as Record<string, unknown> | null) ?? {};
-    auth["openai-compatible"] = { baseUrl, apiKey: input.apiKey, model };
-    await writeJsonFile(path, auth);
+    // Canonical config: ~/.config/kilo/kilo.jsonc
+    const existing = (await readJsonFile(path)) as Record<string, unknown> | null;
+    const config: Record<string, unknown> = (existing ?? {}) as Record<string, unknown>;
+    if (!config.provider || typeof config.provider !== "object") config.provider = {};
+    const providers = config.provider as Record<string, unknown>;
+    const prior = (providers[KILO_PROVIDER_ID] as Record<string, unknown> | undefined) ?? {};
+    const priorModels = (prior.models as Record<string, unknown> | undefined) ?? {};
+    const otherProviders = Object.keys(providers).filter((id) => id !== KILO_PROVIDER_ID);
+    providers[KILO_PROVIDER_ID] = {
+      npm: input.sdk ?? (prior as { npm?: string }).npm ?? "@ai-sdk/openai-compatible",
+      options: {
+        ...((prior.options as Record<string, unknown> | undefined) ?? {}),
+        baseURL: input.endpoint,
+        apiKey: input.apiKey,
+      },
+      models: { ...priorModels, ...buildKiloModels(input.modelIds) },
+    };
+    const activeModel = input.activeModel ?? input.modelIds[0] ?? "";
+    config.model = activeModel === "" ? "" : `${KILO_PROVIDER_ID}/${activeModel}`;
+
+    // YOLO mode: auto-approve shell/read/write.
+    if (input.bypassPermissions === true) {
+      config.permissions = [
+        { action: "shell", resource: "*", effect: "allow" },
+        { action: "external_directory", resource: "*", effect: "allow" },
+        { action: "question", resource: "*", effect: "deny" },
+      ];
+    } else if (input.bypassPermissions === false) {
+      delete config.permissions;
+    }
+
+    await writeJsonFileWithBackup(path, config);
+
+    // Legacy credential store for the older VS Code extension.
+    const authPath = join(resolveKiloDataDirectory(), "auth.json");
+    const auth = ((await readJsonFile(authPath)) as Record<string, unknown> | null) ?? {};
+    auth["openai-compatible"] = { baseUrl: input.endpoint, apiKey: input.apiKey, model: activeModel };
+    await writeJsonFileWithBackup(authPath, auth);
 
     const settings =
       ((await readJsonFile(kiloVscodeSettingsPath())) as Record<string, unknown> | null) ?? {};
     settings["kilo.code.authProviderOverride"] = "openai-compatible";
-    await writeJsonFile(kiloVscodeSettingsPath(), settings);
+    await writeJsonFileWithBackup(kiloVscodeSettingsPath(), settings);
+
+    return otherProviders.length > 0
+      ? [
+          `Config already has other provider(s): ${otherProviders.join(", ")}. They were kept as-is — only ${KILO_PROVIDER_ID} was written/updated.`,
+        ]
+      : undefined;
   },
 
   async reset(path) {
-    const auth = (await readJsonFile(path)) as Record<string, unknown> | null;
-    if (!auth) return false;
-    delete auth["openai-compatible"];
-    await writeJsonFile(path, auth);
+    const config = (await readJsonFile(path)) as Record<string, unknown> | null;
+    if (config && config.provider && typeof config.provider === "object") {
+      const providers = config.provider as Record<string, unknown>;
+      delete providers[KILO_PROVIDER_ID];
+      if (Object.keys(providers).length === 0) delete config.provider;
+    }
+    if (typeof config?.model === "string" && config.model.startsWith(`${KILO_PROVIDER_ID}/`)) {
+      delete config.model;
+    }
+    if (config) await writeJsonFileWithBackup(path, config);
+
+    const auth = (await readJsonFile(join(resolveKiloDataDirectory(), "auth.json"))) as Record<
+      string,
+      unknown
+    > | null;
+    if (auth) {
+      delete auth["openai-compatible"];
+      await writeJsonFileWithBackup(join(resolveKiloDataDirectory(), "auth.json"), auth);
+    }
 
     const settings = (await readJsonFile(kiloVscodeSettingsPath())) as Record<
       string,
@@ -70,21 +185,31 @@ export const kiloSpec: InjectorSpec = {
     > | null;
     if (settings && "kilo.code.authProviderOverride" in settings) {
       delete settings["kilo.code.authProviderOverride"];
-      await writeJsonFile(kiloVscodeSettingsPath(), settings);
+      await writeJsonFileWithBackup(kiloVscodeSettingsPath(), settings);
     }
   },
 
   download(input) {
-    const { model, baseUrl } = resolveApplyTarget(input);
-    return jsonDownload({ "openai-compatible": { baseUrl, apiKey: input.apiKey, model } }, {
-      filename: "auth.json",
-    });
+    const activeModel = input.activeModel ?? input.modelIds[0] ?? "";
+    const config: Record<string, unknown> = {
+      provider: {
+        [KILO_PROVIDER_ID]: {
+          npm: input.sdk ?? "@ai-sdk/openai-compatible",
+          options: {
+            baseURL: input.endpoint,
+            apiKey: input.apiKey,
+          },
+          models: buildKiloModels(input.modelIds),
+        },
+      },
+      model: activeModel === "" ? "" : `${KILO_PROVIDER_ID}/${activeModel}`,
+    };
+    return jsonDownload(config, { filename: "kilo.jsonc" });
   },
 
   messages: {
     applied: "Kilo Code settings applied",
     reset: "Cartethyia settings removed from Kilo Code",
-    resetMissing: "No auth file to reset",
+    resetMissing: "No config file to reset",
   },
 };
-

package/src/console/cli-tools/injectors/opencode.ts

@@ -1,6 +1,8 @@
 import type {} from "../contracts";
-import { ensureV1Suffix, homeDir, join, readJsonFile, writeJsonFile } from "../fs-ops";
+import { ensureV1Suffix, homeDir, join, readJsonFile, writeJsonFileWithBackup } from "../fs-ops";
 import type { InjectorSpec } from "../contracts";
+import { DEFAULT_SDK } from "../contracts";
+import { writeWebsearchPlugin, removeWebsearchPlugin } from "../cartethyia-websearch-plugin";
 
 
 // OpenCode injector spec.
@@ -18,6 +20,7 @@ interface OpencodeProvider {
 interface OpencodeConfig {
   provider?: Record<string, OpencodeProvider>;
   model?: string;
+  websearch?: { provider?: string };
   agent?: {
     explorer?: {
       description?: string;
@@ -50,11 +53,14 @@ export const opencodeSpec: InjectorSpec = {
     if (!config) {
       return { configured: false, currentEndpoint: null, rawApiKey: null, currentModels: null };
     }
-    const provider = config.provider?.cartethyia;
+    // The provider key written by this injector is the websearch provider name
+    // when one is configured, otherwise the default `cartethyia`.
+    const providerId = config.websearch?.provider ?? "cartethyia";
+    const provider = config.provider?.[providerId];
     const endpoint = provider?.options?.baseURL ?? null;
     const models = provider?.models ? Object.keys(provider.models) : null;
     const active =
-      typeof config.model === "string" && config.model.startsWith("cartethyia/")
+      typeof config.model === "string" && config.model.startsWith(`${providerId}/`)
         ? config.model.split("/").slice(1).join("/")
         : null;
     return {
@@ -69,10 +75,16 @@ export const opencodeSpec: InjectorSpec = {
     const existing = (await readJsonFile(path)) as OpencodeConfig | null;
     const config: OpencodeConfig = (existing ?? {}) as OpencodeConfig;
 
+    // The provider key written into opencode.jsonc follows the websearch
+    // provider name when one is chosen, which keeps the websearch plugin and
+    // the provider block pointing at the same entry.
+    const providerId = input.websearch ?? "cartethyia";
+
     if (!config.provider) config.provider = {};
-    const prior = config.provider.cartethyia;
-    config.provider.cartethyia = {
-      npm: "@ai-sdk/openai-compatible",
+    const prior = config.provider[providerId];
+    const otherProviders = Object.keys(config.provider).filter((id) => id !== providerId);
+    config.provider[providerId] = {
+      npm: input.sdk ?? prior?.npm ?? DEFAULT_SDK,
       options: {
         ...(prior?.options ?? {}),
         baseURL: ensureV1Suffix(input.endpoint),
@@ -82,47 +94,85 @@ export const opencodeSpec: InjectorSpec = {
     };
 
     const activeModel = input.activeModel ?? input.modelIds[0] ?? "";
-    config.model = activeModel === "" ? "" : `cartethyia/${activeModel}`;
+    config.model = activeModel === "" ? "" : `${providerId}/${activeModel}`;
+
+    if (input.websearch !== undefined) {
+      config.websearch = { provider: input.websearch };
+    }
+
+    // YOLO mode: auto-approve shell/read/write. When on, write OpenCode's
+    // permission rules; when off, leave whatever the user had (or nothing).
+    if (input.bypassPermissions === true) {
+      config.permissions = [
+        { action: "shell", resource: "*", effect: "allow" },
+        { action: "external_directory", resource: "*", effect: "allow" },
+        { action: "question", resource: "*", effect: "deny" },
+      ];
+    } else if (input.bypassPermissions === false) {
+      delete config.permissions;
+    }
 
     if (!config.agent) config.agent = {};
     const subagentModel = input.subagentModel ?? input.modelIds[0] ?? activeModel;
     config.agent.explorer = {
       description: "Fast explorer subagent",
       mode: "subagent",
-      model: `cartethyia/${subagentModel}`,
+      model: `${providerId}/${subagentModel}`,
     };
 
-    await writeJsonFile(path, config);
+    await writeJsonFileWithBackup(path, config);
+
+    // Write (or refresh) the websearch provider plugin when web search is
+    // routed through the gateway. The plugin id follows the provider name.
+    if (input.websearch !== undefined) {
+      await writeWebsearchPlugin(opencodeSpec.resolveDir?.() ?? join(homeDir(), ".config", "opencode"), providerId);
+    }
+
+    return otherProviders.length > 0
+      ? [
+          `Config already has other provider(s): ${otherProviders.join(", ")}. They were kept as-is — only ${providerId} was written/updated.`,
+        ]
+      : undefined;
   },
 
   async reset(path) {
     const config = (await readJsonFile(path)) as OpencodeConfig | null;
     if (!config) return false;
 
+    const providerId = config.websearch?.provider ?? "cartethyia";
+
     if (config.provider) {
-      delete config.provider.cartethyia;
+      delete config.provider[providerId];
       if (Object.keys(config.provider).length === 0) delete config.provider;
     }
 
-    if (typeof config.model === "string" && config.model.startsWith("cartethyia/")) {
+    if (typeof config.model === "string" && config.model.startsWith(`${providerId}/`)) {
       delete config.model;
     }
 
-    if (config.agent?.explorer?.model?.startsWith("cartethyia/")) {
+    if (config.agent?.explorer?.model?.startsWith(`${providerId}/`)) {
       delete config.agent.explorer;
       if (Object.keys(config.agent).length === 0) delete config.agent;
     }
 
-    await writeJsonFile(path, config);
+    if (config.websearch) {
+      delete config.websearch;
+    }
+
+    await writeJsonFileWithBackup(path, config);
+
+    // Remove the generated websearch plugin when present.
+    await removeWebsearchPlugin(opencodeSpec.resolveDir?.() ?? join(homeDir(), ".config", "opencode"), providerId);
   },
 
   download(input) {
     const activeModel = input.activeModel ?? input.modelIds[0] ?? "";
     const subagentModel = input.subagentModel ?? input.modelIds[0] ?? activeModel;
+    const providerId = input.websearch ?? "cartethyia";
     const config: OpencodeConfig = {
       provider: {
-        cartethyia: {
-          npm: "@ai-sdk/openai-compatible",
+        [providerId]: {
+          npm: input.sdk ?? DEFAULT_SDK,
           options: {
             baseURL: ensureV1Suffix(input.endpoint),
             apiKey: input.apiKey,
@@ -130,12 +180,13 @@ export const opencodeSpec: InjectorSpec = {
           models: buildOpencodeModels(input.modelIds),
         },
       },
-      model: activeModel === "" ? "" : `cartethyia/${activeModel}`,
+      model: activeModel === "" ? "" : `${providerId}/${activeModel}`,
+      ...(input.websearch !== undefined ? { websearch: { provider: input.websearch } } : {}),
       agent: {
         explorer: {
           description: "Fast explorer subagent",
           mode: "subagent",
-          model: `cartethyia/${subagentModel}`,
+          model: `${providerId}/${subagentModel}`,
         },
       },
     };

package/src/console/cli-tools/routes.ts

@@ -102,6 +102,10 @@ function parseApplyInput(
     ...(value.mode === "file" || value.mode === "remote" || value.mode === "both"
       ? { mode: value.mode }
       : {}),
+    ...(typeof value.sdk === "string" && value.sdk.length > 0 ? { sdk: value.sdk } : {}),
+    ...(typeof value.websearch === "string" && value.websearch.length > 0
+      ? { websearch: value.websearch }
+      : {}),
   };
 }
 
@@ -128,6 +132,8 @@ const applyBody = t.Object({
     }),
   ),
   bypassPermissions: t.Optional(t.Boolean()),
+  sdk: t.Optional(t.String()),
+  websearch: t.Optional(t.String()),
 });
 
 const mappingBody = t.Object({

package/src/console/cli-tools/service.ts

@@ -44,8 +44,6 @@ function toToolRegistryEntry(def: ToolDef): ToolRegistryEntry {
     ...(def.settingsFile === undefined ? {} : { settingsFile: def.settingsFile }),
     ...(def.docsUrl === undefined ? {} : { docsUrl: def.docsUrl }),
     ...(def.notes === undefined ? {} : { notes: def.notes }),
-    ...(def.guideSteps === undefined ? {} : { guideSteps: def.guideSteps }),
-    ...(def.codeBlock === undefined ? {} : { codeBlock: def.codeBlock }),
   };
 }
 
@@ -64,8 +62,8 @@ function applyMessage(outcome: ApplyOutcome, toolId: string, fileMessage: string
     case "remote":
       return `Saved the remote route for ${toolId}. No config file was written.`;
     case "none":
-      // A guide tool has no config to inject; the injector's own message says
-      // what to do instead (download the guide), so surface it verbatim.
+      // Nothing was written and no remote route was saved; surface the
+      // injector's own message verbatim.
       return fileMessage.length > 0 ? fileMessage : `Nothing to apply for ${toolId}.`;
   }
 }
@@ -274,8 +272,8 @@ export class CliToolService {
    *
    * `mode` defaults to `both` so the common single-machine case does the
    * obviously-right thing without the operator choosing. A tool that has no
-   * injectable config (a guide tool) reports `remote` honestly instead of
-   * claiming a file write it never performed.
+   * injectable config reports `remote` honestly instead of claiming a file
+   * write it never performed.
    */
   async applyConfig(
     tenantId: string,
@@ -292,12 +290,14 @@ export class CliToolService {
     let wroteFile = false;
     let settingsPath: string | undefined;
     let fileMessage = "";
+    let fileWarnings: readonly string[] | undefined;
 
     if (wantsFile) {
       const result: ApplyResult = await injector.apply(input);
       wroteFile = result.success;
       if (result.settingsPath !== undefined) settingsPath = result.settingsPath;
       fileMessage = result.message;
+      fileWarnings = result.warnings;
     }
 
     let savedRemoteRoute = false;
@@ -321,6 +321,7 @@ export class CliToolService {
       savedRemoteRoute,
       ...(settingsPath === undefined ? {} : { settingsPath }),
       message: applyMessage(outcome, toolId, fileMessage),
+      ...(fileWarnings && fileWarnings.length > 0 ? { warnings: fileWarnings } : {}),
     };
   }
 

package/src/console/observability/contracts.ts

@@ -232,6 +232,12 @@ export interface UsageRequestItem {
    * written before the column existed.
    */
   payloadCaptureState?: string;
+  /**
+   * True for a completed request whose output was far smaller than the model's
+   * ceiling and which ended with an ordinary `stop` (a "degenerate stop").
+   * Absent for everything else — including rows written before the column.
+   */
+  degenerateStop?: boolean;
   /**
    * Bitmask of the payload stages captured for this request: 1 request,
    * 2 provider request, 4 provider response, 8 client response. Read from the