@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-EJIWTPSZ.js

@@ -0,0 +1,1063 @@
+import {
+  isProviderStderrOnlyRecoverableNoise,
+  stripAnsiControlSequences
+} from "./chunk-MYLH2S4G.js";
+import {
+  isUnknownErrorRetryable
+} from "./chunk-3P5IN5E7.js";
+import {
+  buildGrokArgv,
+  createGrokCliChildEnv,
+  metadata
+} from "./chunk-2Y2IIHPI.js";
+import {
+  resolveProviderReportedCostUsd
+} from "./chunk-WEI3ZDZH.js";
+import {
+  normalizeTokenUsage
+} from "./chunk-H6MJGKAW.js";
+import {
+  createLineDelimitedTmuxCompletionSignal,
+  executeProviderCommand
+} from "./chunk-633XZ7UF.js";
+import {
+  isSkipAuthEnvActive
+} from "./chunk-33IGPPUI.js";
+import {
+  requireActivePolicyBoundary
+} from "./chunk-B7YRSULE.js";
+import {
+  mkBuildTempDir
+} from "./chunk-D6WTZMZB.js";
+import {
+  resolveProviderCliCommand
+} from "./chunk-KKQKWAMF.js";
+import {
+  ProviderExecutionError
+} from "./chunk-RRC5BL7B.js";
+import {
+  isCapacityError,
+  isRateLimitError
+} from "./chunk-M6UHOC4I.js";
+import {
+  BUILD_GROK_ALLOW_BROWSER_AUTH,
+  BUILD_GROK_AUTH_PROBE_TIMEOUT_MS,
+  BUILD_SKIP_AUTH,
+  isDebugMode,
+  readRawEnv
+} from "./chunk-7VRJHTGZ.js";
+import {
+  sanitizeString
+} from "./chunk-CPSVQR2I.js";
+
+// src/core/providers/grok/auth.ts
+import { readFile, rm, writeFile } from "fs/promises";
+import path2 from "path";
+
+// src/core/providers/grok/auth-file.ts
+import { stat } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+var GROK_AUTH_FILE_MIN_SIZE = 100;
+var GROK_AUTH_FILE_MODE = 384;
+function grokAuthFilePath(env) {
+  return path.join(env?.HOME?.trim() || homedir(), ".grok", "auth.json");
+}
+async function probeGrokAuthFile(env) {
+  try {
+    const info = await stat(grokAuthFilePath(env));
+    if (!info.isFile()) {
+      return "no";
+    }
+    if (info.size < GROK_AUTH_FILE_MIN_SIZE) {
+      return "no";
+    }
+    if (process.platform !== "win32") {
+      const permissionBits = info.mode & 511;
+      if (permissionBits !== GROK_AUTH_FILE_MODE) {
+        return "no";
+      }
+    }
+    return "yes";
+  } catch (error) {
+    const code = error?.code;
+    if (code === "ENOENT") {
+      return "unknown";
+    }
+    if (code === "EACCES" || code === "EPERM") {
+      return "no";
+    }
+    return "unknown";
+  }
+}
+
+// src/core/providers/grok/error-category.ts
+var GROK_UNKNOWN_ERROR_POLICY = "fail";
+function hasProviderTransportDeathEvidence(haystack) {
+  return /Transport channel closed.*Auth\(AuthorizationRequired\)/i.test(haystack) || /Auth\(AuthorizationRequired\).*Transport channel closed/i.test(haystack) || /worker quit with fatal/i.test(haystack) || /Transport channel closed/i.test(haystack);
+}
+function isMaxTurnsExceededMessage(haystack) {
+  return /max[_\s-]?turns(?:[_\s-]?(?:exceeded|reached))?/i.test(haystack) || /max_turns_reached/i.test(haystack) || /turn limit/i.test(haystack);
+}
+function categorizeError(message, inner) {
+  const haystack = `${message}
+${inner?.code ?? ""}
+${inner?.detail ?? ""}
+${inner?.message ?? ""}`;
+  if (/FS_PERMISSION_DENIED/i.test(haystack)) return "fs_permission_denied";
+  if (hasProviderTransportDeathEvidence(haystack)) {
+    return "provider_transport_failure";
+  }
+  if (/AuthorizationRequired|Authentication|not authenticated/i.test(haystack)) return "auth";
+  if (isMaxTurnsExceededMessage(haystack)) return "max_turns_exceeded";
+  const statusContext = inner?.httpStatus !== void 0 ? `
+status: ${inner.httpStatus}` : "";
+  const statusHaystack = `${haystack}${statusContext}`;
+  if (isRateLimitError(statusHaystack) || /rate[_\s-]?limit/i.test(haystack) || /\b429\b/.test(haystack)) {
+    return "rate_limit";
+  }
+  if (isCapacityError(statusHaystack)) {
+    return "capacity";
+  }
+  if (/\bECONNRESET\b/i.test(haystack) || /\bETIMEDOUT\b/i.test(haystack) || /\bENOTFOUND\b/i.test(haystack) || /\bECONNREFUSED\b/i.test(haystack) || /socket hang up/i.test(haystack) || /connection refused/i.test(haystack) || /network (?:error|failure|unreachable)/i.test(haystack) || /fetch failed/i.test(haystack)) {
+    return "network";
+  }
+  if (/does not support parameter/i.test(haystack) || inner?.httpStatus === 400) {
+    return "model_rejection";
+  }
+  if (/Internal error|API error/i.test(haystack)) return "runtime";
+  return "unknown";
+}
+function grokCategoryToRetryable(category) {
+  if (category === "unknown") return isUnknownErrorRetryable(GROK_UNKNOWN_ERROR_POLICY);
+  return category === "rate_limit" || category === "capacity" || category === "network" || category === "cancelled_incomplete";
+}
+
+// src/core/providers/grok/reported-cost.ts
+function readGrokTotalCostUsd(obj) {
+  const data = obj.data && typeof obj.data === "object" && !Array.isArray(obj.data) ? obj.data : void 0;
+  for (const source of [obj, data]) {
+    const value = source?.total_cost_usd ?? source?.totalCostUsd;
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) return value;
+  }
+  return void 0;
+}
+
+// src/core/providers/grok/stream-message-join.ts
+var STREAM_TEXT_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "answer",
+  "assistant",
+  "completion",
+  "content",
+  "delta",
+  "final",
+  "message",
+  "output",
+  "response",
+  "result",
+  "success",
+  "text"
+]);
+var MESSAGE_BOUNDARY_TYPE = /tool|step|thought/i;
+function isStreamMessageBoundary(type) {
+  return typeof type === "string" && MESSAGE_BOUNDARY_TYPE.test(type);
+}
+function prefixMessageSeparator(previousChunks, chunk, boundary) {
+  if (!boundary || previousChunks.length === 0 || chunk.length === 0) return chunk;
+  const previous = previousChunks.join("");
+  if (previous.length === 0 || /\s$/.test(previous) || /^\s/.test(chunk)) return chunk;
+  return `
+
+${chunk}`;
+}
+
+// src/core/providers/grok/error-parser.ts
+function reportedModelUsageKey(obj) {
+  const modelUsage = obj.modelUsage;
+  if (!modelUsage || typeof modelUsage !== "object" || Array.isArray(modelUsage)) {
+    return void 0;
+  }
+  const ids = Object.keys(modelUsage).filter((id) => id.trim().length > 0);
+  return ids.length === 1 ? ids[0] : void 0;
+}
+function catalogModelId(reported) {
+  return reported.replace(/-build$/, "");
+}
+var TERMINAL_SUCCESS_STOP_REASONS = /* @__PURE__ */ new Set(["endturn"]);
+var ABORTED_STOP_REASONS = /* @__PURE__ */ new Set(["cancelled", "abort", "aborted"]);
+function normalizeStopReason(stopReason) {
+  if (typeof stopReason !== "string") return void 0;
+  const normalized = stopReason.trim().toLowerCase().replace(/[\s._-]+/g, "");
+  return normalized.length > 0 ? normalized : void 0;
+}
+function isTerminalSuccessStopReason(stopReason) {
+  const normalized = normalizeStopReason(stopReason);
+  return normalized !== void 0 && TERMINAL_SUCCESS_STOP_REASONS.has(normalized);
+}
+function isAbortedStopReason(stopReason) {
+  const normalized = normalizeStopReason(stopReason);
+  return normalized !== void 0 && ABORTED_STOP_REASONS.has(normalized);
+}
+function isAbortedSuccessEnvelope(stopReason) {
+  return isAbortedStopReason(stopReason);
+}
+function isConcludingStopReason(stopReason) {
+  return isTerminalSuccessStopReason(stopReason) || isAbortedStopReason(stopReason);
+}
+function isGrokTerminalEnvelope(obj) {
+  const record = asRecord(obj);
+  if (!record) return false;
+  const type = typeof record.type === "string" ? record.type.toLowerCase() : void 0;
+  if (type === "error") return true;
+  const isSuccessShaped = typeof record.text === "string" || type === void 0 || type !== void 0 && TERMINAL_SUCCESS_EVENT_TYPES.has(type) || type === "end";
+  if (!isSuccessShaped) return false;
+  const data = asRecord(record.data);
+  const stopReason = readStringField(record, "stopReason", "stop_reason") ?? (data ? readStringField(data, "stopReason", "stop_reason") : void 0);
+  return isConcludingStopReason(stopReason);
+}
+function isGrokTerminalSuccessEnvelope(obj) {
+  const record = asRecord(obj);
+  if (!record) return false;
+  const type = typeof record.type === "string" ? record.type.toLowerCase() : void 0;
+  if (type === "error") return false;
+  const isSuccessShaped = typeof record.text === "string" || type === void 0 || type !== void 0 && TERMINAL_SUCCESS_EVENT_TYPES.has(type) || type === "end";
+  if (!isSuccessShaped) return false;
+  const data = asRecord(record.data);
+  const stopReason = readStringField(record, "stopReason", "stop_reason") ?? (data ? readStringField(data, "stopReason", "stop_reason") : void 0);
+  return isTerminalSuccessStopReason(stopReason);
+}
+function capturedStdoutHasTerminalEnvelope(stdout) {
+  if (!stdout || !stdout.trim()) return false;
+  for (const obj of findJsonObjects(stdout)) {
+    const record = asRecord(obj);
+    if (!record) continue;
+    const type = typeof record.type === "string" ? record.type.toLowerCase() : void 0;
+    if (type === "error") return true;
+    if (isGrokTerminalSuccessEnvelope(obj)) return true;
+  }
+  return false;
+}
+function grokLineConcludes(line) {
+  const trimmed = line.trim();
+  if (trimmed[0] !== "{") return false;
+  const parsed = tryParseJson(trimmed);
+  return isGrokTerminalEnvelope(parsed);
+}
+function createGrokTmuxCompletionSignal() {
+  const lineSignal = createLineDelimitedTmuxCompletionSignal(grokLineConcludes);
+  let accumulated = "";
+  let concluded = false;
+  const MAX_ACCUMULATED_BYTES = 8 * 1024 * 1024;
+  return (chunk, stream) => {
+    if (concluded) return true;
+    if (lineSignal(chunk, stream)) {
+      concluded = true;
+      return true;
+    }
+    if (stream !== "stdout" || !chunk) return false;
+    if (accumulated.length <= MAX_ACCUMULATED_BYTES) {
+      accumulated += chunk;
+      if (accumulated.trimEnd().endsWith("}")) {
+        for (const obj of findJsonObjects(accumulated)) {
+          if (isGrokTerminalEnvelope(obj)) {
+            concluded = true;
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  };
+}
+function isStderrOnlyNoise(stderr) {
+  return isProviderStderrOnlyRecoverableNoise("grok", stderr);
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function findBalancedJsonTexts(text) {
+  const results = [];
+  let start = -1;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  const stack = [];
+  for (let i = 0; i < text.length; i += 1) {
+    const char = text[i];
+    if (start < 0) {
+      if (char === "{" || char === "[") {
+        start = i;
+        depth = 1;
+        stack.push(char === "{" ? "}" : "]");
+      }
+      continue;
+    }
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "{" || char === "[") {
+      depth += 1;
+      stack.push(char === "{" ? "}" : "]");
+      continue;
+    }
+    if (char === "}" || char === "]") {
+      const expected = stack.pop();
+      if (char !== expected) {
+        start = -1;
+        depth = 0;
+        inString = false;
+        escaped = false;
+        stack.length = 0;
+        continue;
+      }
+      depth -= 1;
+      if (depth === 0) {
+        results.push(text.slice(start, i + 1));
+        start = -1;
+        inString = false;
+        escaped = false;
+        stack.length = 0;
+      }
+    }
+  }
+  return results;
+}
+function appendJsonObject(value, values) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (item && typeof item === "object") values.push(item);
+    }
+    return;
+  }
+  if (value && typeof value === "object") values.push(value);
+}
+function findJsonObjects(stdout) {
+  if (!stdout) return [];
+  const trimmed = stdout.trim();
+  if (!trimmed) return [];
+  const whole = tryParseJson(trimmed);
+  if (whole && typeof whole === "object") {
+    const values2 = [];
+    appendJsonObject(whole, values2);
+    return values2;
+  }
+  const values = [];
+  for (const balanced of findBalancedJsonTexts(trimmed)) {
+    const parsed = tryParseJson(balanced);
+    appendJsonObject(parsed, values);
+  }
+  if (values.length > 0) return values;
+  for (const line of trimmed.split(/\r?\n/)) {
+    const t = line.trim();
+    if (!t || t[0] !== "{" && t[0] !== "[") continue;
+    const parsed = tryParseJson(t);
+    appendJsonObject(parsed, values);
+  }
+  return values;
+}
+function readStringField(obj, camelKey, snakeKey) {
+  const camel = obj[camelKey];
+  if (typeof camel === "string") return camel;
+  if (snakeKey) {
+    const snake = obj[snakeKey];
+    if (typeof snake === "string") return snake;
+  }
+  return void 0;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+var TERMINAL_SUCCESS_EVENT_TYPES = /* @__PURE__ */ new Set(["final", "result", "success"]);
+function buildSuccessEnvelope(obj, text, accumulatedThought) {
+  const data = asRecord(obj.data);
+  const success = {
+    type: "success",
+    text
+  };
+  const stopReason = readStringField(obj, "stopReason", "stop_reason") ?? (data ? readStringField(data, "stopReason", "stop_reason") : void 0);
+  const sessionId = readStringField(obj, "sessionId", "session_id") ?? (data ? readStringField(data, "sessionId", "session_id") : void 0);
+  const requestId = readStringField(obj, "requestId", "request_id") ?? (data ? readStringField(data, "requestId", "request_id") : void 0);
+  const thought = readStringField(obj, "thought") ?? (data ? readStringField(data, "thought") : void 0) ?? accumulatedThought;
+  if (stopReason) success.stopReason = stopReason;
+  if (sessionId) success.sessionId = sessionId;
+  if (requestId) success.requestId = requestId;
+  if (thought) success.thought = thought;
+  const usage = obj.usage ?? data?.usage;
+  if (usage && typeof usage === "object" && !Array.isArray(usage)) {
+    success.tokenUsage = normalizeTokenUsage(usage, "grok");
+  }
+  return success;
+}
+function extractTokenUsageFromObject(obj) {
+  const data = asRecord(obj.data);
+  const usageCandidates = [obj.usage, data?.usage];
+  const type = typeof obj.type === "string" ? obj.type.toLowerCase() : void 0;
+  if (type === "usage") {
+    usageCandidates.push(data);
+  }
+  for (const candidate of usageCandidates) {
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) continue;
+    const usage = normalizeTokenUsage(candidate, "grok");
+    if (usage) return usage;
+  }
+  return void 0;
+}
+function isStepUsageEventType(type) {
+  if (typeof type !== "string") return false;
+  return /^step[-_.]?finish$/i.test(type);
+}
+function sumTokenUsages(usages) {
+  if (usages.length === 0) return void 0;
+  if (usages.length === 1) return usages[0];
+  const usage = usages.reduce(
+    (sum, current) => ({
+      inputTokens: sum.inputTokens + current.inputTokens,
+      outputTokens: sum.outputTokens + current.outputTokens,
+      cachedInputTokens: (sum.cachedInputTokens ?? 0) + (current.cachedInputTokens ?? 0),
+      cacheCreationInputTokens: (sum.cacheCreationInputTokens ?? 0) + (current.cacheCreationInputTokens ?? 0)
+    }),
+    {
+      inputTokens: 0,
+      outputTokens: 0,
+      cachedInputTokens: 0,
+      cacheCreationInputTokens: 0
+    }
+  );
+  return {
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    ...usage.cachedInputTokens > 0 ? { cachedInputTokens: usage.cachedInputTokens } : {},
+    ...usage.cacheCreationInputTokens > 0 ? { cacheCreationInputTokens: usage.cacheCreationInputTokens } : {},
+    totalTokens: usage.inputTokens + usage.outputTokens
+  };
+}
+function extractSuccessEnvelope(obj, accumulatedThought) {
+  if (typeof obj.text === "string") {
+    return buildSuccessEnvelope(obj, obj.text, accumulatedThought);
+  }
+  const type = typeof obj.type === "string" ? obj.type.toLowerCase() : void 0;
+  if (!type || !TERMINAL_SUCCESS_EVENT_TYPES.has(type)) return void 0;
+  if (typeof obj.data === "string") {
+    return buildSuccessEnvelope(obj, obj.data, accumulatedThought);
+  }
+  const data = asRecord(obj.data);
+  const dataText = data ? readStringField(data, "text") : void 0;
+  if (dataText !== void 0) {
+    return buildSuccessEnvelope(obj, dataText, accumulatedThought);
+  }
+  const message = asRecord(obj.message);
+  const messageText = message ? readStringField(message, "text") : void 0;
+  if (messageText !== void 0) {
+    return buildSuccessEnvelope(obj, messageText, accumulatedThought);
+  }
+  return void 0;
+}
+function extractStreamTextChunk(obj) {
+  const type = typeof obj.type === "string" ? obj.type.toLowerCase() : void 0;
+  if (!type || !STREAM_TEXT_EVENT_TYPES.has(type) || type === "success" || type === "result") {
+    return void 0;
+  }
+  if (typeof obj.data === "string") return obj.data;
+  const data = asRecord(obj.data);
+  return data ? readStringField(data, "text") : void 0;
+}
+function extractInnerFromMessage(message) {
+  if (!message) return void 0;
+  const firstBrace = message.indexOf("{");
+  if (firstBrace < 0) return void 0;
+  const candidate = message.slice(firstBrace).trim();
+  const parsed = tryParseJson(candidate);
+  if (!parsed || typeof parsed !== "object") return void 0;
+  const inner = {};
+  if (typeof parsed.code === "string") inner.code = parsed.code;
+  if (typeof parsed.detail === "string") inner.detail = parsed.detail;
+  if (typeof parsed.http_status === "number") inner.httpStatus = parsed.http_status;
+  if (typeof parsed.message === "string") inner.message = parsed.message;
+  return Object.keys(inner).length > 0 ? inner : void 0;
+}
+function readStopReason(obj) {
+  const data = asRecord(obj.data);
+  return readStringField(obj, "stopReason", "stop_reason") ?? (data ? readStringField(data, "stopReason", "stop_reason") : void 0);
+}
+function hasTerminalSuccessSemantics(obj, stopReason) {
+  if (isAbortedStopReason(stopReason)) return false;
+  if (isTerminalSuccessStopReason(stopReason)) return true;
+  const type = typeof obj.type === "string" ? obj.type.toLowerCase() : void 0;
+  return type !== void 0 && TERMINAL_SUCCESS_EVENT_TYPES.has(type);
+}
+function buildAbortedRunError(stopReason, text, stderr, stdout = "") {
+  const stderrClean = stripAnsiControlSequences(stderr).trim();
+  const textNote = text.trim().length > 0 ? "non-empty partial output" : "empty output";
+  const message = `grok run aborted before completion (stopReason=${stopReason ?? "unknown"}, ${textNote})`;
+  const transportDeathHaystack = `${stdout}
+${stderrClean}
+${text}`;
+  if (hasProviderTransportDeathEvidence(transportDeathHaystack) || stderrClean.length > 0 && isStderrOnlyNoise(stderr)) {
+    return { type: "error", message, category: "provider_transport_failure" };
+  }
+  const category = categorizeError(`${stopReason ?? ""}
+${stderrClean}`);
+  return {
+    type: "error",
+    message,
+    category: category === "unknown" ? "cancelled_incomplete" : category
+  };
+}
+function parseGrokOutput(stdout, stderr, exitCode) {
+  const objects = findJsonObjects(stdout);
+  if (objects.length === 0) {
+    const stderrClean = stripAnsiControlSequences(stderr).trim();
+    const stdoutClean = stripAnsiControlSequences(stdout).trim();
+    const message = [stdoutClean, stderrClean].filter(Boolean).join("\n") || `grok exited with code ${exitCode} and no parseable JSON on stdout`;
+    const category = categorizeError(message);
+    return {
+      type: "error",
+      message,
+      category: category === "unknown" ? "runtime" : category
+    };
+  }
+  const thoughtChunks = [];
+  const textChunks = [];
+  let success;
+  let abortedStopReason;
+  let abortedText = "";
+  let sawTerminalSuccessStop = false;
+  let atMessageBoundary = false;
+  let terminalEndMeta;
+  let latestFinalTokenUsage;
+  let reportedModel;
+  let reportedCostUsd;
+  const stepTokenUsages = [];
+  for (const obj of objects) {
+    reportedModel ??= reportedModelUsageKey(obj);
+    if (isStreamMessageBoundary(obj.type)) atMessageBoundary = true;
+    if (obj.type === "error") {
+      const message = typeof obj.message === "string" ? obj.message : JSON.stringify(obj.message);
+      const inner = extractInnerFromMessage(message);
+      const category = categorizeError(
+        `${message}
+${stripAnsiControlSequences(stderr).trim()}`,
+        inner
+      );
+      return {
+        type: "error",
+        message,
+        inner,
+        category
+      };
+    }
+    reportedCostUsd = readGrokTotalCostUsd(obj) ?? reportedCostUsd;
+    const tokenUsage = extractTokenUsageFromObject(obj);
+    if (tokenUsage) {
+      if (isStepUsageEventType(obj.type)) {
+        stepTokenUsages.push(tokenUsage);
+      } else {
+        latestFinalTokenUsage = tokenUsage;
+      }
+    }
+    if (obj.type === "thought" && typeof obj.data === "string") {
+      thoughtChunks.push(obj.data);
+      continue;
+    }
+    const stopReason = readStopReason(obj);
+    const type = typeof obj.type === "string" ? obj.type.toLowerCase() : void 0;
+    if (type === "end") {
+      if (isAbortedStopReason(stopReason)) {
+        abortedStopReason = stopReason;
+        continue;
+      }
+      if (isTerminalSuccessStopReason(stopReason)) {
+        sawTerminalSuccessStop = true;
+        terminalEndMeta = obj;
+        continue;
+      }
+    }
+    const accumulatedThought = thoughtChunks.length > 0 ? thoughtChunks.join("") : void 0;
+    const parsedSuccess = extractSuccessEnvelope(obj, accumulatedThought);
+    if (parsedSuccess) {
+      if (isAbortedSuccessEnvelope(parsedSuccess.stopReason)) {
+        abortedStopReason = parsedSuccess.stopReason;
+        abortedText = parsedSuccess.text;
+        continue;
+      }
+      if (hasTerminalSuccessSemantics(obj, parsedSuccess.stopReason)) {
+        success = parsedSuccess;
+        if (isTerminalSuccessStopReason(parsedSuccess.stopReason)) {
+          sawTerminalSuccessStop = true;
+        }
+        continue;
+      }
+      if (parsedSuccess.text.length > 0) {
+        textChunks.push(prefixMessageSeparator(textChunks, parsedSuccess.text, atMessageBoundary));
+        atMessageBoundary = false;
+      }
+      continue;
+    }
+    const chunk = extractStreamTextChunk(obj);
+    if (chunk !== void 0) {
+      textChunks.push(prefixMessageSeparator(textChunks, chunk, atMessageBoundary));
+      if (chunk.length > 0) atMessageBoundary = false;
+    }
+  }
+  if (abortedStopReason !== void 0) {
+    return buildAbortedRunError(
+      abortedStopReason,
+      abortedText || textChunks.join(""),
+      stderr,
+      stdout
+    );
+  }
+  if (!success && sawTerminalSuccessStop) {
+    const accumulatedThought = thoughtChunks.length > 0 ? thoughtChunks.join("") : void 0;
+    success = buildSuccessEnvelope(
+      terminalEndMeta ?? { stopReason: "EndTurn" },
+      textChunks.join(""),
+      accumulatedThought
+    );
+  } else if (success && success.text.length === 0 && textChunks.length > 0) {
+    success = { ...success, text: textChunks.join("") };
+  }
+  if (success) {
+    if (reportedModel) {
+      success.reportedModel = reportedModel;
+      success.resolvedModel = catalogModelId(reportedModel);
+    }
+    const tokenUsage = latestFinalTokenUsage ?? sumTokenUsages(stepTokenUsages);
+    if (tokenUsage) {
+      success.tokenUsage = tokenUsage;
+    }
+    const providerReportedCostUsd = resolveProviderReportedCostUsd(
+      reportedCostUsd,
+      success.tokenUsage
+    );
+    if (providerReportedCostUsd !== void 0) {
+      success.providerReportedCostUsd = providerReportedCostUsd;
+    }
+    if (exitCode !== 0 && !isStderrOnlyNoise(stderr)) {
+      return {
+        type: "error",
+        message: `grok exited with code ${exitCode} despite success-shaped stdout`,
+        category: "runtime"
+      };
+    }
+    return success;
+  }
+  const hasOnlyNonterminalStreamEvents = objects.every((obj) => {
+    const type = typeof obj.type === "string" ? obj.type.toLowerCase() : void 0;
+    return type === "thought" || type === "status" || type === "progress" || type === "usage" || type !== void 0 && STREAM_TEXT_EVENT_TYPES.has(type) && type !== "success" && type !== "result";
+  });
+  if (hasOnlyNonterminalStreamEvents || textChunks.length > 0) {
+    return {
+      type: "error",
+      message: `Grok stdout stream ended without a terminal success/error envelope (${objects.length} event${objects.length === 1 ? "" : "s"})`,
+      category: exitCode === 0 ? "runtime" : "unknown"
+    };
+  }
+  return {
+    type: "error",
+    message: `Unrecognized Grok stdout envelope: ${JSON.stringify(objects[0]).slice(0, 200)}`,
+    category: "unknown"
+  };
+}
+var GROK_NONTERMINAL_STREAM_TYPES = /* @__PURE__ */ new Set(["thought", "status", "progress", "usage"]);
+function formatGrokStreamLineForDisplay(line, options = {}) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return trimmed;
+  }
+  const type = typeof parsed.type === "string" ? parsed.type.toLowerCase() : void 0;
+  const includePartials = options.includePartials ?? isDebugMode();
+  if (!includePartials && type && GROK_NONTERMINAL_STREAM_TYPES.has(type)) {
+    return null;
+  }
+  if (type === "success" && typeof parsed.text === "string" && parsed.text.length > 0) {
+    return parsed.text;
+  }
+  if (type === "error" && typeof parsed.message === "string") {
+    return `Error: ${parsed.message}`;
+  }
+  if (includePartials) {
+    if (type === "thought" && typeof parsed.data === "string") {
+      return parsed.data;
+    }
+    const chunk = extractStreamTextChunk(parsed);
+    if (chunk !== void 0 && chunk.length > 0) {
+      return chunk;
+    }
+  }
+  return null;
+}
+
+// src/core/providers/grok/auth.ts
+var AUTH_PROBE_ENV = {
+  BUILD_GROK_MAX_TURNS: "2",
+  BUILD_GROK_AUTO_APPROVE: "0"
+};
+var EDIT_PROBE_ENV = {
+  BUILD_GROK_MAX_TURNS: "8",
+  BUILD_GROK_AUTO_APPROVE: "1"
+};
+var DEFAULT_AUTH_PROBE_TIMEOUT_MS = 45e3;
+var API_KEY_REQUIRES_ACTIVE_VERIFICATION_REASON = "Grok API key is configured, but authentication is not verified by passive checks. Requested execution or `build doctor --probe --provider grok` provides authoritative evidence.";
+var AUTH_FILE_REQUIRES_ACTIVE_VERIFICATION_REASON = "Grok CLI auth file exists, but headless edit execution is not verified by passive checks. Run `build doctor --probe --provider grok` to verify headless execution.";
+function authSkipRequested(env) {
+  return isSkipAuthEnvActive(BUILD_SKIP_AUTH.name, env);
+}
+function parsePositiveTimeoutMs(raw) {
+  if (!raw) return void 0;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0) return void 0;
+  return n;
+}
+function resolveAuthProbeTimeoutMs(env) {
+  const raw = env?.BUILD_GROK_AUTH_PROBE_TIMEOUT_MS ?? readRawEnv(BUILD_GROK_AUTH_PROBE_TIMEOUT_MS);
+  return parsePositiveTimeoutMs(raw) ?? DEFAULT_AUTH_PROBE_TIMEOUT_MS;
+}
+function hasGrokHeadlessApiKey(env = process.env) {
+  return Boolean(env?.GROK_CODE_XAI_API_KEY?.trim() || env?.XAI_API_KEY?.trim());
+}
+function allowsGrokBrowserAuth(env = process.env) {
+  const raw = env?.BUILD_GROK_ALLOW_BROWSER_AUTH ?? readRawEnv(BUILD_GROK_ALLOW_BROWSER_AUTH);
+  return raw === "1" || raw?.toLowerCase() === "true" || raw?.toLowerCase() === "yes";
+}
+function isTimeoutReason(reason) {
+  return reason === "hard_timeout" || reason === "idle_timeout" || reason === "timeout" || reason === "plm_timeout";
+}
+function requireActiveEditProbePolicyBoundary(env) {
+  try {
+    requireActivePolicyBoundary(
+      "Grok",
+      "Grok active edit auth probe (--always-approve)",
+      metadata.id,
+      { env }
+    );
+    return void 0;
+  } catch (error) {
+    if (error instanceof ProviderExecutionError) {
+      return {
+        ok: false,
+        category: "runtime",
+        message: error.message,
+        exitCode: error.exitCode
+      };
+    }
+    throw error;
+  }
+}
+function normalizeHeadlessProbeFailure(parsed, stdout, stderr) {
+  if (parsed.category === "auth" && !stdout.trim() && isStderrOnlyNoise(stderr)) {
+    return {
+      ok: false,
+      category: "runtime",
+      message: parsed.message
+    };
+  }
+  return {
+    ok: false,
+    category: parsed.category,
+    message: parsed.message
+  };
+}
+async function probeHeadlessSessionDetailed(options) {
+  const argvEnvOverrides = options?.argvEnvOverrides ?? AUTH_PROBE_ENV;
+  const childEnv = options?.env ? { ...options.env, ...argvEnvOverrides } : argvEnvOverrides;
+  const dir = await mkBuildTempDir("grok-auth");
+  const promptFile = path2.join(dir, "prompt.txt");
+  try {
+    await writeFile(promptFile, "Reply with exactly: OK", "utf8");
+    const { command, prefixArgs } = resolveProviderCliCommand(metadata.id);
+    const { args } = buildGrokArgv({
+      promptFile,
+      model: metadata.defaultModel ?? "auto",
+      env: argvEnvOverrides
+    });
+    const childResult = await executeProviderCommand({
+      command,
+      args: [...prefixArgs, ...args],
+      workingDir: process.cwd(),
+      env: createGrokCliChildEnv(childEnv),
+      timeout: resolveAuthProbeTimeoutMs(options?.env),
+      metadata: {
+        id: metadata.id,
+        name: metadata.name,
+        installCommand: metadata.installCommand,
+        authHint: metadata.authHint,
+        docsPath: metadata.docsPath,
+        docsAnchor: metadata.docsAnchor
+      }
+    });
+    const stdout = childResult.stdout ?? "";
+    const stderr = childResult.stderr ?? "";
+    const exitCode = typeof childResult.exitCode === "number" ? childResult.exitCode : 1;
+    const parsed = parseGrokOutput(stdout, stderr, exitCode);
+    if (parsed.type === "success") {
+      return { ok: true, exitCode };
+    }
+    return {
+      ...normalizeHeadlessProbeFailure(parsed, stdout, stderr),
+      exitCode
+    };
+  } catch (error) {
+    if (error instanceof ProviderExecutionError) {
+      const stdout = error.stdout ?? "";
+      const stderr = error.stderr ?? "";
+      if (isTimeoutReason(error.reason)) {
+        return {
+          ok: false,
+          category: "runtime",
+          message: error.message,
+          exitCode: error.exitCode
+        };
+      }
+      if (stdout || stderr) {
+        const parsed = parseGrokOutput(stdout, stderr, error.exitCode ?? 1);
+        if (parsed.type === "success") {
+          return { ok: true, exitCode: error.exitCode };
+        }
+        return {
+          ...normalizeHeadlessProbeFailure(parsed, stdout, stderr),
+          exitCode: error.exitCode
+        };
+      }
+      return {
+        ok: false,
+        category: "runtime",
+        message: error.message,
+        exitCode: error.exitCode
+      };
+    }
+    return {
+      ok: false,
+      category: "runtime",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    await rm(dir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function probeHeadlessEditSessionDetailed(options) {
+  const argvEnvOverrides = options?.argvEnvOverrides ?? EDIT_PROBE_ENV;
+  const childEnv = options?.env ? { ...options.env, ...argvEnvOverrides } : argvEnvOverrides;
+  const boundaryFailure = requireActiveEditProbePolicyBoundary(options?.env);
+  if (boundaryFailure) return boundaryFailure;
+  const dir = await mkBuildTempDir("grok-edit-auth");
+  const promptFile = path2.join(dir, "prompt.txt");
+  const targetFile = "build-grok-edit-probe.txt";
+  const targetPath = path2.join(dir, targetFile);
+  const expected = "BUILD_GROK_EDIT_PROBE_OK\n";
+  try {
+    await writeFile(
+      promptFile,
+      [
+        `Create a file named ${targetFile} in the current working directory.`,
+        `The file must contain exactly one line: ${expected.trim()}.`,
+        "Do not modify any other file."
+      ].join(" "),
+      "utf8"
+    );
+    const { command, prefixArgs } = resolveProviderCliCommand(metadata.id);
+    const { args } = buildGrokArgv({
+      promptFile,
+      model: metadata.defaultModel ?? "auto",
+      env: argvEnvOverrides
+    });
+    const childResult = await executeProviderCommand({
+      command,
+      args: [...prefixArgs, ...args],
+      workingDir: dir,
+      env: createGrokCliChildEnv(childEnv),
+      timeout: resolveAuthProbeTimeoutMs(options?.env),
+      metadata: {
+        id: metadata.id,
+        name: metadata.name,
+        installCommand: metadata.installCommand,
+        authHint: metadata.authHint,
+        docsPath: metadata.docsPath,
+        docsAnchor: metadata.docsAnchor
+      }
+    });
+    const stdout = childResult.stdout ?? "";
+    const stderr = childResult.stderr ?? "";
+    const exitCode = typeof childResult.exitCode === "number" ? childResult.exitCode : 1;
+    const parsed = parseGrokOutput(stdout, stderr, exitCode);
+    if (parsed.type !== "success") {
+      return {
+        ...normalizeHeadlessProbeFailure(parsed, stdout, stderr),
+        exitCode
+      };
+    }
+    try {
+      const actual = await readFile(targetPath, "utf8");
+      if (actual === expected) {
+        return { ok: true, exitCode };
+      }
+      return {
+        ok: false,
+        category: "runtime",
+        message: `${metadata.name} active edit probe created ${targetFile}, but its contents did not match the expected sentinel.`,
+        exitCode
+      };
+    } catch {
+      return {
+        ok: false,
+        category: "runtime",
+        message: `${metadata.name} active edit probe completed but did not create ${targetFile}; headless text generation works, but edit/tool execution was not verified.`,
+        exitCode
+      };
+    }
+  } catch (error) {
+    if (error instanceof ProviderExecutionError) {
+      const stdout = error.stdout ?? "";
+      const stderr = error.stderr ?? "";
+      if (isTimeoutReason(error.reason)) {
+        return {
+          ok: false,
+          category: "runtime",
+          message: error.message,
+          exitCode: error.exitCode
+        };
+      }
+      if (stdout || stderr) {
+        const parsed = parseGrokOutput(stdout, stderr, error.exitCode ?? 1);
+        if (parsed.type === "success") {
+          try {
+            const actual = await readFile(targetPath, "utf8");
+            if (actual === expected) {
+              return { ok: true, exitCode: error.exitCode };
+            }
+          } catch {
+          }
+          return {
+            ok: false,
+            category: "runtime",
+            message: `${metadata.name} active edit probe completed but did not create ${targetFile}; headless text generation works, but edit/tool execution was not verified.`,
+            exitCode: error.exitCode
+          };
+        }
+        return {
+          ...normalizeHeadlessProbeFailure(parsed, stdout, stderr),
+          exitCode: error.exitCode
+        };
+      }
+      return {
+        ok: false,
+        category: "runtime",
+        message: error.message,
+        exitCode: error.exitCode
+      };
+    }
+    return {
+      ok: false,
+      category: "runtime",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    await rm(dir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function probeHeadlessSession(options) {
+  return (await probeHeadlessSessionDetailed(options)).ok;
+}
+function shouldSoftFailGrokCliAuthProbe(hasCliAuthFile, probe) {
+  if (!hasCliAuthFile || probe.ok) return false;
+  return probe.category === "runtime";
+}
+async function probeActiveGrokAuth(options) {
+  if (authSkipRequested(options?.env)) return { ok: true };
+  if (hasGrokHeadlessApiKey(options?.env)) {
+    return probeHeadlessEditSessionDetailed({ env: options?.env });
+  }
+  if (await probeGrokAuthFile(options?.env) === "yes") {
+    return probeHeadlessEditSessionDetailed({ env: options?.env });
+  }
+  if (!allowsGrokBrowserAuth(options?.env)) {
+    return {
+      ok: false,
+      category: "auth",
+      message: "No Grok headless API key, CLI auth file, or browser-auth probe opt-in is available."
+    };
+  }
+  return probeHeadlessEditSessionDetailed({ env: options?.env });
+}
+async function isAuthenticated(options) {
+  return await isAuthenticatedTriState(options) === "yes";
+}
+async function isAuthenticatedTriState(options) {
+  return (await getAuthReadiness(options)).state;
+}
+async function getAuthReadiness(options) {
+  const mode = options?.mode ?? "passive";
+  if (authSkipRequested(options?.env)) return { state: "yes" };
+  if (mode === "passive") {
+    if (hasGrokHeadlessApiKey(options?.env)) {
+      return {
+        state: "unknown",
+        reason: API_KEY_REQUIRES_ACTIVE_VERIFICATION_REASON
+      };
+    }
+    const authFileState = await probeGrokAuthFile(options?.env);
+    if (authFileState === "yes") {
+      return {
+        state: "unknown",
+        reason: AUTH_FILE_REQUIRES_ACTIVE_VERIFICATION_REASON
+      };
+    }
+    return { state: authFileState };
+  }
+  const result = await probeActiveGrokAuth(options);
+  if (result.ok) return { state: "yes", evidence: "execution" };
+  return {
+    state: result.category === "auth" ? "no" : "unknown",
+    // Sanitize before surfacing to readiness/health UIs: the message is
+    // provider-derived and may carry diagnostic text from the CLI.
+    ...result.message ? { reason: sanitizeString(result.message) } : {},
+    ...result.category ? { category: result.category } : {}
+  };
+}
+var auth = {
+  isAuthenticated,
+  isAuthenticatedTriState
+};
+
+export {
+  grokCategoryToRetryable,
+  capturedStdoutHasTerminalEnvelope,
+  createGrokTmuxCompletionSignal,
+  isStderrOnlyNoise,
+  parseGrokOutput,
+  formatGrokStreamLineForDisplay,
+  hasGrokHeadlessApiKey,
+  allowsGrokBrowserAuth,
+  probeHeadlessSessionDetailed,
+  probeHeadlessEditSessionDetailed,
+  probeHeadlessSession,
+  shouldSoftFailGrokCliAuthProbe,
+  isAuthenticated,
+  isAuthenticatedTriState,
+  getAuthReadiness,
+  auth
+};
+//# sourceMappingURL=chunk-EJIWTPSZ.js.map