@tablation/crew 0.33.0 → 0.34.0

package/crew.example.yaml

@@ -29,8 +29,7 @@ ship:
 
   # Optional (CREW-1511): named toolchains — a harness adapter plus the binary
   # and model to run it with. The `agent:` block above keeps working and
-  # defines an implicit toolchain named `claude`. Only the `claude` harness
-  # exists today. See docs/toolchains.md.
+  # defines an implicit toolchain named `claude`. Harnesses: claude, gemini. See docs/toolchains.md.
   # toolchain: claude              # the ship's default; a route may override it
   # toolchains:
   #   claude-wrapped:
@@ -42,6 +41,7 @@ ship:
   #       deep: { model: claude-opus-5-5 }
   #     args: []                   # appended to the harness argv
   #     env: {}                    # added to the session environment
+  #   gemini: { harness: gemini, bin: gemini, model: gemini-2.5-pro }
 
   # shell: bash                      # defaults per platform
   extraPath: "/opt/homebrew/bin"     # prepended for hooks

package/dist/cli.js

@@ -616,6 +616,28 @@ function geminiMcpState(s, url) {
   if (e.headers?.Authorization !== `Bearer $${PAIR_KEY_VAR}`) return { state: "different", detail: `it does not read its key from $${PAIR_KEY_VAR}` };
   return { state: "registered" };
 }
+function inspectGeminiMcp(o) {
+  const p = geminiPaths(o.home ?? homedir2());
+  const settings = readGeminiSettings(p.config);
+  if (!settings) return { state: "different", detail: `${p.config} is not a JSON object` };
+  const st = geminiMcpState(settings, o.url);
+  return st.state === "registered" ? { state: "registered", url: o.url } : st;
+}
+function ensureGeminiMcp(o) {
+  const p = geminiPaths(o.home ?? homedir2());
+  const settings = readGeminiSettings(p.config);
+  if (!settings) return `gemini: ${p.config} is not a JSON object \u2014 fix it by hand; nothing was written`;
+  const st = geminiMcpState(settings, o.url);
+  if (st.state === "registered") return `gemini: ${SERVER} MCP server already registered in ${p.config}`;
+  if (st.state === "different" && !o.replace) {
+    return `gemini: left ${p.config} alone \u2014 a "${SERVER}" server exists and ${st.detail}. Re-run with --mcp replace to overwrite it.`;
+  }
+  if (!o.dryRun) {
+    writeFileMkdir(p.config, `${JSON.stringify({ ...settings, mcpServers: { ...settings.mcpServers, [SERVER]: geminiEntry(o.url) } }, null, 2)}
+`);
+  }
+  return `gemini: ${o.dryRun ? "(dry run) would register" : "registered"} ${SERVER} in ${p.config} (key read from $${PAIR_KEY_VAR})`;
+}
 var geminiPair = {
   harness: "gemini",
   displayName: "Gemini CLI",
@@ -828,9 +850,120 @@ function harnessPromptNote(harness) {
 
 // src/toolchain.ts
 import { basename } from "path";
+
+// src/adapters/gemini.ts
+var BILLING_VARS_TO_UNSET2 = [
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "GOOGLE_GENAI_USE_VERTEXAI",
+  "GOOGLE_GENAI_USE_GCA",
+  "GOOGLE_CLOUD_PROJECT",
+  "GOOGLE_CLOUD_PROJECT_ID",
+  "GOOGLE_CLOUD_LOCATION",
+  "GOOGLE_APPLICATION_CREDENTIALS",
+  "GOOGLE_GEMINI_BASE_URL",
+  "GEMINI_MODEL"
+];
+var READ_TOOLS = ["read_file", "read_many_files", "list_directory", "glob", "search_file_content"];
+function geminiGrantFor(p) {
+  if (p.level === "read") return { approvalMode: "default", allowed: [...READ_TOOLS, "run_shell_command"] };
+  if (p.level === "write") return { approvalMode: "default", allowed: [...READ_TOOLS, "run_shell_command", "write_file"] };
+  return { approvalMode: "yolo", allowed: [] };
+}
+function geminiGrantArgs(role) {
+  const g = geminiGrantFor(profileFor(role));
+  return ["--approval-mode", g.approvalMode, ...g.allowed.length ? ["--allowed-tools", g.allowed.join(",")] : []];
+}
+function mapGeminiLine(line) {
+  const obj = line;
+  if (!obj || typeof obj !== "object") return [];
+  if (obj.type === "message" && obj.role === "assistant" && obj.content) return [{ kind: "text", text: obj.content }];
+  if (obj.type === "tool_use") return [{ kind: "tool", tool: obj.tool_name, target: toolTarget(obj.tool_name === "run_shell_command" ? "Bash" : obj.tool_name, obj.parameters) }];
+  return [];
+}
+function createGeminiStreamMapper() {
+  let pending = "";
+  const flush = () => {
+    const text = pending;
+    pending = "";
+    return text ? [{ kind: "text", text }] : [];
+  };
+  return {
+    flush,
+    map(line) {
+      const obj = line;
+      if (obj && typeof obj === "object" && obj.type === "message" && obj.role === "assistant") {
+        if (obj.content) pending += obj.content;
+        return [];
+      }
+      return [...flush(), ...mapGeminiLine(line)];
+    }
+  };
+}
+function extractGeminiResult(line) {
+  const obj = line;
+  if (obj?.type === "init") return obj.session_id ? { sessionId: obj.session_id } : void 0;
+  if (!obj || obj.type !== "result") return void 0;
+  const s = obj.stats;
+  return {
+    inputTokens: s?.input_tokens,
+    outputTokens: s?.output_tokens,
+    cacheReadTokens: s?.cached
+  };
+}
+var geminiAdapter = {
+  harness: "gemini",
+  displayName: "Gemini CLI",
+  vendor: "google",
+  ownsModel: (model) => model.startsWith("gemini-"),
+  // Gemini CLI has no per-run reasoning knob, so a tier's `reasoning` is ignored.
+  defaultBin: "gemini",
+  defaultModel: "gemini-2.5-pro",
+  defaultTiers: {
+    light: { model: "gemini-2.5-flash" },
+    standard: { model: "gemini-2.5-pro" },
+    deep: { model: "gemini-2.5-pro" }
+  },
+  limitations: [
+    "the tool grant is an allow list of tools that skip confirmation, not a sandbox: run_shell_command is allowed in every profile and sub-commands cannot be restricted",
+    "there is no deny list: destructive shell patterns (rm -rf, forced pushes, curl | sh) are not refused at the tool layer, unlike the Claude adapter",
+    "the edit profile runs in yolo mode (auto-approves every tool); the write profile (QA) withholds replace, not shell writes",
+    "design tools (skills, design canvas) are unavailable on this harness",
+    "the tracker MCP server is read from ~/.gemini/settings.json (there is no per-run --mcp-config), and MCP tool calls in the read and write profiles are not on the allow list",
+    "the stream carries no thinking blocks and streams assistant text in fragments, so the runner coalesces fragments into one Agent Log cycle per assistant turn; no turn count or cost is reported"
+  ],
+  invocation(spec, o) {
+    const args = [
+      // The prompt arrives on stdin; `-p` puts the CLI in non-interactive mode.
+      "-p",
+      "",
+      "--model",
+      o.model,
+      "--output-format",
+      "stream-json",
+      ...geminiGrantArgs(o.role),
+      ...spec.args
+    ];
+    return spec.launcher ? { bin: spec.launcherBin ?? spec.launcher, args: [spec.bin, ...args] } : { bin: spec.bin, args };
+  },
+  runEnv: (spec) => ({ ...spec.env }),
+  provider: () => "google",
+  unsetEnv: BILLING_VARS_TO_UNSET2,
+  mapStreamLine: mapGeminiLine,
+  createStreamMapper: createGeminiStreamMapper,
+  extractResult: extractGeminiResult,
+  extractTurnTokens: () => void 0,
+  inspectMcp(o) {
+    return inspectGeminiMcp(o);
+  },
+  ensureMcp: (o) => ensureGeminiMcp(o)
+};
+
+// src/toolchain.ts
 var TIERS = ["light", "standard", "deep"];
 var ADAPTERS = {
-  [claudeAdapter.harness]: claudeAdapter
+  [claudeAdapter.harness]: claudeAdapter,
+  [geminiAdapter.harness]: geminiAdapter
 };
 var HARNESS_NAMES = Object.keys(ADAPTERS);
 function isHarness(name) {
@@ -6847,6 +6980,7 @@ function spawnAgent(plan, emit) {
     let result;
     const cycles = [];
     const attribution = new TicketAttributionTracker();
+    const mapper = adapter.createStreamMapper?.() ?? { map: (p) => adapter.mapStreamLine(p), flush: () => [] };
     const handleLine = (line) => {
       if (!line) return;
       try {
@@ -6861,9 +6995,16 @@ function spawnAgent(plan, emit) {
         return;
       }
       try {
-        result = adapter.extractResult(parsed) ?? result;
+        const extracted = adapter.extractResult(parsed);
+        if (extracted) result = { ...result, ...extracted };
+        consume(parsed, mapper.map(parsed));
+      } catch {
+      }
+    };
+    const consume = (parsed, events) => {
+      {
         let turnText = "";
-        for (const ev of adapter.mapStreamLine(parsed)) {
+        for (const ev of events) {
           const e = {
             at: (/* @__PURE__ */ new Date()).toISOString(),
             cycle: emit.cycle,
@@ -6901,9 +7042,8 @@ function spawnAgent(plan, emit) {
 `);
           }
         }
-        const turnTokens = adapter.extractTurnTokens(parsed);
+        const turnTokens = parsed === void 0 ? void 0 : adapter.extractTurnTokens(parsed);
         if (turnTokens !== void 0) attribution.add(turnText, turnTokens);
-      } catch {
       }
     };
     child.stdout.on("data", (chunk) => {
@@ -6919,6 +7059,10 @@ function spawnAgent(plan, emit) {
     });
     child.on("close", async (code) => {
       if (buf) handleLine(buf);
+      try {
+        consume(void 0, mapper.flush());
+      } catch {
+      }
       await Promise.all([endSink(rawSink), endSink(eventsSink)]);
       if (spawnFailed) return;
       const attributedTicket = attribution.winner(plan.ticket);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablation/crew",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "description": "A standing team of headless agents that picks work off a Tablation board, does it on a machine you control, and reports back.",
   "type": "module",
   "license": "MIT",