@smithers-orchestrator/agents 0.24.2 → 0.25.0

package/src/GeminiAgent.js

@@ -1,18 +1,27 @@
-import { BaseCliAgent, pushFlag, pushList, isRecord, asString, truncate, toolKindFromName, createSyntheticIdGenerator, } from "./BaseCliAgent/index.js";
-import { normalizeCapabilityStringList, } from "./capability-registry/index.js";
-/** @typedef {import("./BaseCliAgent/BaseCliAgentOptions.ts").BaseCliAgentOptions} BaseCliAgentOptions */
+import { BaseCliAgent } from "./BaseCliAgent/index.js";
+import { normalizeCapabilityStringList } from "./capability-registry/index.js";
+
 /** @typedef {import("./capability-registry/AgentCapabilityRegistry.ts").AgentCapabilityRegistry} AgentCapabilityRegistry */
 /** @typedef {import("./BaseCliAgent/CliOutputInterpreter.ts").CliOutputInterpreter} CliOutputInterpreter */
 /** @typedef {import("./GeminiAgentOptions.ts").GeminiAgentOptions} GeminiAgentOptions */
 
+export const GEMINI_SUNSET_MESSAGE = [
+    "Gemini CLI support has been sunset in Smithers.",
+    "Use AntigravityAgent with Google's `agy` CLI instead.",
+    "Example:",
+    '  import { AntigravityAgent } from "smithers-orchestrator";',
+    '  const agent = new AntigravityAgent({ model: "gemini-3.1-pro-preview", cwd: process.cwd() });',
+].join("\n");
+
 /**
  * @param {GeminiAgentOptions} opts
  */
 function resolveGeminiBuiltIns(opts) {
     return opts.allowedTools?.length
         ? normalizeCapabilityStringList(opts.allowedTools)
-        : ["default"];
+        : ["sunset"];
 }
+
 /**
  * @param {GeminiAgentOptions} [opts]
  * @returns {AgentCapabilityRegistry}
@@ -23,9 +32,9 @@ export function createGeminiCapabilityRegistry(opts = {}) {
         engine: "gemini",
         runtimeTools: {},
         mcp: {
-            bootstrap: "allow-list",
+            bootstrap: "unsupported",
             supportsProjectScope: false,
-            supportsUserScope: true,
+            supportsUserScope: false,
         },
         skills: {
             supportsSkills: false,
@@ -38,14 +47,16 @@ export function createGeminiCapabilityRegistry(opts = {}) {
         builtIns: resolveGeminiBuiltIns(opts),
     };
 }
+
 /**
- * @deprecated Use AntigravityAgent for new Google CLI integrations. GeminiAgent
- * remains for legacy and enterprise Gemini CLI setups.
+ * @deprecated Gemini CLI support has been sunset. Use AntigravityAgent with
+ * Google's `agy` CLI instead.
  */
 export class GeminiAgent extends BaseCliAgent {
     opts;
     capabilities;
     cliEngine = "gemini";
+
     /**
    * @param {GeminiAgentOptions} [opts]
    */
@@ -54,228 +65,27 @@ export class GeminiAgent extends BaseCliAgent {
         this.opts = opts;
         this.capabilities = createGeminiCapabilityRegistry(opts);
     }
+
     /**
    * @returns {CliOutputInterpreter}
    */
     createOutputInterpreter() {
-        let sessionId;
-        let finalAnswer = "";
-        let didEmitCompleted = false;
-        const nextSyntheticId = createSyntheticIdGenerator();
-        /**
-     * @param {string} line
-     * @returns {AgentCliEvent[]}
-     */
-        const parseLine = (line) => {
-            const trimmed = line.trim();
-            if (!trimmed)
-                return [];
-            let payload;
-            try {
-                payload = JSON.parse(trimmed);
-            }
-            catch {
-                return [];
-            }
-            if (!isRecord(payload))
-                return [];
-            const type = asString(payload.type);
-            if (!type)
-                return [];
-            if (type === "init") {
-                const resume = asString(payload.session_id);
-                if (resume) {
-                    sessionId = resume;
-                }
-                return [{
-                        type: "started",
-                        engine: this.cliEngine,
-                        title: "Gemini CLI",
-                        resume: sessionId,
-                        detail: {
-                            model: asString(payload.model),
-                        },
-                    }];
-            }
-            if (type === "MESSAGE") {
-                const role = asString(payload.role);
-                const content = asString(payload.content);
-                if (role === "assistant" && content) {
-                    if (payload.delta === true) {
-                        finalAnswer += content;
-                    }
-                    else {
-                        finalAnswer = content;
-                    }
-                }
-                return [];
-            }
-            if (type === "TOOL_USE") {
-                const toolName = asString(payload.tool_name) ?? "tool";
-                const toolId = asString(payload.tool_id) ?? nextSyntheticId("gemini-tool");
-                return [{
-                        type: "action",
-                        engine: this.cliEngine,
-                        phase: "started",
-                        entryType: "thought",
-                        action: {
-                            id: toolId,
-                            kind: toolKindFromName(toolName),
-                            title: toolName,
-                            detail: {
-                                parameters: payload.parameters,
-                            },
-                        },
-                        message: `Running ${toolName}`,
-                        level: "info",
-                    }];
-            }
-            if (type === "TOOL_RESULT") {
-                const toolId = asString(payload.tool_id) ?? nextSyntheticId("gemini-tool");
-                const ok = asString(payload.status) !== "error";
-                const error = isRecord(payload.error) ? asString(payload.error.message) : undefined;
-                const output = asString(payload.output);
-                return [{
-                        type: "action",
-                        engine: this.cliEngine,
-                        phase: "completed",
-                        entryType: "thought",
-                        action: {
-                            id: toolId,
-                            kind: "tool",
-                            title: "tool result",
-                            detail: {
-                                status: asString(payload.status),
-                                output: output ? truncate(output, 400) : undefined,
-                            },
-                        },
-                        message: error ?? output,
-                        ok,
-                        level: ok ? "info" : "warning",
-                    }];
-            }
-            if (type === "ERROR") {
-                return [{
-                        type: "action",
-                        engine: this.cliEngine,
-                        phase: "completed",
-                        entryType: "thought",
-                        action: {
-                            id: nextSyntheticId("gemini-warning"),
-                            kind: "warning",
-                            title: "warning",
-                            detail: {
-                                severity: asString(payload.severity),
-                            },
-                        },
-                        message: asString(payload.message),
-                        ok: asString(payload.severity) !== "error",
-                        level: asString(payload.severity) === "error" ? "error" : "warning",
-                    }];
-            }
-            if (type === "RESULT") {
-                if (didEmitCompleted)
-                    return [];
-                didEmitCompleted = true;
-                return [{
-                        type: "completed",
-                        engine: this.cliEngine,
-                        ok: asString(payload.status) !== "error",
-                        answer: finalAnswer || asString(payload.response),
-                        resume: sessionId,
-                        usage: isRecord(payload.stats) ? payload.stats : undefined,
-                    }];
-            }
-            return [];
-        };
         return {
-            onStdoutLine: parseLine,
-            onExit: (result) => {
-                if (didEmitCompleted)
-                    return [];
-                if (result.exitCode === 0)
-                    return [];
-                didEmitCompleted = true;
-                return [{
-                        type: "completed",
-                        engine: this.cliEngine,
-                        ok: false,
-                        answer: finalAnswer || undefined,
-                        error: result.stderr.trim() || `Gemini exited with code ${result.exitCode}`,
-                        resume: sessionId,
-                    }];
-            },
+            onStdoutLine: () => [],
+            onExit: () => [{
+                    type: "completed",
+                    engine: this.cliEngine,
+                    ok: false,
+                    error: GEMINI_SUNSET_MESSAGE,
+                }],
         };
     }
-    /**
-   * @param {{ prompt: string; systemPrompt?: string; cwd: string; options: any; }} params
-   */
-    async buildCommand(params) {
-        const args = [];
-        const yoloEnabled = this.opts.yolo ?? this.yolo;
-        // Default to "json" output format to separate model responses from tool
-        // output text. With "text" format, tool call results (file contents etc.)
-        // are concatenated into the response, making JSON extraction unreliable.
-        const outputFormat = this.opts.outputFormat ??
-            (params.options?.onEvent ? "stream-json" : "json");
-        const resumeSession = typeof params.options?.resumeSession === "string"
-            ? params.options.resumeSession
-            : this.opts.resume;
-        if (this.opts.debug)
-            args.push("--debug");
-        pushFlag(args, "--model", this.opts.model ?? this.model);
-        if (this.opts.sandbox)
-            args.push("--sandbox");
-        if (this.opts.approvalMode) {
-            pushFlag(args, "--approval-mode", this.opts.approvalMode);
-        }
-        else if (yoloEnabled) {
-            args.push("--yolo");
-        }
-        if (this.opts.experimentalAcp)
-            args.push("--experimental-acp");
-        pushList(args, "--allowed-mcp-server-names", this.opts.allowedMcpServerNames);
-        if (this.opts.allowedTools !== undefined) {
-            if (this.opts.allowedTools.length === 0) {
-                pushFlag(args, "--allowed-tools", "");
-            }
-            else {
-                pushList(args, "--allowed-tools", this.opts.allowedTools);
-            }
-        }
-        pushList(args, "--extensions", this.opts.extensions);
-        if (this.opts.listExtensions)
-            args.push("--list-extensions");
-        pushFlag(args, "--resume", resumeSession);
-        if (this.opts.listSessions)
-            args.push("--list-sessions");
-        pushFlag(args, "--delete-session", this.opts.deleteSession);
-        pushList(args, "--include-directories", this.opts.includeDirectories);
-        if (this.opts.screenReader)
-            args.push("--screen-reader");
-        pushFlag(args, "--output-format", outputFormat);
-        if (this.extraArgs?.length)
-            args.push(...this.extraArgs);
-        const systemPrefix = params.systemPrompt
-            ? `${params.systemPrompt}\n\n`
-            : "";
-        // Reinforce raw JSON output requirement in the prompt for Gemini models
-        // which tend to forget structured output instructions on long responses.
-        const jsonReminder = params.prompt?.includes("REQUIRED OUTPUT")
-            ? "\n\nREMINDER: Your response MUST be ONLY the required raw JSON object. Do not include prose, markdown, or code fences. The first character must be `{` and the last character must be `}`.\n"
-            : "";
-        const fullPrompt = `${systemPrefix}${params.prompt ?? ""}${jsonReminder}`;
-        args.push("--prompt", fullPrompt);
-        const accountEnv = {};
-        if (this.opts.configDir)
-            accountEnv.GEMINI_DIR = this.opts.configDir;
-        if (this.opts.apiKey)
-            accountEnv.GEMINI_API_KEY = this.opts.apiKey;
-        return {
-            command: "gemini",
-            args,
-            outputFormat,
-            env: Object.keys(accountEnv).length > 0 ? accountEnv : undefined,
-        };
+
+    async generate() {
+        throw new Error(GEMINI_SUNSET_MESSAGE);
+    }
+
+    async buildCommand() {
+        throw new Error(GEMINI_SUNSET_MESSAGE);
     }
 }

package/src/GeminiAgentOptions.ts

@@ -1,9 +1,8 @@
 import type { BaseCliAgentOptions } from "./BaseCliAgent/BaseCliAgentOptions";
 
 /**
- * @deprecated Use AntigravityAgentOptions with the Antigravity CLI (`agy`) for
- * new Google CLI integrations. GeminiAgentOptions remains for legacy and
- * enterprise Gemini CLI setups.
+ * @deprecated Gemini CLI support has been sunset. Use AntigravityAgentOptions
+ * with the Antigravity CLI (`agy`) for Google CLI integrations.
  */
 export type GeminiAgentOptions = BaseCliAgentOptions & {
   debug?: boolean;
@@ -23,15 +22,11 @@ export type GeminiAgentOptions = BaseCliAgentOptions & {
   screenReader?: boolean;
   outputFormat?: "text" | "json" | "stream-json";
   /**
-   * Path to an isolated Gemini CLI config directory. Sets `GEMINI_DIR` on the
-   * spawned process so this invocation uses the credentials stored at
-   * `<configDir>/oauth_creds.json` (instead of the user's default
-   * `~/.gemini/`). Use this to run multiple Gemini accounts side-by-side.
+   * Legacy option retained only so old constructor calls type-check.
    */
   configDir?: string;
   /**
-   * Gemini API key. Sets `GEMINI_API_KEY` on the spawned process for
-   * API-billed invocations.
+   * Legacy option retained only so old constructor calls type-check.
    */
   apiKey?: string;
 };

package/src/OpenCodeAgent.js

@@ -12,17 +12,7 @@ import { normalizeCapabilityStringList } from "./capability-registry/index.js";
 
 /** @typedef {import("./BaseCliAgent/index.ts").BaseCliAgentOptions} BaseCliAgentOptions */
 /** @typedef {import("./capability-registry/index.ts").AgentCapabilityRegistry} AgentCapabilityRegistry */
-
-/**
- * @typedef {BaseCliAgentOptions & {
- *   model?: string;
- *   agentName?: string;
- *   attachFiles?: string[];
- *   continueSession?: boolean;
- *   sessionId?: string;
- *   variant?: "high" | "medium" | "low";
- * }} OpenCodeAgentOptions
- */
+/** @typedef {import("./OpenCodeAgentOptions.ts").OpenCodeAgentOptions} OpenCodeAgentOptions */
 
 /** @typedef {import("./BaseCliAgent/index.ts").CliOutputInterpreter} CliOutputInterpreter */
 
@@ -80,7 +70,7 @@ export function createOpenCodeCapabilityRegistry(opts = {}) {
  *
  * Usage:
  *   const agent = new OpenCodeAgent({
- *     model: "anthropic/claude-opus-4-20250514",
+ *     model: "anthropic/claude-opus-4-8",
  *     yolo: true,
  *   });
  *   const result = await agent.generate({

package/src/OpenCodeAgentOptions.ts

@@ -0,0 +1,19 @@
+import type { BaseCliAgentOptions } from "./BaseCliAgent";
+
+/**
+ * Configuration options for the OpenCodeAgent.
+ */
+export type OpenCodeAgentOptions = BaseCliAgentOptions & {
+  /** Model identifier (e.g., "anthropic/claude-opus-4-8", "openai/gpt-5.4") */
+  model?: string;
+  /** OpenCode agent name (maps to --agent flag, selects predefined agent config) */
+  agentName?: string;
+  /** Files to attach to the prompt via -f flags */
+  attachFiles?: string[];
+  /** Continue a previous session */
+  continueSession?: boolean;
+  /** Resume a specific session by ID */
+  sessionId?: string;
+  /** Provider-specific model variant/reasoning effort level */
+  variant?: string;
+};

package/src/cli-capabilities/CliAgentCapabilityAdapterId.ts

@@ -4,7 +4,6 @@ export type CliAgentCapabilityAdapterId =
   | "antigravity"
   | "codex"
   | "forge"
-  | "gemini"
   | "kimi"
   | "opencode"
   | "pi"

package/src/cli-capabilities/getCliAgentCapabilityDoctorReport.js

@@ -116,10 +116,11 @@ function diagnoseSurfaceContract(entry) {
 }
 
 /**
+ * @param {CliAgentCapabilityReportEntry[]} [entries]
  * @returns {CliAgentCapabilityDoctorReport}
  */
-export function getCliAgentCapabilityDoctorReport() {
-    const agents = getCliAgentCapabilityReport().map((entry) => {
+export function getCliAgentCapabilityDoctorReport(entries = getCliAgentCapabilityReport()) {
+    const agents = entries.map((entry) => {
         const issues = [
             ...diagnoseCapabilityRegistry(entry.capabilities),
             ...diagnoseSurfaceContract(entry),

package/src/cli-capabilities/getCliAgentCapabilityReport.js

@@ -4,7 +4,6 @@ import { createAntigravityCapabilityRegistry } from "../AntigravityAgent.js";
 import { createClaudeCodeCapabilityRegistry } from "../ClaudeCodeAgent.js";
 import { createCodexCapabilityRegistry } from "../CodexAgent.js";
 import { createForgeCapabilityRegistry } from "../ForgeAgent.js";
-import { createGeminiCapabilityRegistry } from "../GeminiAgent.js";
 import { createKimiCapabilityRegistry } from "../KimiAgent.js";
 import { createOpenCodeCapabilityRegistry } from "../OpenCodeAgent.js";
 import { createPiCapabilityRegistry } from "../PiAgent.js";
@@ -33,11 +32,6 @@ const CLI_AGENT_CAPABILITY_ADAPTERS = [
         binary: "agy",
         buildRegistry: () => createAntigravityCapabilityRegistry(),
     },
-    {
-        id: "gemini",
-        binary: "gemini",
-        buildRegistry: () => createGeminiCapabilityRegistry(),
-    },
     {
         id: "forge",
         binary: "forge",

package/src/cli-surface/cliAgentSurfaceManifest.js

@@ -97,6 +97,7 @@ export const CLI_AGENT_SURFACE_MANIFEST = [
       "--color",
       "--json",
       "--output-last-message",
+      "-",
     ],
     supportedFlags: [],
     unsupportedFlags: [],
@@ -213,45 +214,6 @@ export const CLI_AGENT_SURFACE_MANIFEST = [
       notes: "Smithers maps native session ids to `agy --conversation <id>`.",
     },
   },
-  {
-    id: "gemini",
-    displayName: "Gemini",
-    binary: "gemini",
-    packageExport: "GeminiAgent",
-    defaultOutputFormat: "json",
-    docsUrls: ["https://github.com/google-gemini/gemini-cli"],
-    emittedFlags: [
-      "--debug",
-      "--model",
-      "--sandbox",
-      "--approval-mode",
-      "--yolo",
-      "--experimental-acp",
-      "--allowed-mcp-server-names",
-      "--allowed-tools",
-      "--extensions",
-      "--list-extensions",
-      "--resume",
-      "--list-sessions",
-      "--delete-session",
-      "--include-directories",
-      "--screen-reader",
-      "--output-format",
-      "--prompt",
-    ],
-    supportedFlags: [],
-    unsupportedFlags: [],
-    optionMappings: [
-      { option: "configDir", env: "GEMINI_DIR" },
-      { option: "apiKey", env: "GEMINI_API_KEY" },
-      { option: "resume", flag: "--resume" },
-    ],
-    resume: {
-      kind: "flag",
-      emitted: ["--resume"],
-      notes: "Legacy Gemini CLI session id.",
-    },
-  },
   {
     id: "pi",
     displayName: "Pi",
@@ -287,7 +249,6 @@ export const CLI_AGENT_SURFACE_MANIFEST = [
       "--no-themes",
       "--thinking",
       "--verbose",
-      "--files",
     ],
     supportedFlags: [],
     unsupportedFlags: [],

package/src/createElevenLabsTextToSpeechTool.js

@@ -0,0 +1,128 @@
+import { dynamicTool, jsonSchema } from "ai";
+
+const DEFAULT_BASE_URL = "https://api.elevenlabs.io";
+const DEFAULT_MODEL_ID = "eleven_turbo_v2_5";
+const DEFAULT_VOICE_ID = "21m00Tcm4TlvDq8ikWAM";
+const TOOL_NAME = "elevenlabs_text_to_speech";
+
+const inputSchema = {
+  type: "object",
+  properties: {
+    text: {
+      type: "string",
+      minLength: 1,
+      description: "Text to synthesize into speech.",
+    },
+    voiceId: {
+      type: "string",
+      minLength: 1,
+      description: "Optional ElevenLabs voice id. Defaults to the configured voice.",
+    },
+    modelId: {
+      type: "string",
+      minLength: 1,
+      description: "Optional ElevenLabs model id. Defaults to the configured model.",
+    },
+    voiceSettings: {
+      type: "object",
+      additionalProperties: true,
+      description: "Optional ElevenLabs voice_settings payload.",
+    },
+  },
+  required: ["text"],
+  additionalProperties: false,
+};
+
+/**
+ * Create an agent-callable ElevenLabs text-to-speech tool.
+ *
+ * @param {import("./createElevenLabsTextToSpeechTool.ts").ElevenLabsTextToSpeechToolOptions} options
+ * @returns {import("./createElevenLabsTextToSpeechTool.ts").ElevenLabsTextToSpeechToolset}
+ */
+export function createElevenLabsTextToSpeechTool(options) {
+  if (!options?.apiKey) {
+    throw new Error("createElevenLabsTextToSpeechTool requires an ElevenLabs apiKey");
+  }
+
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error("createElevenLabsTextToSpeechTool requires fetch");
+  }
+
+  const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+  const defaultVoiceId = options.defaultVoiceId ?? DEFAULT_VOICE_ID;
+  const defaultModelId = options.defaultModelId ?? DEFAULT_MODEL_ID;
+
+  return {
+    tools: {
+      [TOOL_NAME]: dynamicTool({
+        description: "Synthesize speech audio from text using ElevenLabs.",
+        inputSchema: jsonSchema(inputSchema),
+        execute: async (input) =>
+          synthesizeSpeech({
+            apiKey: options.apiKey,
+            baseUrl,
+            defaultVoiceId,
+            defaultModelId,
+            fetchImpl,
+            input,
+          }),
+      }),
+    },
+    toolNames: [TOOL_NAME],
+  };
+}
+
+/**
+ * @param {{
+ *   apiKey: string;
+ *   baseUrl: string;
+ *   defaultVoiceId: string;
+ *   defaultModelId: string;
+ *   fetchImpl: typeof fetch;
+ *   input: unknown;
+ * }} params
+ */
+async function synthesizeSpeech({ apiKey, baseUrl, defaultVoiceId, defaultModelId, fetchImpl, input }) {
+  const args = /** @type {import("./createElevenLabsTextToSpeechTool.ts").ElevenLabsTextToSpeechInput} */ (
+    input ?? {}
+  );
+  if (typeof args.text !== "string" || args.text.trim() === "") {
+    throw new Error("elevenlabs_text_to_speech requires non-empty text");
+  }
+
+  const voiceId = args.voiceId ?? defaultVoiceId;
+  const modelId = args.modelId ?? defaultModelId;
+  const body = {
+    text: args.text,
+    model_id: modelId,
+    ...(args.voiceSettings ? { voice_settings: args.voiceSettings } : {}),
+  };
+
+  const response = await fetchImpl(`${baseUrl}/v1/text-to-speech/${encodeURIComponent(voiceId)}`, {
+    method: "POST",
+    headers: {
+      Accept: "audio/mpeg",
+      "Content-Type": "application/json",
+      "xi-api-key": apiKey,
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "");
+    throw new Error(
+      `ElevenLabs text-to-speech failed with ${response.status}${errorText ? `: ${errorText}` : ""}`,
+    );
+  }
+
+  const contentType = response.headers.get("content-type") ?? "audio/mpeg";
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  return {
+    audioBase64: Buffer.from(bytes).toString("base64"),
+    contentType,
+    voiceId,
+    modelId,
+    byteLength: bytes.byteLength,
+  };
+}

package/src/createElevenLabsTextToSpeechTool.ts

@@ -0,0 +1,33 @@
+import type { Tool } from "ai";
+
+export type ElevenLabsTextToSpeechInput = {
+  text: string;
+  voiceId?: string;
+  modelId?: string;
+  voiceSettings?: Record<string, unknown>;
+};
+
+export type ElevenLabsTextToSpeechResult = {
+  audioBase64: string;
+  contentType: string;
+  voiceId: string;
+  modelId: string;
+  byteLength: number;
+};
+
+export type ElevenLabsTextToSpeechToolOptions = {
+  apiKey: string;
+  defaultVoiceId?: string;
+  defaultModelId?: string;
+  baseUrl?: string;
+  fetch?: typeof fetch;
+};
+
+export type ElevenLabsTextToSpeechToolset = {
+  tools: Record<"elevenlabs_text_to_speech", Tool>;
+  toolNames: ["elevenlabs_text_to_speech"];
+};
+
+export declare function createElevenLabsTextToSpeechTool(
+  options: ElevenLabsTextToSpeechToolOptions,
+): ElevenLabsTextToSpeechToolset;