@ken-jo/agent-connector 0.4.75 → 0.4.91

package/dist/{doctor-AC437ZAW.js → doctor-3CUBPQKU.js}

@@ -2,18 +2,20 @@
 import {
   marketplaceDoctorChecks,
   syncConnector
-} from "./chunk-2L6LTQ6L.js";
-import "./chunk-OEQJGBBW.js";
+} from "./chunk-KIRCPLM4.js";
+import "./chunk-LF76VPGQ.js";
 import {
   readMarketplaceInstalls
-} from "./chunk-AXAHW2KU.js";
-import "./chunk-DI6OWKH2.js";
+} from "./chunk-QKLJU4JX.js";
+import "./chunk-UM5S7DKK.js";
+import "./chunk-NBUEL74R.js";
+import "./chunk-OPXAP3AC.js";
 import {
   fail,
   parseScope,
   parseTargets,
   print
-} from "./chunk-HKM3HUOK.js";
+} from "./chunk-7HUUINPB.js";
 import {
   LineBuffer,
   idKey,
@@ -21,42 +23,40 @@ import {
 } from "./chunk-OP4KBXUO.js";
 import {
   spawnChild
-} from "./chunk-7QRUZAUG.js";
+} from "./chunk-LN76OGNR.js";
 import {
   detectInstalledPlatforms
-} from "./chunk-TW4DVR4V.js";
+} from "./chunk-ZMLVR4J7.js";
 import {
   explainHooks
-} from "./chunk-ECSRTK4M.js";
-import "./chunk-24K6JOKV.js";
-import "./chunk-D6ZJS4ND.js";
+} from "./chunk-QARPXSIV.js";
+import "./chunk-LAIITCMW.js";
 import "./chunk-KHO5WNTP.js";
-import "./chunk-MDZG5QHB.js";
+import "./chunk-4FWETID5.js";
+import "./chunk-R6LML2YS.js";
 import {
   findConnectorConfig,
   listRegisteredConnectors,
   loadConnectorFromPath,
   readRegisteredMeta
-} from "./chunk-5LAFKXFM.js";
+} from "./chunk-NWLRJNXM.js";
 import {
   MCP_PROTOCOL_VERSION
-} from "./chunk-7ITLLYWB.js";
+} from "./chunk-G4CEELKO.js";
 import {
   REGISTERED_PLATFORM_IDS,
   loadAdapter
-} from "./chunk-Q5LECKZL.js";
-import "./chunk-7CZKXXBD.js";
-import "./chunk-OPXAP3AC.js";
-import "./chunk-UM5S7DKK.js";
+} from "./chunk-25CPWJA7.js";
+import "./chunk-56R2ER7K.js";
 import "./chunk-H53QZQJI.js";
 import "./chunk-BEFVJ2OE.js";
-import "./chunk-NUGMVVV2.js";
-import "./chunk-TO57WYBB.js";
-import "./chunk-ALVXORZM.js";
+import "./chunk-VVFDU4IX.js";
+import "./chunk-HORHRHNG.js";
+import "./chunk-YYNXIUR2.js";
 import {
   dataRoot,
   homeBinPath
-} from "./chunk-2HCJV6UO.js";
+} from "./chunk-IXOQDZWC.js";
 
 // src/cli/commands/doctor.ts
 import { parseArgs } from "util";
@@ -623,4 +623,4 @@ async function run(argv) {
 export {
   run
 };
-//# sourceMappingURL=doctor-AC437ZAW.js.map
+//# sourceMappingURL=doctor-3CUBPQKU.js.map

package/dist/{droid-HF2AIFB2.js → droid-PTCH2K7Y.js}

@@ -8,13 +8,13 @@ import {
 import {
   BaseAdapter,
   renderCommandMd
-} from "./chunk-NUGMVVV2.js";
+} from "./chunk-VVFDU4IX.js";
 import {
   buildWrappedStdio,
   isHomeBinHookCommand
-} from "./chunk-TO57WYBB.js";
-import "./chunk-ALVXORZM.js";
-import "./chunk-2HCJV6UO.js";
+} from "./chunk-HORHRHNG.js";
+import "./chunk-YYNXIUR2.js";
+import "./chunk-IXOQDZWC.js";
 
 // src/adapters/droid/index.ts
 import { existsSync } from "fs";
@@ -649,4 +649,4 @@ export {
   adapter,
   droid_default as default
 };
-//# sourceMappingURL=droid-HF2AIFB2.js.map
+//# sourceMappingURL=droid-PTCH2K7Y.js.map

package/dist/{gemini-cli-2EOK26S2.js → gemini-cli-QGLN2UMS.js}

@@ -12,7 +12,7 @@ import {
   BaseAdapter,
   renderSkillMd,
   renderSubagentMd
-} from "./chunk-NUGMVVV2.js";
+} from "./chunk-VVFDU4IX.js";
 import {
   buildHomeBinHookCommand,
   buildUsageEventCommand,
@@ -20,9 +20,9 @@ import {
   isHomeBinHookCommand,
   isHostNativeUsageEnabled,
   isUsageEventCommand
-} from "./chunk-TO57WYBB.js";
-import "./chunk-ALVXORZM.js";
-import "./chunk-2HCJV6UO.js";
+} from "./chunk-HORHRHNG.js";
+import "./chunk-YYNXIUR2.js";
+import "./chunk-IXOQDZWC.js";
 
 // src/adapters/gemini-cli/index.ts
 import { existsSync } from "fs";
@@ -770,4 +770,4 @@ export {
   adapter,
   gemini_cli_default as default
 };
-//# sourceMappingURL=gemini-cli-2EOK26S2.js.map
+//# sourceMappingURL=gemini-cli-QGLN2UMS.js.map

package/dist/{goose-55JOTXS5.js → goose-DQ6GSZ5O.js}

@@ -2,7 +2,7 @@
 import {
   readYaml,
   yamlObjectMapCodec
-} from "./chunk-IU42THN7.js";
+} from "./chunk-4NSU3KWX.js";
 import {
   roamingAppData
 } from "./chunk-UM5S7DKK.js";
@@ -17,13 +17,13 @@ import {
   removeFromObjectMap,
   renderSkillMd,
   upsertInObjectMap
-} from "./chunk-NUGMVVV2.js";
+} from "./chunk-VVFDU4IX.js";
 import {
   buildWrappedStdio,
   isHomeBinHookCommand
-} from "./chunk-TO57WYBB.js";
-import "./chunk-ALVXORZM.js";
-import "./chunk-2HCJV6UO.js";
+} from "./chunk-HORHRHNG.js";
+import "./chunk-YYNXIUR2.js";
+import "./chunk-IXOQDZWC.js";
 
 // src/adapters/goose/index.ts
 import { existsSync } from "fs";
@@ -603,4 +603,4 @@ export {
   adapter,
   goose_default as default
 };
-//# sourceMappingURL=goose-55JOTXS5.js.map
+//# sourceMappingURL=goose-DQ6GSZ5O.js.map

package/dist/grok-cli-5QD235UB.js

@@ -0,0 +1,482 @@
+#!/usr/bin/env node
+import {
+  normalizeSessionSource
+} from "./chunk-H53QZQJI.js";
+import {
+  resolveEnvRefsDeep
+} from "./chunk-BEFVJ2OE.js";
+import {
+  BaseAdapter
+} from "./chunk-VVFDU4IX.js";
+import {
+  buildWrappedStdio,
+  isHomeBinHookCommand
+} from "./chunk-HORHRHNG.js";
+import "./chunk-YYNXIUR2.js";
+import "./chunk-IXOQDZWC.js";
+
+// src/adapters/grok-cli/index.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var HOST = "grok-cli";
+var SUPPORTED_EVENTS = /* @__PURE__ */ new Set([
+  "PreToolUse",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "UserPromptSubmit",
+  "SessionStart",
+  "SessionEnd",
+  "Stop",
+  "SubagentStart",
+  "SubagentStop",
+  "PreCompact",
+  "PostCompact",
+  "Notification"
+]);
+var GrokCliAdapter = class extends BaseAdapter {
+  id = HOST;
+  name = "Grok CLI";
+  paradigm = "json-stdio";
+  capabilities = {
+    // Memory surface: Grok reads AGENTS.md ("merged from git root down to your
+    // cwd; AGENTS.override.md wins per directory" — README). The BaseAdapter
+    // AGENTS.md-first default handles it.
+    supportsMemory: true,
+    preToolUse: true,
+    postToolUse: true,
+    postToolUseFailure: true,
+    userPromptSubmit: true,
+    sessionStart: true,
+    sessionEnd: true,
+    stop: true,
+    notification: true,
+    preCompact: true,
+    // Grok fires PostCompact (its HOOK_EVENTS lists it beside PreCompact).
+    postCompact: true,
+    // Grok fires SubagentStart AND SubagentStop (both in HOOK_EVENTS).
+    subagentStart: true,
+    subagentStop: true,
+    // No PermissionRequest event in Grok's HOOK_EVENTS → warn/skip at install.
+    // Grok's reply protocol is block/approve/context only — it cannot rewrite
+    // tool args or already-emitted output.
+    canModifyArgs: false,
+    canModifyOutput: false,
+    // Grok injects `additionalContext` from a hook's stdout JSON.
+    canInjectSessionContext: true,
+    // Grok's settings.json hook keys are free-form event names (its HOOK_EVENTS
+    // superset includes StopFailure/TaskCreated/TaskCompleted/InstructionsLoaded/
+    // CwdChanged with no canonical analog), so any host event declared under
+    // platforms["grok-cli"].nativeHooks installs verbatim.
+    supportsNativeHooks: true,
+    // MCP entry supports stdio + remote (http / sse) per McpServerConfig.transport.
+    transports: ["stdio", "http", "sse"]
+  };
+  // ── Detection ────────────────────────────────────────────────────────────
+  detectInstalled(_projectDir) {
+    const userDir = join(homedir(), ".grok");
+    const userSettings = join(userDir, "user-settings.json");
+    const installed = existsSync(userDir) || existsSync(userSettings);
+    return {
+      id: this.id,
+      name: this.name,
+      installed,
+      paradigm: this.paradigm,
+      capabilities: this.capabilities,
+      // MCP + hooks both live in user-settings.json (user scope only).
+      configPath: userSettings,
+      scope: "user",
+      reason: installed ? `found Grok CLI config at ${userSettings}` : `no Grok CLI config at ${userDir}`,
+      confidence: installed ? "high" : "low"
+    };
+  }
+  // ── Native paths ───────────────────────────────────────────────────────────
+  // BOTH MCP servers (mcp.servers array) and hooks (top-level hooks map) live in
+  // the SAME user-settings.json. Project .grok/settings.json holds neither, so
+  // every scope resolves to the user file.
+  getConfigDir(_ctx) {
+    return join(homedir(), ".grok");
+  }
+  getServerConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "user-settings.json");
+  }
+  getHookConfigPath(ctx) {
+    return join(this.getConfigDir(ctx), "user-settings.json");
+  }
+  // ── MCP server install / uninstall (JSON — nested mcp.servers ARRAY) ───────
+  installServer(ctx) {
+    const { connector, dryRun } = ctx;
+    const path = this.getServerConfigPath(ctx);
+    const override = connector.platforms[HOST]?.server;
+    if (!connector.server || override === false) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          path,
+          detail: connector.server ? "server registration disabled for grok-cli" : "connector declares no MCP server"
+        }
+      ];
+    }
+    const symlink = this.symlinkPathWarning(path);
+    if (symlink) return [symlink];
+    const server = override && typeof override === "object" ? { ...connector.server, ...override } : connector.server;
+    const entry = this.renderServerEntry(ctx, server);
+    if (this.isPresentButUnparseable(path)) {
+      return [
+        {
+          platform: this.id,
+          action: "warn",
+          path,
+          detail: `existing ${path} is not parseable; left untouched (back it up / fix it, then re-run)`
+        }
+      ];
+    }
+    const cfg = this.readJson(path) ?? {};
+    const existingMcp = cfg.mcp;
+    if (existingMcp !== void 0 && (typeof existingMcp !== "object" || Array.isArray(existingMcp))) {
+      return [{ platform: this.id, action: "warn", path, detail: "mcp is not an object \u2014 left untouched (manual fix needed)" }];
+    }
+    const existingServers = existingMcp?.servers;
+    if (existingServers !== void 0 && !Array.isArray(existingServers)) {
+      return [{ platform: this.id, action: "warn", path, detail: "mcp.servers is not an array \u2014 left untouched (manual fix needed)" }];
+    }
+    const list = Array.isArray(existingServers) ? [...existingServers] : [];
+    const idx = list.findIndex((e) => e?.id === connector.id);
+    let action;
+    if (idx < 0) {
+      list.push(entry);
+      action = "create";
+    } else if (JSON.stringify(list[idx]) === JSON.stringify(entry)) {
+      action = "skip";
+    } else {
+      list[idx] = entry;
+      action = "update";
+    }
+    if (action !== "skip") {
+      cfg.mcp = { ...existingMcp ?? {}, servers: list };
+      this.writeJson(path, cfg, dryRun);
+    }
+    return [{ platform: this.id, action, path, detail: `mcp.servers[id=${connector.id}]` }];
+  }
+  uninstallServer(ctx) {
+    const { connector, dryRun } = ctx;
+    const path = this.getServerConfigPath(ctx);
+    const symlink = this.symlinkPathWarning(path);
+    if (symlink) return [symlink];
+    const cfg = this.readJson(path);
+    const rawList = cfg?.mcp?.servers;
+    if (!cfg || !Array.isArray(rawList)) {
+      return [{ platform: this.id, action: "skip", path, detail: `mcp.servers[id=${connector.id}] absent` }];
+    }
+    const list = rawList;
+    const kept = list.filter((e) => e?.id !== connector.id);
+    if (kept.length === list.length) {
+      return [{ platform: this.id, action: "skip", path, detail: `mcp.servers[id=${connector.id}] absent` }];
+    }
+    cfg.mcp = { ...cfg.mcp, servers: kept };
+    this.writeJson(path, cfg, dryRun);
+    return [{ platform: this.id, action: "remove", path, detail: `mcp.servers[id=${connector.id}]` }];
+  }
+  /** Render a normalized ServerDef into Grok's native McpServerConfig entry. */
+  renderServerEntry(ctx, server) {
+    const transport = server.transport;
+    const enabled = server.enabled !== false;
+    const id = ctx.connector.id;
+    const label = ctx.connector.displayName?.trim() || id;
+    if (transport === "stdio") {
+      let command = server.command ?? "";
+      let args = [...server.args ?? []];
+      ({ command, args } = buildWrappedStdio(ctx, server, this.id, command, args));
+      const entry2 = {
+        id,
+        label,
+        enabled,
+        transport: "stdio",
+        command: resolveEnvRefsDeep(command)
+      };
+      if (args.length > 0) entry2.args = resolveEnvRefsDeep(args);
+      const env = this.renderEnv(server.env);
+      if (env) entry2.env = env;
+      if (typeof server.cwd === "string" && server.cwd.length > 0) {
+        entry2.cwd = resolveEnvRefsDeep(server.cwd);
+      }
+      return entry2;
+    }
+    const entry = {
+      id,
+      label,
+      enabled,
+      transport: transport === "sse" ? "sse" : "http",
+      url: resolveEnvRefsDeep(server.url ?? "")
+    };
+    const headers = this.renderEnv(server.headers);
+    if (headers) entry.headers = headers;
+    return entry;
+  }
+  /**
+   * Render env/header values. Grok documents no native ${VAR} server
+   * interpolation, so resolve `${env:VAR}` references to literals at install
+   * time (the safe path; matches continue/droid).
+   */
+  renderEnv(env) {
+    if (!env || Object.keys(env).length === 0) return void 0;
+    return resolveEnvRefsDeep({ ...env });
+  }
+  // ── Hook install / uninstall (top-level hooks, Claude nested-rule shape) ───
+  installHooks(ctx) {
+    const { connector } = ctx;
+    const override = connector.platforms[HOST];
+    const normalizedEvents = override?.hooks === false ? [] : connector.hookEvents;
+    const nativeHooks = override?.nativeHooks ?? {};
+    const nativeEvents = Object.keys(nativeHooks);
+    if (normalizedEvents.length === 0 && nativeEvents.length === 0) {
+      return [
+        {
+          platform: this.id,
+          action: "skip",
+          detail: override?.hooks === false ? "hooks disabled for grok-cli" : "connector declares no hooks"
+        }
+      ];
+    }
+    const pending = normalizedEvents.map((event) => ({
+      event,
+      matcher: connector.hooks[event]?.matcher ?? ""
+    }));
+    const native = nativeEvents.map((event) => ({
+      event,
+      matcher: nativeHooks[event]?.matcher ?? ""
+    }));
+    return this.upsertHookEntries(
+      ctx,
+      this.getHookConfigPath(ctx),
+      pending,
+      this.hookDescriptor(ctx),
+      native
+    );
+  }
+  uninstallHooks(ctx) {
+    return this.removeHookEntries(ctx, this.getHookConfigPath(ctx), this.hookDescriptor(ctx));
+  }
+  /**
+   * Grok's hook-merge descriptor (NESTED shape `{ matcher?, hooks: [...] }`).
+   * Connector-generic ownership (any of our home-bin commands in the inner
+   * `hooks`), matching droid:
+   *  - mapEvent drops events outside SUPPORTED_EVENTS (Grok has no
+   *    PermissionRequest); supported events map 1:1 (PascalCase identical);
+   *  - the native pass installs free-form host-only event keys verbatim;
+   *  - uninstall = inner-strip ONLY (ownsEntryForRemove never-true).
+   */
+  hookDescriptor(ctx) {
+    const stripInner = (c) => (entry) => {
+      const innerBefore = entry.hooks?.length ?? 0;
+      const inner = (entry.hooks ?? []).filter((h) => !this.isOurCommand(h.command, c));
+      return {
+        next: inner.length > 0 ? { matcher: entry.matcher ?? "", hooks: inner } : null,
+        removed: innerBefore - inner.length
+      };
+    };
+    return {
+      mapEvent: (e) => SUPPORTED_EVENTS.has(e) ? e : void 0,
+      unmappedWarnDetail: (e) => `${e} has no Grok CLI hook equivalent \u2014 skipped`,
+      renderEntry: (_event, matcher, command) => ({
+        matcher,
+        hooks: [{ type: "command", command }]
+      }),
+      entryOwnsCommand: (entry, _command) => (entry.hooks ?? []).some((h) => this.isOurCommand(h.command, ctx)),
+      nativeOwnsCommand: (entry, command) => (entry.hooks ?? []).some((h) => h.command === command),
+      ownsEntryForRemove: () => () => false,
+      stripInner,
+      skipDetail: (event) => `hooks.${event} already registered`,
+      removeDetail: (event, removed) => `hooks.${event} (${removed})`,
+      nativeSkipDetail: (event) => `hooks.${event} already registered (native)`,
+      nativeMutateDetail: (event) => `hooks.${event} (native)`,
+      absentDetail: "no hooks section present",
+      noMatchDetail: "no matching hook entries"
+    };
+  }
+  /** True when a hook command references our home binary AND this connector id. */
+  isOurCommand(command, ctx) {
+    return isHomeBinHookCommand(command, ctx.homeBinPath, ctx.connector.id);
+  }
+  // ── Diagnostics ──────────────────────────────────────────────────────────
+  getHealthChecks(ctx) {
+    const path = this.getServerConfigPath(ctx);
+    const connectorId = ctx.connector.id;
+    const homeBin = ctx.homeBinPath;
+    const hookEvents = ctx.connector.hookEvents;
+    return [
+      {
+        name: `${this.name}: user-settings.json present`,
+        check: () => existsSync(path) ? { status: "OK", detail: path } : { status: "FAIL", detail: `not found: ${path}` }
+      },
+      {
+        name: `${this.name}: server entry registered`,
+        check: () => {
+          if (!ctx.connector.server) {
+            return { status: "OK", detail: "no MCP server declared" };
+          }
+          const cfg = this.readJson(path);
+          const list = cfg?.mcp?.servers;
+          if (!cfg || !Array.isArray(list)) {
+            return { status: "FAIL", detail: `no mcp.servers array in ${path}` };
+          }
+          return list.some((e) => e?.id === connectorId) ? { status: "OK", detail: `mcp.servers[id=${connectorId}] present` } : { status: "FAIL", detail: `no mcp.servers[id=${connectorId}] in ${path}` };
+        }
+      },
+      {
+        name: `${this.name}: hook command registered`,
+        check: () => {
+          if (hookEvents.length === 0) {
+            return { status: "OK", detail: "no hooks declared" };
+          }
+          const cfg = this.readJson(path);
+          const hooks = cfg?.hooks ?? {};
+          const registered = Object.values(hooks).some(
+            (entries) => (entries ?? []).some(
+              (e) => (e.hooks ?? []).some((h) => isHomeBinHookCommand(h.command, homeBin, connectorId))
+            )
+          );
+          return registered ? { status: "OK", detail: "hook command present" } : { status: "FAIL", detail: `no hook for ${connectorId} in ${path}` };
+        }
+      }
+    ];
+  }
+  // ── Runtime: parse Grok stdin JSON → normalized event ──────────────────────
+  parseEvent(event, raw) {
+    const input = raw ?? {};
+    const connectorId = typeof input.connector === "string" ? input.connector : "";
+    const sessionId = typeof input.session_id === "string" ? input.session_id : "";
+    const projectDir = typeof input.cwd === "string" ? input.cwd : void 0;
+    const base = {
+      hostPlatform: HOST,
+      connectorId,
+      sessionId,
+      raw,
+      ...projectDir !== void 0 ? { projectDir } : {}
+    };
+    switch (event) {
+      case "PreToolUse": {
+        const ev = {
+          ...base,
+          toolName: typeof input.tool_name === "string" ? input.tool_name : "",
+          toolInput: input.tool_input ?? {}
+        };
+        return ev;
+      }
+      case "PostToolUse": {
+        const ev = {
+          ...base,
+          toolName: typeof input.tool_name === "string" ? input.tool_name : "",
+          toolInput: input.tool_input ?? {},
+          ...toolOutputToString(input.tool_output) !== void 0 ? { toolOutput: toolOutputToString(input.tool_output) } : {}
+        };
+        return ev;
+      }
+      case "PostToolUseFailure": {
+        const ev = {
+          ...base,
+          toolName: typeof input.tool_name === "string" ? input.tool_name : "",
+          toolInput: input.tool_input ?? {},
+          error: typeof input.error === "string" ? input.error : ""
+        };
+        return ev;
+      }
+      case "UserPromptSubmit": {
+        const ev = {
+          ...base,
+          prompt: typeof input.user_prompt === "string" ? input.user_prompt : ""
+        };
+        return ev;
+      }
+      case "SessionStart": {
+        const ev = {
+          ...base,
+          source: normalizeSessionSource(input.source)
+        };
+        return ev;
+      }
+      case "SessionEnd": {
+        const ev = { ...base };
+        return ev;
+      }
+      case "Stop": {
+        const ev = { ...base };
+        return ev;
+      }
+      case "Notification": {
+        const ev = {
+          ...base,
+          message: typeof input.message === "string" ? input.message : ""
+        };
+        return ev;
+      }
+      case "PreCompact": {
+        const ev = {
+          ...base,
+          ...input.trigger === "auto" || input.trigger === "manual" ? { trigger: input.trigger } : {}
+        };
+        return ev;
+      }
+      case "PostCompact": {
+        const ev = {
+          ...base,
+          ...input.trigger === "auto" || input.trigger === "manual" ? { trigger: input.trigger } : {}
+        };
+        return ev;
+      }
+      case "SubagentStart": {
+        const ev = {
+          ...base,
+          ...typeof input.agent_type === "string" ? { agentType: input.agent_type } : {}
+        };
+        return ev;
+      }
+      case "SubagentStop": {
+        const ev = {
+          ...base,
+          ...typeof input.agent_type === "string" ? { agentType: input.agent_type } : {}
+        };
+        return ev;
+      }
+      default: {
+        throw new Error(`unsupported grok-cli hook event: ${String(event)}`);
+      }
+    }
+  }
+  // ── Runtime: normalized response → Grok native hook reply ──────────────────
+  // Grok parses stdout as JSON when it starts with `{` and aggregates:
+  //   decision:"block" (or exit 2) → block; decision:"approve" → approve;
+  //   additionalContext → injected context; continue:false + stopReason → halt.
+  // We emit exit 0 + a structured stdout object so the JSON is always parsed.
+  formatReply(_event, response) {
+    const decision = response.decision ?? "allow";
+    if (decision === "deny") {
+      return this.stdout({ decision: "block", reason: response.reason ?? "Blocked by hook" });
+    }
+    if (decision === "context" && response.additionalContext) {
+      return this.stdout({ additionalContext: response.additionalContext });
+    }
+    return { exitCode: 0 };
+  }
+  stdout(payload) {
+    return { exitCode: 0, stdout: JSON.stringify(payload) };
+  }
+};
+function toolOutputToString(value) {
+  if (value == null) return void 0;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+var adapter = new GrokCliAdapter();
+var grok_cli_default = adapter;
+export {
+  GrokCliAdapter,
+  adapter,
+  grok_cli_default as default
+};
+//# sourceMappingURL=grok-cli-5QD235UB.js.map