@cartanova/qgrid-cli 2.10.9 → 2.11.0

package/bundle/dist/utils/providers/grok/grok-backend-protocol.js

@@ -0,0 +1,427 @@
+import { isJsonObject, jsonValueSchema } from "../common/provider-types.js";
+import { z } from "zod";
+import { promisify } from "node:util";
+import { zstdCompress } from "node:zlib";
+//#region src/utils/providers/grok/grok-backend-protocol.ts
+const GROK_DEFAULT_OUTPUT_SCHEMA_NAME = "qgrid_output";
+function replayItem(item) {
+	if (item.type !== "reasoning") return item;
+	if (!item.encrypted_content) return void 0;
+	const replayed = {
+		type: "reasoning",
+		summary: item.summary ?? [],
+		encrypted_content: item.encrypted_content
+	};
+	if (item.id) replayed.id = item.id;
+	return replayed;
+}
+/** Builds the `/responses` body in the key order of the 1.0.60 golden capture. */
+function buildGrokResponsesRequest(options) {
+	if (!options.model) throw new TypeError("Grok model is required");
+	if (!options.promptCacheKey) throw new TypeError("Grok prompt_cache_key is required");
+	if (options.maxOutputTokens !== void 0 && (!Number.isSafeInteger(options.maxOutputTokens) || options.maxOutputTokens <= 0)) throw new TypeError("maxOutputTokens must be a positive integer");
+	const input = [];
+	if (options.systemPrompt) input.push({
+		type: "message",
+		role: "system",
+		content: options.systemPrompt
+	});
+	for (const item of options.history) {
+		const wire = replayItem(item);
+		if (wire) input.push(wire);
+	}
+	const request = {
+		include: ["reasoning.encrypted_content", "no_inline_citations"],
+		input,
+		model: options.model,
+		prompt_cache_key: options.promptCacheKey,
+		reasoning: {
+			effort: options.effort,
+			summary: "concise"
+		},
+		store: false,
+		stream: true
+	};
+	if (options.outputSchema) request.text = { format: {
+		type: "json_schema",
+		name: options.outputSchema.name ?? "qgrid_output",
+		strict: true,
+		schema: options.outputSchema.schema
+	} };
+	if (options.tools?.length) request.tools = [...options.tools];
+	if (options.toolChoice !== void 0) request.tool_choice = options.toolChoice;
+	if (options.maxOutputTokens !== void 0) request.max_output_tokens = options.maxOutputTokens;
+	return request;
+}
+const zstdCompressAsync = promisify(zstdCompress);
+/** zstd-compressed JSON body, as the 1.0.60 binary sends it (`content-encoding: zstd`). */
+async function encodeGrokRequestBody(body) {
+	const compressed = await zstdCompressAsync(Buffer.from(JSON.stringify(body), "utf8"));
+	return {
+		bytes: new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength),
+		contentEncoding: "zstd"
+	};
+}
+/** Plain JSON body; the proxy accepts it too (U0 item 1). */
+function encodeGrokRequestBodyPlain(body) {
+	return {
+		bytes: new TextEncoder().encode(JSON.stringify(body)),
+		contentEncoding: void 0
+	};
+}
+var GrokProtocolError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.name = "GrokProtocolError";
+		this.code = code;
+	}
+};
+const count = z.number().int().nonnegative();
+const WireUsage = z.object({
+	input_tokens: count.optional(),
+	input_tokens_details: z.object({ cached_tokens: count.optional() }).nullish(),
+	output_tokens: count.optional(),
+	output_tokens_details: z.object({ reasoning_tokens: count.optional() }).nullish(),
+	total_tokens: count.optional(),
+	num_sources_used: count.optional(),
+	num_server_side_tools_used: count.optional(),
+	cost_in_usd_ticks: count.optional(),
+	context_details: z.object({
+		input_tokens: count.optional(),
+		output_tokens: count.optional()
+	}).nullish()
+});
+const WireItem = z.object({ type: z.string() }).catchall(jsonValueSchema);
+const WireResponse = z.looseObject({
+	id: z.string().optional(),
+	model: z.string().optional(),
+	status: z.string().optional(),
+	usage: WireUsage.nullish(),
+	output: z.array(WireItem).optional(),
+	incomplete_details: z.object({ reason: z.string().optional() }).nullish(),
+	error: z.object({
+		message: z.string().optional(),
+		code: z.string().optional()
+	}).nullish()
+});
+const WireEvent = z.looseObject({
+	type: z.string(),
+	response: WireResponse.optional(),
+	item: WireItem.optional(),
+	item_id: z.string().optional(),
+	delta: z.string().optional(),
+	message: z.string().optional(),
+	code: z.string().nullish(),
+	error: z.object({
+		message: z.string().optional(),
+		code: z.string().optional()
+	}).nullish()
+});
+function grokUsageFrom(usage) {
+	const inputTokens = usage.input_tokens ?? 0;
+	const outputTokens = usage.output_tokens ?? 0;
+	const result = {
+		inputTokens,
+		cachedInputTokens: usage.input_tokens_details?.cached_tokens ?? 0,
+		outputTokens,
+		reasoningTokens: usage.output_tokens_details?.reasoning_tokens ?? 0,
+		totalTokens: usage.total_tokens ?? inputTokens + outputTokens
+	};
+	if (usage.num_sources_used !== void 0) result.numSourcesUsed = usage.num_sources_used;
+	if (usage.num_server_side_tools_used !== void 0) result.numServerSideToolsUsed = usage.num_server_side_tools_used;
+	if (usage.cost_in_usd_ticks !== void 0) result.costInUsdTicks = usage.cost_in_usd_ticks;
+	if (usage.context_details?.input_tokens !== void 0) result.contextInputTokens = usage.context_details.input_tokens;
+	if (usage.context_details?.output_tokens !== void 0) result.contextOutputTokens = usage.context_details.output_tokens;
+	return result;
+}
+/**
+* Normalizes one SSE block. Returns `undefined` for well-formed events that carry nothing a
+* caller consumes (`response.in_progress`, part/done bookkeeping). Terminal events are
+* `response.completed | response.incomplete | response.failed | error`; the proxy does not
+* send `[DONE]`, and a `[DONE]` sentinel is ignored if one ever appears.
+*/
+function normalizeGrokEvent(raw) {
+	if (raw.data.trim() === "[DONE]") return void 0;
+	let json;
+	try {
+		json = JSON.parse(raw.data);
+	} catch (error) {
+		throw new GrokProtocolError(`Invalid Grok SSE JSON: ${String(error)}`);
+	}
+	const withType = isJsonObject(json) && !("type" in json) && raw.event ? {
+		...json,
+		type: raw.event
+	} : json;
+	const parsed = WireEvent.safeParse(withType);
+	if (!parsed.success) throw new GrokProtocolError(`Unexpected Grok SSE event shape: ${parsed.error.message}`);
+	const event = parsed.data;
+	const response = event.response;
+	switch (event.type) {
+		case "response.created": {
+			const created = { type: "created" };
+			if (response?.id) created.responseId = response.id;
+			if (response?.model) created.model = response.model;
+			return created;
+		}
+		case "response.output_text.delta":
+			if (event.delta === void 0) return void 0;
+			return event.item_id ? {
+				type: "text-delta",
+				text: event.delta,
+				itemId: event.item_id
+			} : {
+				type: "text-delta",
+				text: event.delta
+			};
+		case "response.reasoning_summary_text.delta":
+			if (event.delta === void 0) return void 0;
+			return event.item_id ? {
+				type: "reasoning-summary-delta",
+				text: event.delta,
+				itemId: event.item_id
+			} : {
+				type: "reasoning-summary-delta",
+				text: event.delta
+			};
+		case "response.output_item.added":
+		case "response.output_item.done":
+			if (!event.item) return void 0;
+			return {
+				type: "output-item",
+				item: event.item,
+				completed: event.type === "response.output_item.done"
+			};
+		case "response.completed": {
+			const usage = response?.usage ? grokUsageFrom(response.usage) : void 0;
+			const completed = {
+				type: "completed",
+				terminal: true,
+				responseId: response?.id ?? ""
+			};
+			if (response?.model) completed.model = response.model;
+			if (usage) completed.usage = usage;
+			if (response?.output) completed.output = response.output;
+			return completed;
+		}
+		case "response.incomplete": {
+			const usage = response?.usage ? grokUsageFrom(response.usage) : void 0;
+			const reason = response?.incomplete_details?.reason;
+			const incomplete = {
+				type: "incomplete",
+				terminal: true,
+				responseId: response?.id ?? ""
+			};
+			if (reason) incomplete.reason = reason;
+			if (response?.model) incomplete.model = response.model;
+			if (usage) incomplete.usage = usage;
+			return incomplete;
+		}
+		case "response.failed":
+		case "error": {
+			const nested = event.error ?? response?.error ?? void 0;
+			return {
+				type: "error",
+				terminal: true,
+				error: new GrokProtocolError(nested?.message ?? event.message ?? `Grok stream ended with ${event.type}`, nested?.code ?? event.code ?? void 0)
+			};
+		}
+		default: return;
+	}
+}
+function parseSSEBlock(block) {
+	const data = [];
+	let event;
+	for (const line of block.split("\n")) {
+		if (line.startsWith(":")) continue;
+		const separator = line.indexOf(":");
+		const field = separator < 0 ? line : line.slice(0, separator);
+		let value = separator < 0 ? "" : line.slice(separator + 1);
+		if (value.startsWith(" ")) value = value.slice(1);
+		if (field === "data") data.push(value);
+		else if (field === "event") event = value;
+	}
+	if (!data.length) return void 0;
+	const parsed = { data: data.join("\n") };
+	if (event !== void 0) parsed.event = event;
+	return parsed;
+}
+/** Splits a byte stream into SSE blocks across arbitrary UTF-8/chunk boundaries. */
+async function* parseGrokSSE(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let pending = "";
+	let first = true;
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			let chunk = pending + decoder.decode(value, { stream: !done });
+			pending = "";
+			if (first && chunk.length) {
+				if (chunk.startsWith("")) chunk = chunk.slice(1);
+				first = false;
+			}
+			if (!done && chunk.endsWith("\r")) {
+				pending = "\r";
+				chunk = chunk.slice(0, -1);
+			}
+			buffer += chunk.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+			let index;
+			while ((index = buffer.indexOf("\n\n")) >= 0) {
+				const block = parseSSEBlock(buffer.slice(0, index));
+				buffer = buffer.slice(index + 2);
+				if (block) yield block;
+			}
+			if (done) break;
+		}
+		if (buffer.trim()) {
+			const block = parseSSEBlock(buffer);
+			if (block) yield block;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+/** Normalized stream that ends at the first terminal event and rejects a truncated stream. */
+async function* normalizeGrokSSE(body) {
+	for await (const raw of parseGrokSSE(body)) {
+		const event = normalizeGrokEvent(raw);
+		if (!event) continue;
+		yield event;
+		if ("terminal" in event) return;
+	}
+	throw new GrokProtocolError("Grok SSE connection closed before a terminal event");
+}
+function headerValue(headers, name) {
+	if (headers instanceof Headers) return headers.get(name) ?? void 0;
+	const key = Object.keys(headers).find((candidate) => candidate.toLowerCase() === name);
+	return key === void 0 ? void 0 : headers[key];
+}
+function integerHeader(headers, name) {
+	const value = headerValue(headers, name)?.trim();
+	if (!value || !/^\d+$/.test(value)) return void 0;
+	const parsed = Number(value);
+	return Number.isSafeInteger(parsed) ? parsed : void 0;
+}
+/** `Retry-After` as whole seconds (delta-seconds or HTTP-date). Uncapped; callers clamp. */
+function parseRetryAfterSec(headers, now = Date.now()) {
+	const value = headerValue(headers, "retry-after")?.trim();
+	if (!value) return void 0;
+	if (/^\d+$/.test(value)) return Number(value);
+	const date = Date.parse(value);
+	if (Number.isNaN(date)) return void 0;
+	return Math.max(0, Math.ceil((date - now) / 1e3));
+}
+function parseShouldRetry(headers) {
+	const value = headerValue(headers, "x-should-retry")?.trim().toLowerCase();
+	if (value === "true") return true;
+	if (value === "false") return false;
+}
+/** Response headers grok-build reads (client.rs:187-224) plus the observed rate-limit set. */
+function readGrokResponseHeaders(headers) {
+	const zdr = headerValue(headers, "x-zero-data-retention")?.trim().toLowerCase();
+	const entries = [
+		["contextWindow", integerHeader(headers, "x-grok-context-window")],
+		["maxCompletionTokens", integerHeader(headers, "x-grok-max-completion-tokens")],
+		["modelsEtag", headerValue(headers, "x-models-etag")],
+		["requestId", headerValue(headers, "x-request-id")],
+		["rateLimitLimitTokens", integerHeader(headers, "x-ratelimit-limit-tokens")],
+		["rateLimitRemainingTokens", integerHeader(headers, "x-ratelimit-remaining-tokens")],
+		["rateLimitLimitRequests", integerHeader(headers, "x-ratelimit-limit-requests")],
+		["rateLimitRemainingRequests", integerHeader(headers, "x-ratelimit-remaining-requests")],
+		["zeroDataRetention", zdr === "true" ? true : zdr === "false" ? false : void 0]
+	];
+	return Object.fromEntries(entries.filter(([, value]) => value !== void 0));
+}
+const MAX_ERROR_MESSAGE_LENGTH = 500;
+const SUBSCRIPTION_CODE_PATTERN = /subscription:[a-z0-9][a-z0-9_.-]*/i;
+const ErrorObject = z.looseObject({
+	code: z.string().optional(),
+	message: z.string().optional(),
+	type: z.string().optional()
+});
+const ErrorBody = z.looseObject({
+	code: z.string().optional(),
+	message: z.string().optional(),
+	error: z.union([z.string(), ErrorObject]).optional()
+});
+function parseErrorBody(bodyText) {
+	let json;
+	try {
+		json = JSON.parse(bodyText);
+	} catch {
+		return bodyText.trim() ? { message: bodyText.trim() } : {};
+	}
+	const parsed = ErrorBody.safeParse(json);
+	if (!parsed.success) return bodyText.trim() ? { message: bodyText.trim() } : {};
+	const { error } = parsed.data;
+	const errorText = z.string().safeParse(error).data;
+	const errorObject = ErrorObject.safeParse(error).data;
+	const code = parsed.data.code ?? errorObject?.code;
+	const message = errorText ?? errorObject?.message ?? parsed.data.message;
+	const body = {};
+	if (code) body.code = code;
+	if (message) body.message = message;
+	return body;
+}
+/**
+* Classifies a non-2xx proxy or api.x.ai response. Pass `status = 0` for a network failure.
+* The body is not trusted to be JSON.
+*/
+function classifyGrokHttpError(status, bodyText, headers) {
+	const body = parseErrorBody(bodyText);
+	const message = body.message === void 0 ? void 0 : body.message.slice(0, MAX_ERROR_MESSAGE_LENGTH);
+	const shouldRetry = parseShouldRetry(headers);
+	const retryAfterSec = parseRetryAfterSec(headers);
+	const base = { status };
+	if (body.code) base.code = body.code;
+	if (message !== void 0) base.message = message;
+	if (shouldRetry !== void 0) base.shouldRetry = shouldRetry;
+	if (retryAfterSec !== void 0) base.retryAfterSec = retryAfterSec;
+	const subscriptionCode = SUBSCRIPTION_CODE_PATTERN.exec(bodyText)?.[0];
+	if (status === 401) return {
+		kind: "auth",
+		...base
+	};
+	if (status === 426) {
+		const minClientVersion = /\bversion\s+(\d+\.\d+\.\d+)\s+or later/i.exec(bodyText)?.[1];
+		const gate = {
+			kind: "version_gate",
+			...base
+		};
+		if (minClientVersion) gate.minClientVersion = minClientVersion;
+		return gate;
+	}
+	if (status === 429) {
+		if (subscriptionCode) return {
+			kind: "quota_exhausted",
+			...base,
+			code: subscriptionCode
+		};
+		return {
+			kind: "rate_limited",
+			...base
+		};
+	}
+	if (status === 403) return {
+		kind: "entitlement",
+		...base
+	};
+	if (status === 400 || status === 422) return {
+		kind: "invalid_request",
+		...base
+	};
+	if (status === 0 || status === 408 || status >= 500) return {
+		kind: "transient",
+		...base
+	};
+	return {
+		kind: "permanent",
+		...base
+	};
+}
+//#endregion
+export { GROK_DEFAULT_OUTPUT_SCHEMA_NAME, GrokProtocolError, buildGrokResponsesRequest, classifyGrokHttpError, encodeGrokRequestBody, encodeGrokRequestBodyPlain, grokUsageFrom, normalizeGrokEvent, normalizeGrokSSE, parseGrokSSE, parseRetryAfterSec, parseShouldRetry, readGrokResponseHeaders };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"grok-backend-protocol.js","names":[],"sources":["../../../../src/utils/providers/grok/grok-backend-protocol.ts"],"sourcesContent":["import { promisify } from \"node:util\";\nimport { zstdCompress } from \"node:zlib\";\n\nimport { z } from \"zod\";\n\nimport {\n  isJsonObject,\n  type JsonObject,\n  type JsonValue,\n  jsonValueSchema,\n} from \"../common/provider-types\";\nimport { type GrokReasoningEffort } from \"./grok-constants\";\n\n// ---------------------------------------------------------------------------\n// Request body\n// ---------------------------------------------------------------------------\n\nexport type GrokInputContentPart =\n  | { type: \"input_text\"; text: string }\n  | { type: \"input_image\"; image_url: string }\n  | { type: \"output_text\"; text: string };\n\nexport type GrokInputItem =\n  | { type: \"message\"; role: \"user\" | \"assistant\"; content: string | GrokInputContentPart[] }\n  | { type: \"function_call\"; call_id: string; name: string; arguments: string; id?: string }\n  | { type: \"function_call_output\"; call_id: string; output: string }\n  | {\n      type: \"reasoning\";\n      id?: string;\n      summary?: Array<{ type: \"summary_text\"; text: string }>;\n      encrypted_content?: string;\n    };\n\nexport type GrokFunctionTool = {\n  type: \"function\";\n  name: string;\n  description?: string;\n  parameters: JsonValue;\n  strict: boolean;\n};\n\nexport type GrokTool = GrokFunctionTool | { type: \"web_search\" } | { type: \"x_search\" };\n\nexport type GrokToolChoice = \"auto\" | \"none\" | \"required\" | { type: \"function\"; name: string };\n\nexport interface GrokResponsesOptions {\n  model: string;\n  /** Sent as the first `input` item; grok-build never uses `instructions`. */\n  systemPrompt?: string;\n  /** Full conversation history; qgrid replays it every turn (`store: false`). */\n  history: readonly GrokInputItem[];\n  /** grok-build sends the conversation id here. */\n  promptCacheKey: string;\n  effort: GrokReasoningEffort;\n  outputSchema?: { name?: string; schema: JsonValue };\n  tools?: readonly GrokTool[];\n  toolChoice?: GrokToolChoice;\n  maxOutputTokens?: number;\n}\n\nexport type GrokInputWireItem =\n  | { type: \"message\"; role: \"system\"; content: string }\n  | Exclude<GrokInputItem, { type: \"reasoning\" }>\n  | {\n      type: \"reasoning\";\n      id?: string;\n      summary: Array<{ type: \"summary_text\"; text: string }>;\n      encrypted_content: string;\n    };\n\nexport interface GrokResponsesRequest {\n  include: [\"reasoning.encrypted_content\", \"no_inline_citations\"];\n  input: GrokInputWireItem[];\n  model: string;\n  prompt_cache_key: string;\n  reasoning: { effort: GrokReasoningEffort; summary: \"concise\" };\n  store: false;\n  stream: true;\n  text?: {\n    format: { type: \"json_schema\"; name: string; strict: true; schema: JsonValue };\n  };\n  tools?: GrokTool[];\n  tool_choice?: GrokToolChoice;\n  max_output_tokens?: number;\n}\n\nexport const GROK_DEFAULT_OUTPUT_SCHEMA_NAME = \"qgrid_output\";\n\nfunction replayItem(item: GrokInputItem): GrokInputWireItem | undefined {\n  if (item.type !== \"reasoning\") return item;\n\n  // With store:false the proxy cannot resolve a reasoning item by id; without the encrypted\n  // payload (for example reasoning from another account) the item is dropped, not replayed.\n  if (!item.encrypted_content) return undefined;\n\n  const replayed: Extract<GrokInputWireItem, { type: \"reasoning\" }> = {\n    type: \"reasoning\",\n    summary: item.summary ?? [],\n    encrypted_content: item.encrypted_content,\n  };\n\n  if (item.id) replayed.id = item.id;\n\n  return replayed;\n}\n\n/** Builds the `/responses` body in the key order of the 1.0.60 golden capture. */\nexport function buildGrokResponsesRequest(options: GrokResponsesOptions): GrokResponsesRequest {\n  if (!options.model) throw new TypeError(\"Grok model is required\");\n\n  if (!options.promptCacheKey) throw new TypeError(\"Grok prompt_cache_key is required\");\n\n  if (\n    options.maxOutputTokens !== undefined &&\n    (!Number.isSafeInteger(options.maxOutputTokens) || options.maxOutputTokens <= 0)\n  )\n    throw new TypeError(\"maxOutputTokens must be a positive integer\");\n\n  const input: GrokInputWireItem[] = [];\n\n  if (options.systemPrompt)\n    input.push({ type: \"message\", role: \"system\", content: options.systemPrompt });\n\n  for (const item of options.history) {\n    const wire = replayItem(item);\n\n    if (wire) input.push(wire);\n  }\n\n  const request: GrokResponsesRequest = {\n    include: [\"reasoning.encrypted_content\", \"no_inline_citations\"],\n    input,\n    model: options.model,\n    prompt_cache_key: options.promptCacheKey,\n    reasoning: { effort: options.effort, summary: \"concise\" },\n    store: false,\n    stream: true,\n  };\n\n  if (options.outputSchema) {\n    request.text = {\n      format: {\n        type: \"json_schema\",\n        name: options.outputSchema.name ?? GROK_DEFAULT_OUTPUT_SCHEMA_NAME,\n        strict: true,\n        schema: options.outputSchema.schema,\n      },\n    };\n  }\n\n  if (options.tools?.length) request.tools = [...options.tools];\n\n  if (options.toolChoice !== undefined) request.tool_choice = options.toolChoice;\n\n  if (options.maxOutputTokens !== undefined) request.max_output_tokens = options.maxOutputTokens;\n\n  return request;\n}\n\nexport interface GrokEncodedBody {\n  bytes: Uint8Array;\n  contentEncoding: \"zstd\" | undefined;\n}\n\nconst zstdCompressAsync = promisify(zstdCompress);\n\n/** zstd-compressed JSON body, as the 1.0.60 binary sends it (`content-encoding: zstd`). */\nexport async function encodeGrokRequestBody(\n  body: GrokResponsesRequest,\n): Promise<GrokEncodedBody & { contentEncoding: \"zstd\" }> {\n  const compressed = await zstdCompressAsync(Buffer.from(JSON.stringify(body), \"utf8\"));\n\n  return {\n    bytes: new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength),\n    contentEncoding: \"zstd\",\n  };\n}\n\n/** Plain JSON body; the proxy accepts it too (U0 item 1). */\nexport function encodeGrokRequestBodyPlain(\n  body: GrokResponsesRequest,\n): GrokEncodedBody & { contentEncoding: undefined } {\n  return { bytes: new TextEncoder().encode(JSON.stringify(body)), contentEncoding: undefined };\n}\n\n// ---------------------------------------------------------------------------\n// SSE events\n// ---------------------------------------------------------------------------\n\nexport class GrokProtocolError extends Error {\n  readonly code: string | undefined;\n\n  constructor(message: string, code?: string) {\n    super(message);\n    this.name = \"GrokProtocolError\";\n    this.code = code;\n  }\n}\n\nexport interface GrokUsage {\n  inputTokens: number;\n  cachedInputTokens: number;\n  outputTokens: number;\n  reasoningTokens: number;\n  totalTokens: number;\n  numSourcesUsed?: number;\n  numServerSideToolsUsed?: number;\n  /** 1 tick = GROK_USD_PER_TICK USD. */\n  costInUsdTicks?: number;\n  /** Live context size (`context_details`), distinct from cumulative input tokens. */\n  contextInputTokens?: number;\n  contextOutputTokens?: number;\n}\n\nexport type GrokOutputItem = { type: string } & JsonObject;\n\nexport type GrokNormalizedEvent =\n  | { type: \"created\"; responseId?: string; model?: string }\n  | { type: \"text-delta\"; text: string; itemId?: string }\n  | { type: \"reasoning-summary-delta\"; text: string; itemId?: string }\n  | { type: \"output-item\"; item: GrokOutputItem; completed: boolean }\n  | {\n      type: \"completed\";\n      terminal: true;\n      responseId: string;\n      model?: string;\n      usage?: GrokUsage;\n      output?: GrokOutputItem[];\n    }\n  | {\n      type: \"incomplete\";\n      terminal: true;\n      responseId: string;\n      reason?: string;\n      model?: string;\n      usage?: GrokUsage;\n    }\n  | { type: \"error\"; terminal: true; error: GrokProtocolError };\n\nconst count = z.number().int().nonnegative();\n\nconst WireUsage = z.object({\n  input_tokens: count.optional(),\n  input_tokens_details: z.object({ cached_tokens: count.optional() }).nullish(),\n  output_tokens: count.optional(),\n  output_tokens_details: z.object({ reasoning_tokens: count.optional() }).nullish(),\n  total_tokens: count.optional(),\n  num_sources_used: count.optional(),\n  num_server_side_tools_used: count.optional(),\n  cost_in_usd_ticks: count.optional(),\n  context_details: z\n    .object({ input_tokens: count.optional(), output_tokens: count.optional() })\n    .nullish(),\n});\n\n// Items arrive from JSON.parse, so every extra member is a JSON value.\nconst WireItem = z.object({ type: z.string() }).catchall(jsonValueSchema);\n\nconst WireResponse = z.looseObject({\n  id: z.string().optional(),\n  model: z.string().optional(),\n  status: z.string().optional(),\n  usage: WireUsage.nullish(),\n  output: z.array(WireItem).optional(),\n  incomplete_details: z.object({ reason: z.string().optional() }).nullish(),\n  error: z.object({ message: z.string().optional(), code: z.string().optional() }).nullish(),\n});\n\nconst WireEvent = z.looseObject({\n  type: z.string(),\n  response: WireResponse.optional(),\n  item: WireItem.optional(),\n  item_id: z.string().optional(),\n  delta: z.string().optional(),\n  message: z.string().optional(),\n  code: z.string().nullish(),\n  error: z.object({ message: z.string().optional(), code: z.string().optional() }).nullish(),\n});\n\nexport function grokUsageFrom(usage: z.infer<typeof WireUsage>): GrokUsage {\n  const inputTokens = usage.input_tokens ?? 0;\n  const outputTokens = usage.output_tokens ?? 0;\n\n  const result: GrokUsage = {\n    inputTokens,\n    cachedInputTokens: usage.input_tokens_details?.cached_tokens ?? 0,\n    outputTokens,\n    reasoningTokens: usage.output_tokens_details?.reasoning_tokens ?? 0,\n    totalTokens: usage.total_tokens ?? inputTokens + outputTokens,\n  };\n\n  if (usage.num_sources_used !== undefined) result.numSourcesUsed = usage.num_sources_used;\n\n  if (usage.num_server_side_tools_used !== undefined) {\n    result.numServerSideToolsUsed = usage.num_server_side_tools_used;\n  }\n\n  if (usage.cost_in_usd_ticks !== undefined) result.costInUsdTicks = usage.cost_in_usd_ticks;\n\n  if (usage.context_details?.input_tokens !== undefined) {\n    result.contextInputTokens = usage.context_details.input_tokens;\n  }\n\n  if (usage.context_details?.output_tokens !== undefined) {\n    result.contextOutputTokens = usage.context_details.output_tokens;\n  }\n\n  return result;\n}\n\nexport interface GrokRawSSEEvent {\n  event?: string;\n  data: string;\n}\n\n/**\n * Normalizes one SSE block. Returns `undefined` for well-formed events that carry nothing a\n * caller consumes (`response.in_progress`, part/done bookkeeping). Terminal events are\n * `response.completed | response.incomplete | response.failed | error`; the proxy does not\n * send `[DONE]`, and a `[DONE]` sentinel is ignored if one ever appears.\n */\nexport function normalizeGrokEvent(raw: GrokRawSSEEvent): GrokNormalizedEvent | undefined {\n  if (raw.data.trim() === \"[DONE]\") return undefined;\n  let json: JsonValue;\n\n  try {\n    // JSON.parse without a reviver yields only JSON values.\n    json = JSON.parse(raw.data);\n  } catch (error) {\n    throw new GrokProtocolError(`Invalid Grok SSE JSON: ${String(error)}`);\n  }\n\n  // An SSE `event:` line names the type when the payload object omits it.\n  const withType =\n    isJsonObject(json) && !(\"type\" in json) && raw.event ? { ...json, type: raw.event } : json;\n\n  const parsed = WireEvent.safeParse(withType);\n\n  if (!parsed.success)\n    throw new GrokProtocolError(`Unexpected Grok SSE event shape: ${parsed.error.message}`);\n  const event = parsed.data;\n  const response = event.response;\n\n  switch (event.type) {\n    case \"response.created\": {\n      const created: GrokNormalizedEvent = { type: \"created\" };\n\n      if (response?.id) created.responseId = response.id;\n\n      if (response?.model) created.model = response.model;\n\n      return created;\n    }\n\n    case \"response.output_text.delta\":\n      if (event.delta === undefined) return undefined;\n\n      return event.item_id\n        ? { type: \"text-delta\", text: event.delta, itemId: event.item_id }\n        : { type: \"text-delta\", text: event.delta };\n    case \"response.reasoning_summary_text.delta\":\n      if (event.delta === undefined) return undefined;\n\n      return event.item_id\n        ? { type: \"reasoning-summary-delta\", text: event.delta, itemId: event.item_id }\n        : { type: \"reasoning-summary-delta\", text: event.delta };\n    case \"response.output_item.added\":\n    case \"response.output_item.done\":\n      if (!event.item) return undefined;\n\n      return {\n        type: \"output-item\",\n        item: event.item,\n        completed: event.type === \"response.output_item.done\",\n      };\n    case \"response.completed\": {\n      const usage = response?.usage ? grokUsageFrom(response.usage) : undefined;\n\n      const completed: GrokNormalizedEvent = {\n        type: \"completed\",\n        terminal: true,\n        responseId: response?.id ?? \"\",\n      };\n\n      if (response?.model) completed.model = response.model;\n\n      if (usage) completed.usage = usage;\n\n      if (response?.output) completed.output = response.output;\n\n      return completed;\n    }\n\n    case \"response.incomplete\": {\n      const usage = response?.usage ? grokUsageFrom(response.usage) : undefined;\n      const reason = response?.incomplete_details?.reason;\n\n      const incomplete: GrokNormalizedEvent = {\n        type: \"incomplete\",\n        terminal: true,\n        responseId: response?.id ?? \"\",\n      };\n\n      if (reason) incomplete.reason = reason;\n\n      if (response?.model) incomplete.model = response.model;\n\n      if (usage) incomplete.usage = usage;\n\n      return incomplete;\n    }\n\n    case \"response.failed\":\n    case \"error\": {\n      const nested = event.error ?? response?.error ?? undefined;\n      const message = nested?.message ?? event.message ?? `Grok stream ended with ${event.type}`;\n      const code = nested?.code ?? event.code ?? undefined;\n\n      return { type: \"error\", terminal: true, error: new GrokProtocolError(message, code) };\n    }\n\n    default:\n      return undefined;\n  }\n}\n\nfunction parseSSEBlock(block: string): GrokRawSSEEvent | undefined {\n  const data: string[] = [];\n  let event: string | undefined;\n\n  for (const line of block.split(\"\\n\")) {\n    if (line.startsWith(\":\")) continue;\n    const separator = line.indexOf(\":\");\n    const field = separator < 0 ? line : line.slice(0, separator);\n    let value = separator < 0 ? \"\" : line.slice(separator + 1);\n\n    if (value.startsWith(\" \")) value = value.slice(1);\n\n    if (field === \"data\") data.push(value);\n    else if (field === \"event\") event = value;\n  }\n\n  if (!data.length) return undefined;\n\n  const parsed: GrokRawSSEEvent = { data: data.join(\"\\n\") };\n\n  if (event !== undefined) parsed.event = event;\n\n  return parsed;\n}\n\n/** Splits a byte stream into SSE blocks across arbitrary UTF-8/chunk boundaries. */\nexport async function* parseGrokSSE(\n  body: ReadableStream<Uint8Array>,\n): AsyncGenerator<GrokRawSSEEvent> {\n  const reader = body.getReader();\n  const decoder = new TextDecoder();\n  let buffer = \"\";\n  // A trailing CR may be the first half of a CRLF split across chunks; hold it back.\n  let pending = \"\";\n  let first = true;\n\n  try {\n    while (true) {\n      const { done, value } = await reader.read();\n      let chunk = pending + decoder.decode(value, { stream: !done });\n      pending = \"\";\n\n      if (first && chunk.length) {\n        if (chunk.startsWith(\"\\uFEFF\")) chunk = chunk.slice(1);\n        first = false;\n      }\n\n      if (!done && chunk.endsWith(\"\\r\")) {\n        pending = \"\\r\";\n        chunk = chunk.slice(0, -1);\n      }\n\n      buffer += chunk.replaceAll(\"\\r\\n\", \"\\n\").replaceAll(\"\\r\", \"\\n\");\n      let index: number;\n\n      while ((index = buffer.indexOf(\"\\n\\n\")) >= 0) {\n        const block = parseSSEBlock(buffer.slice(0, index));\n        buffer = buffer.slice(index + 2);\n\n        if (block) yield block;\n      }\n\n      if (done) break;\n    }\n\n    if (buffer.trim()) {\n      const block = parseSSEBlock(buffer);\n\n      if (block) yield block;\n    }\n  } finally {\n    reader.releaseLock();\n  }\n}\n\n/** Normalized stream that ends at the first terminal event and rejects a truncated stream. */\nexport async function* normalizeGrokSSE(\n  body: ReadableStream<Uint8Array>,\n): AsyncGenerator<GrokNormalizedEvent> {\n  for await (const raw of parseGrokSSE(body)) {\n    const event = normalizeGrokEvent(raw);\n\n    if (!event) continue;\n    yield event;\n\n    if (\"terminal\" in event) return;\n  }\n\n  throw new GrokProtocolError(\"Grok SSE connection closed before a terminal event\");\n}\n\n// ---------------------------------------------------------------------------\n// Response headers and HTTP errors\n// ---------------------------------------------------------------------------\n\ntype HeaderSource = Headers | Readonly<Record<string, string | undefined>>;\n\nfunction headerValue(headers: HeaderSource, name: string): string | undefined {\n  if (headers instanceof Headers) return headers.get(name) ?? undefined;\n  const key = Object.keys(headers).find((candidate) => candidate.toLowerCase() === name);\n\n  return key === undefined ? undefined : headers[key];\n}\n\nfunction integerHeader(headers: HeaderSource, name: string): number | undefined {\n  const value = headerValue(headers, name)?.trim();\n\n  if (!value || !/^\\d+$/.test(value)) return undefined;\n  const parsed = Number(value);\n\n  return Number.isSafeInteger(parsed) ? parsed : undefined;\n}\n\n/** `Retry-After` as whole seconds (delta-seconds or HTTP-date). Uncapped; callers clamp. */\nexport function parseRetryAfterSec(\n  headers: HeaderSource,\n  now: number = Date.now(),\n): number | undefined {\n  const value = headerValue(headers, \"retry-after\")?.trim();\n\n  if (!value) return undefined;\n\n  if (/^\\d+$/.test(value)) return Number(value);\n  const date = Date.parse(value);\n\n  if (Number.isNaN(date)) return undefined;\n\n  return Math.max(0, Math.ceil((date - now) / 1000));\n}\n\nexport function parseShouldRetry(headers: HeaderSource): boolean | undefined {\n  const value = headerValue(headers, \"x-should-retry\")?.trim().toLowerCase();\n\n  if (value === \"true\") return true;\n\n  if (value === \"false\") return false;\n\n  return undefined;\n}\n\nexport interface GrokResponseHeaderInfo {\n  contextWindow?: number;\n  maxCompletionTokens?: number;\n  modelsEtag?: string;\n  requestId?: string;\n  rateLimitLimitTokens?: number;\n  rateLimitRemainingTokens?: number;\n  rateLimitLimitRequests?: number;\n  rateLimitRemainingRequests?: number;\n  /** `x-zero-data-retention: true`: the account has Zero Data Retention on (U0, plan §11). */\n  zeroDataRetention?: boolean;\n}\n\n/** Response headers grok-build reads (client.rs:187-224) plus the observed rate-limit set. */\nexport function readGrokResponseHeaders(headers: HeaderSource): GrokResponseHeaderInfo {\n  const zdr = headerValue(headers, \"x-zero-data-retention\")?.trim().toLowerCase();\n\n  const entries: Array<[keyof GrokResponseHeaderInfo, number | string | boolean | undefined]> = [\n    [\"contextWindow\", integerHeader(headers, \"x-grok-context-window\")],\n    [\"maxCompletionTokens\", integerHeader(headers, \"x-grok-max-completion-tokens\")],\n    [\"modelsEtag\", headerValue(headers, \"x-models-etag\")],\n    [\"requestId\", headerValue(headers, \"x-request-id\")],\n    [\"rateLimitLimitTokens\", integerHeader(headers, \"x-ratelimit-limit-tokens\")],\n    [\"rateLimitRemainingTokens\", integerHeader(headers, \"x-ratelimit-remaining-tokens\")],\n    [\"rateLimitLimitRequests\", integerHeader(headers, \"x-ratelimit-limit-requests\")],\n    [\"rateLimitRemainingRequests\", integerHeader(headers, \"x-ratelimit-remaining-requests\")],\n    [\"zeroDataRetention\", zdr === \"true\" ? true : zdr === \"false\" ? false : undefined],\n  ];\n\n  return Object.fromEntries(entries.filter(([, value]) => value !== undefined));\n}\n\nexport type GrokHttpErrorKind =\n  | \"auth\"\n  | \"version_gate\"\n  | \"rate_limited\"\n  | \"quota_exhausted\"\n  | \"entitlement\"\n  | \"invalid_request\"\n  | \"transient\"\n  | \"permanent\";\n\nexport interface GrokHttpErrorClassification {\n  kind: GrokHttpErrorKind;\n  status: number;\n  retryAfterSec?: number;\n  code?: string;\n  message?: string;\n  /** `x-should-retry` override from the server; callers must honor it over `kind`. */\n  shouldRetry?: boolean;\n  /** Minimum CLI version named by a 426 body. */\n  minClientVersion?: string;\n}\n\nconst MAX_ERROR_MESSAGE_LENGTH = 500;\nconst SUBSCRIPTION_CODE_PATTERN = /subscription:[a-z0-9][a-z0-9_.-]*/i;\n\nconst ErrorObject = z.looseObject({\n  code: z.string().optional(),\n  message: z.string().optional(),\n  type: z.string().optional(),\n});\n\nconst ErrorBody = z.looseObject({\n  code: z.string().optional(),\n  message: z.string().optional(),\n  error: z.union([z.string(), ErrorObject]).optional(),\n});\n\ninterface GrokErrorBody {\n  code?: string;\n  message?: string;\n}\n\nfunction parseErrorBody(bodyText: string): GrokErrorBody {\n  let json: JsonValue;\n\n  try {\n    // JSON.parse without a reviver yields only JSON values.\n    json = JSON.parse(bodyText);\n  } catch {\n    return bodyText.trim() ? { message: bodyText.trim() } : {};\n  }\n\n  const parsed = ErrorBody.safeParse(json);\n\n  if (!parsed.success) return bodyText.trim() ? { message: bodyText.trim() } : {};\n  const { error } = parsed.data;\n  const errorText = z.string().safeParse(error).data;\n  const errorObject = ErrorObject.safeParse(error).data;\n  const code = parsed.data.code ?? errorObject?.code;\n  const message = errorText ?? errorObject?.message ?? parsed.data.message;\n  const body: GrokErrorBody = {};\n\n  if (code) body.code = code;\n\n  if (message) body.message = message;\n\n  return body;\n}\n\n/**\n * Classifies a non-2xx proxy or api.x.ai response. Pass `status = 0` for a network failure.\n * The body is not trusted to be JSON.\n */\nexport function classifyGrokHttpError(\n  status: number,\n  bodyText: string,\n  headers: HeaderSource,\n): GrokHttpErrorClassification {\n  const body = parseErrorBody(bodyText);\n\n  const message =\n    body.message === undefined ? undefined : body.message.slice(0, MAX_ERROR_MESSAGE_LENGTH);\n\n  const shouldRetry = parseShouldRetry(headers);\n  const retryAfterSec = parseRetryAfterSec(headers);\n\n  const base: Omit<GrokHttpErrorClassification, \"kind\"> = { status };\n\n  if (body.code) base.code = body.code;\n\n  if (message !== undefined) base.message = message;\n\n  if (shouldRetry !== undefined) base.shouldRetry = shouldRetry;\n\n  if (retryAfterSec !== undefined) base.retryAfterSec = retryAfterSec;\n\n  const subscriptionCode = SUBSCRIPTION_CODE_PATTERN.exec(bodyText)?.[0];\n\n  if (status === 401) return { kind: \"auth\", ...base };\n\n  if (status === 426) {\n    const minClientVersion = /\\bversion\\s+(\\d+\\.\\d+\\.\\d+)\\s+or later/i.exec(bodyText)?.[1];\n    const gate: GrokHttpErrorClassification = { kind: \"version_gate\", ...base };\n\n    if (minClientVersion) gate.minClientVersion = minClientVersion;\n\n    return gate;\n  }\n\n  if (status === 429) {\n    if (subscriptionCode) return { kind: \"quota_exhausted\", ...base, code: subscriptionCode };\n\n    return { kind: \"rate_limited\", ...base };\n  }\n\n  if (status === 403) return { kind: \"entitlement\", ...base };\n\n  if (status === 400 || status === 422) return { kind: \"invalid_request\", ...base };\n\n  if (status === 0 || status === 408 || status >= 500) return { kind: \"transient\", ...base };\n\n  return { kind: \"permanent\", ...base };\n}\n"],"mappings":"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"}

package/bundle/dist/utils/providers/grok/grok-constants.js

@@ -0,0 +1,55 @@
+//#region src/utils/providers/grok/grok-constants.ts
+const GROK_CHAT_PROXY_URL = "https://cli-chat-proxy.grok.com/v1";
+const GROK_PUBLIC_API_URL = "https://api.x.ai/v1";
+const GROK_AUTH_ISSUER = "https://auth.x.ai";
+const GROK_OAUTH_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+const GROK_OAUTH_SCOPES = Object.freeze([
+	"openid",
+	"profile",
+	"email",
+	"offline_access",
+	"grok-cli:access",
+	"api:access",
+	"conversations:read",
+	"conversations:write",
+	"workspaces:read",
+	"workspaces:write"
+]);
+const GROK_OAUTH_REFERRER = "grok-build";
+const GROK_DEVICE_CODE_URL = "https://auth.x.ai/oauth2/device/code";
+const GROK_DEVICE_TOKEN_URL = "https://auth.x.ai/oauth2/token";
+const GROK_BUILD_VERSION = "1.0.60";
+const GROK_BUILD_COMMIT = "01a8e1c591c0";
+const GROK_MIN_CLIENT_VERSION_OBSERVED = "1.0.13";
+const GROK_CLIENT_IDENTIFIER = "grok-shell";
+const GROK_CLIENT_MODE = "headless";
+const GROK_DEFAULT_MODEL = "grok-4.7";
+const GROK_IMAGE_DEFAULT_MODEL = "grok-imagine-image-quality";
+const GROK_VIDEO_DEFAULT_MODEL = "grok-imagine-video-1.5";
+const GROK_STT_DEFAULT_MODEL = "grok-voice-transcribe-2.0";
+const GROK_USD_PER_TICK = 1e-10;
+const GROK_REASONING_EFFORTS = Object.freeze([
+	"xhigh",
+	"high",
+	"medium",
+	"low"
+]);
+const GROK_SEED_MODELS = Object.freeze([
+	"grok-4.7",
+	"grok-4.7-build-fast",
+	"grok-4.6",
+	"grok-4.5"
+].map((id) => Object.freeze({
+	id,
+	contextWindow: 256e3,
+	reasoningEfforts: GROK_REASONING_EFFORTS,
+	defaultEffort: "high"
+})));
+const GROK_COMPACTION_AT = 204800;
+const GROK_COMPACTIONS_REMAINING_DEFAULT = 1;
+const GROK_DOOM_LOOP_CHECK = 1024;
+const GROK_EXACT_REPETITION_CHECK = 64;
+//#endregion
+export { GROK_AUTH_ISSUER, GROK_BUILD_COMMIT, GROK_BUILD_VERSION, GROK_CHAT_PROXY_URL, GROK_CLIENT_IDENTIFIER, GROK_CLIENT_MODE, GROK_COMPACTIONS_REMAINING_DEFAULT, GROK_COMPACTION_AT, GROK_DEFAULT_MODEL, GROK_DEVICE_CODE_URL, GROK_DEVICE_TOKEN_URL, GROK_DOOM_LOOP_CHECK, GROK_EXACT_REPETITION_CHECK, GROK_IMAGE_DEFAULT_MODEL, GROK_MIN_CLIENT_VERSION_OBSERVED, GROK_OAUTH_CLIENT_ID, GROK_OAUTH_REFERRER, GROK_OAUTH_SCOPES, GROK_PUBLIC_API_URL, GROK_REASONING_EFFORTS, GROK_SEED_MODELS, GROK_STT_DEFAULT_MODEL, GROK_USD_PER_TICK, GROK_VIDEO_DEFAULT_MODEL };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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