@specode/pi-antigravity 0.0.0-stage → 0.1.0

package/src/request.ts

@@ -0,0 +1,292 @@
+import { createHash, randomUUID } from "node:crypto";
+import type { Api, Model, SimpleStreamOptions, TranscriptContext } from "@earendil-works/pi-ai";
+import { convertMessages, convertTools, mapToolChoice } from "@earendil-works/pi-ai/api/google-shared";
+import { getCurrentSystemPrompt, getCurrentTools } from "@earendil-works/pi-ai/utils/transcript";
+
+const PI_OPENING = "You are a coding assistant running inside pi, a coding agent harness. Help users inspect files, run commands, and modify code.";
+const CLI_OPENING = "You are a coding agent helping the user with their project.";
+const THINKING_LEVELS = new Set(["MINIMAL", "LOW", "MEDIUM", "HIGH"]);
+
+/** Accept explicit off at this boundary; Pi's simple options normally represent it as undefined. */
+export type RequestOptions = Omit<SimpleStreamOptions, "reasoning"> & {
+	reasoning?: SimpleStreamOptions["reasoning"] | "off";
+};
+
+/** Catalog-selected route, already resolved for the requested thinking level. */
+export interface RequestRoute {
+	runtimeId: string;
+	modelEnum: string;
+	thinkingLevel?: "MINIMAL" | "LOW" | "MEDIUM" | "HIGH";
+}
+
+export interface SessionIdentity {
+	readonly cascadeId: string;
+	readonly rootCascadeId: string;
+	readonly trajectoryId: string;
+}
+
+export interface RequestIdentity extends SessionIdentity {
+	readonly projectId: string;
+	readonly requestUuid: string;
+	readonly timestamp: number;
+	readonly requestIndex: number;
+	/** Override after compaction/resume if the caller has a persisted logical step. */
+	readonly step?: number;
+}
+
+export interface RequestIdentityOptions {
+	requestIndex?: number;
+	step?: number;
+	timestamp?: number;
+}
+
+export interface CliRequest {
+	project: string;
+	model: string;
+	requestId: string;
+	requestType: "agent";
+	userAgent: "antigravity";
+	request: {
+		contents: ReturnType<typeof convertMessages>;
+		systemInstruction: { role: "user"; parts: { text: string }[] };
+		tools: NonNullable<ReturnType<typeof convertTools>>;
+		labels: {
+			cascade_id: string;
+			root_cascade_id: string;
+			trajectory_id: string;
+			request_id: string;
+			last_step_index: string;
+			model_enum: string;
+			used_claude: string;
+			used_claude_conservative: string;
+			used_non_gemini_model: string;
+		};
+		generationConfig: {
+			maxOutputTokens: number;
+			temperature?: number;
+			thinkingConfig?: { includeThoughts: true; thinkingLevel: NonNullable<RequestRoute["thinkingLevel"]> };
+		};
+		sessionId: string;
+		toolConfig?: { functionCallingConfig: { mode: ReturnType<typeof mapToolChoice> } };
+	};
+}
+
+/** Rewrite only the exact known leading sentences, never text elsewhere in the prompt. */
+export function rewriteDefaultPrompt(prompt: string): string {
+	if (!prompt.startsWith(PI_OPENING)) return prompt;
+	const suffix = prompt.slice(PI_OPENING.length);
+	if (suffix !== "" && !/^\s/.test(suffix)) return prompt;
+	return CLI_OPENING + suffix;
+}
+
+/** Official hashToSessionID: UTF-8 bytes, unsigned FNV-1a arithmetic, signed decimal output. */
+export function fnvSessionId(seed: string | Uint8Array = ""): string {
+	let hash = 0xcbf29ce484222325n;
+	const bytes = typeof seed === "string" ? new TextEncoder().encode(seed) : seed;
+	for (const byte of bytes) hash = BigInt.asUintN(64, (hash ^ BigInt(byte)) * 0x100000001b3n);
+	return BigInt.asIntN(64, hash).toString();
+}
+
+function sessionUuid(scope: string, key: string): string {
+	const bytes = createHash("sha256").update("pi-antigravity/identity/v1\0").update(scope).update("\0").update(key).digest();
+	// RFC 9562 UUIDv8: provider-local deterministic identity, not an inferred CLI algorithm.
+	bytes[6] = (bytes[6]! & 0x0f) | 0x80;
+	bytes[8] = (bytes[8]! & 0x3f) | 0x80;
+	const hex = bytes.subarray(0, 16).toString("hex");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+/**
+ * No process-global state. Pass a stable, account/session/branch-scoped key to resume;
+ * use a different key for a fork. Omit it for an ephemeral conversation.
+ * These UUIDs are independent of the CLI's FNV sessionId (whose observed seed is empty).
+ */
+export function createSessionIdentity(sessionKey?: string): SessionIdentity {
+	if (sessionKey !== undefined && sessionKey.length === 0) throw new Error("Session key must not be empty");
+	const cascadeId = sessionKey === undefined ? randomUUID() : sessionUuid("cascade", sessionKey);
+	const trajectoryId = sessionKey === undefined ? randomUUID() : sessionUuid("trajectory", sessionKey);
+	return Object.freeze({ cascadeId, rootCascadeId: cascadeId, trajectoryId });
+}
+
+/**
+ * Create once per logical HTTP attempt; reuse the returned value for exact payload replay.
+ * Fresh UUIDs make parallel attempts unique even with identical timestamp/index/step.
+ * requestIndex is caller-owned bookkeeping, not a claimed reconstruction of CLI counters.
+ */
+export function createRequestIdentity(
+	session: SessionIdentity,
+	projectId: string,
+	options: RequestIdentityOptions = {},
+): RequestIdentity {
+	const identity: RequestIdentity = {
+		...session,
+		projectId,
+		requestUuid: randomUUID(),
+		timestamp: options.timestamp ?? Date.now(),
+		requestIndex: options.requestIndex ?? 0,
+		...(options.step === undefined ? {} : { step: options.step }),
+	};
+	validateIdentity(identity);
+	return Object.freeze(identity);
+}
+
+function nonnegativeInteger(value: number, name: string): void {
+	if (!Number.isSafeInteger(value) || value < 0) throw new Error(`${name} must be a nonnegative safe integer`);
+}
+
+function validateIdentity(identity: RequestIdentity): void {
+	const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+	for (const key of ["cascadeId", "rootCascadeId", "trajectoryId", "requestUuid"] as const) {
+		if (!uuid.test(identity[key])) throw new Error(`${key} must be a UUID`);
+	}
+	if (!identity.projectId.trim()) throw new Error("Project ID is required");
+	nonnegativeInteger(identity.timestamp, "timestamp");
+	nonnegativeInteger(identity.requestIndex, "requestIndex");
+	if (identity.step !== undefined) nonnegativeInteger(identity.step, "step");
+}
+
+const SCHEMA_MAPS = new Set(["properties", "patternProperties", "$defs", "definitions", "dependentSchemas", "dependencies"]);
+const SUBSCHEMAS = new Set([
+	"additionalProperties", "unevaluatedProperties", "propertyNames", "items", "prefixItems",
+	"additionalItems", "unevaluatedItems", "contains", "allOf", "anyOf", "oneOf", "not",
+	"if", "then", "else", "contentSchema",
+]);
+const SCHEMA_TYPES = new Set(["string", "number", "integer", "boolean", "array", "object", "null"]);
+const SCHEMA_META = new Set(["$schema", "$id", "$anchor", "$dynamicAnchor", "$vocabulary", "$comment", "$defs", "definitions"]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Visit schema positions, not arbitrary JSON data. Names (including "type" and
+ * "__proto__"), enum/const/default/examples, descriptions and extensions stay intact.
+ * No dereferencing or union flattening: unsupported server schemas must fail visibly.
+ */
+export function uppercaseSchemaTypes(schema: unknown): unknown {
+	return transformSchema(schema, false);
+}
+
+function transformSchema(schema: unknown, legacyParameters: boolean): unknown {
+	if (Array.isArray(schema)) return schema.map((child) => transformSchema(child, legacyParameters));
+	if (!isRecord(schema)) return schema;
+	if (legacyParameters && (Object.hasOwn(schema, "$ref") || Object.hasOwn(schema, "$dynamicRef"))) {
+		throw new Error("CLI parameters do not support schema references; tool declarations must provide an inline schema");
+	}
+	return Object.fromEntries(Object.entries(schema).filter(([key]) => !legacyParameters || !SCHEMA_META.has(key)).map(([key, value]) => {
+		if (key === "type") {
+			const upper = (type: unknown) => typeof type === "string" && SCHEMA_TYPES.has(type) ? type.toUpperCase() : type;
+			return [key, Array.isArray(value) ? value.map(upper) : upper(value)];
+		}
+		if (SCHEMA_MAPS.has(key) && isRecord(value)) {
+			return [key, Object.fromEntries(Object.entries(value).map(([name, child]) => [name, transformSchema(child, legacyParameters)]))];
+		}
+		return [key, SUBSCHEMAS.has(key) ? transformSchema(value, legacyParameters) : structuredClone(value)];
+	}));
+}
+
+function validateThinking(model: Model<Api>, options: RequestOptions | undefined, route: RequestRoute): void {
+	if (!route.runtimeId.trim() || !route.modelEnum.trim()) throw new Error("A catalog runtime ID and model enum are required");
+	if (options?.thinkingBudgets && Object.values(options.thinkingBudgets).some((value) => value !== undefined)) {
+		throw new Error("CLI routes use thinking tiers, not token budgets");
+	}
+	if (!model.reasoning) {
+		if (route.thinkingLevel !== undefined) throw new Error("Nonthinking models must not supply a thinking tier");
+		if (options?.reasoning !== undefined && options.reasoning !== "off") throw new Error("Nonthinking models only accept reasoning off");
+		return;
+	}
+	if (route.thinkingLevel === undefined || !THINKING_LEVELS.has(route.thinkingLevel)) throw new Error("Unsupported or missing CLI thinking tier");
+	if (options?.reasoning === "off") throw new Error("Requested thinking level off does not match a thinking route");
+	if (options?.reasoning !== undefined) {
+		const mapped = model.thinkingLevelMap?.[options.reasoning];
+		const requested = mapped === undefined ? options.reasoning : mapped;
+		if (typeof requested !== "string" || (requested !== route.runtimeId && requested.toUpperCase() !== route.thinkingLevel)) {
+			throw new Error(`Requested thinking level ${options.reasoning} does not match catalog route ${route.runtimeId}/${route.thinkingLevel}`);
+		}
+	}
+}
+
+/**
+ * Pure serialization. Transport owns onPayload (including replacement), response/stream
+ * hooks, authentication headers, endpoint validation, cancellation and HTTP execution.
+ * No fallback model, thinking clamp, endpoint retry, or hidden execution ID is created.
+ */
+export function buildRequest(
+	model: Model<Api>,
+	context: TranscriptContext,
+	options: RequestOptions | undefined,
+	route: RequestRoute,
+	identity: RequestIdentity,
+): CliRequest {
+	validateIdentity(identity);
+	validateThinking(model, options, route);
+	const maxOutputTokens = options?.maxTokens ?? model.maxTokens;
+	if (!Number.isSafeInteger(maxOutputTokens) || maxOutputTokens <= 0 || maxOutputTokens > model.maxTokens) {
+		throw new Error("maxTokens must be a positive integer within the model output limit");
+	}
+	if (options?.temperature !== undefined && (!Number.isFinite(options.temperature) || options.temperature < 0)) {
+		throw new Error("temperature must be a finite nonnegative number");
+	}
+
+	// The public converter's generic accepts Google API names, but its implementation
+	// supports this wire format with custom providers. This is a type-only narrowing:
+	// changing model.id or model.api here would invalidate same-model thought signatures.
+	const contents = structuredClone(convertMessages(model as Model<"google-generative-ai">, context));
+	// Only this exact runtime route has a verified function-response role difference.
+	if (route.runtimeId === "gemini-3.8-flash-low") {
+		for (const content of contents) {
+			if (content.parts?.length && content.parts.every((part) => part.functionResponse !== undefined)) content.role = "model";
+		}
+	}
+
+	const currentTools = getCurrentTools(context.messages);
+	const convertedTools = convertTools(currentTools, true, false) ?? [];
+	const declarations = convertedTools.flatMap((tool) => tool.functionDeclarations);
+	const tools = declarations.map((declaration, index) => ({
+		functionDeclarations: [{
+			...declaration,
+			// Pi 1.5.2's legacy OpenAPI sanitizer walks user name maps as keywords
+			// (and skips arrays). Restore the original schema with a position-aware
+			// traversal so named properties and literal values are not silently lost.
+			// Strip the same meta declarations, but reject references before dropping
+			// their definitions rather than sending a silently broken schema.
+			parameters: transformSchema(currentTools[index]!.parameters, true),
+		}],
+	}));
+	const step = identity.step ?? Math.max(0, contents.length - 1);
+	const usedClaude = route.runtimeId.startsWith("claude-");
+	const payload: CliRequest = {
+		project: identity.projectId,
+		model: route.runtimeId,
+		requestId: `agent/${identity.cascadeId}/${identity.timestamp}/${identity.requestUuid}/${step}`,
+		requestType: "agent",
+		userAgent: "antigravity",
+		request: {
+			contents,
+			systemInstruction: { role: "user", parts: [{ text: rewriteDefaultPrompt(getCurrentSystemPrompt(context.messages)) }] },
+			tools,
+			labels: {
+				cascade_id: identity.cascadeId,
+				root_cascade_id: identity.rootCascadeId,
+				trajectory_id: identity.trajectoryId,
+				request_id: `${identity.requestUuid}-${identity.requestIndex}`,
+				last_step_index: String(step),
+				model_enum: route.modelEnum,
+				used_claude: String(usedClaude),
+				used_claude_conservative: String(usedClaude),
+				used_non_gemini_model: String(!route.runtimeId.startsWith("gemini-")),
+			},
+			generationConfig: {
+				maxOutputTokens,
+				...(options?.temperature === undefined ? {} : { temperature: options.temperature }),
+				...(route.thinkingLevel === undefined ? {} : { thinkingConfig: { includeThoughts: true as const, thinkingLevel: route.thinkingLevel } }),
+			},
+			// The normal CLI path uses an empty seed; Pi's session key is NOT this seed.
+			sessionId: fnvSessionId(),
+			...(options?.toolChoice === undefined ? {} : {
+				toolConfig: { functionCallingConfig: { mode: mapToolChoice(options.toolChoice) } },
+			}),
+		},
+	};
+	return payload;
+}

package/src/stream.ts

@@ -0,0 +1,387 @@
+import { randomUUID } from "node:crypto";
+import type {
+  Api, AssistantMessage, AssistantMessageEventStream, JsonObject, Model, SimpleStreamOptions, TranscriptContext,
+} from "@earendil-works/pi-ai";
+import { calculateCost } from "@earendil-works/pi-ai/models";
+import { createAssistantMessageEventStream } from "@earendil-works/pi-ai/utils/event-stream";
+import { CLIENT_USER_AGENT, DEFAULT_BASE_URL, assertOfficialBaseUrl } from "./client.ts";
+
+export interface AntigravityStreamOptions extends SimpleStreamOptions {
+  /** Response-header deadline, excluding payload building and hooks. Default: 30 seconds. */
+  headTimeoutMs?: number;
+  /** Deadline for each body read, excluding time spent in observer hooks. Default: 120 seconds. */
+  idleTimeoutMs?: number;
+}
+
+export interface AntigravityStreamCredentials {
+  token: string;
+  baseUrl?: string;
+}
+
+export interface AntigravityStreamDependencies {
+  buildPayload(model: Model<Api>, context: TranscriptContext, options: AntigravityStreamOptions): unknown | Promise<unknown>;
+  resolveCredentials(model: Model<Api>, options: AntigravityStreamOptions): AntigravityStreamCredentials | Promise<AntigravityStreamCredentials>;
+  fetch?: typeof globalThis.fetch;
+}
+
+/** Evidence is provider data, not a guessed quota/retry classification. Never logged here. */
+export class AntigravityStreamError extends Error {
+  constructor(message: string, readonly evidence: JsonObject = {}) {
+    super(message);
+    this.name = "AntigravityStreamError";
+  }
+}
+
+const MAX_FRAME_CHARS = 4 * 1024 * 1024;
+const MAX_ERROR_BYTES = 64 * 1024;
+
+/** Incremental SSE framing. A partial data frame at EOF is an error, not a successful response. */
+class SseDecoder {
+  private decoder = new TextDecoder("utf-8", { fatal: true });
+  private line = "";
+  private data: string[] = [];
+  private frameChars = 0;
+  private skipLF = false;
+
+  push(bytes: Uint8Array): string[] {
+    return this.consume(this.decoder.decode(bytes, { stream: true }));
+  }
+
+  finish(): string[] {
+    const frames = this.consume(this.decoder.decode());
+    if (this.data.length || (this.line && !this.line.startsWith(":"))) {
+      throw new AntigravityStreamError("Antigravity SSE ended with an incomplete frame");
+    }
+    return frames;
+  }
+
+  private consume(text: string): string[] {
+    const frames: string[] = [];
+    for (const char of text) {
+      if (this.skipLF) {
+        this.skipLF = false;
+        if (char === "\n") continue;
+      }
+      if (++this.frameChars > MAX_FRAME_CHARS) throw new AntigravityStreamError("Antigravity SSE frame exceeds the size limit");
+      if (char === "\r" || char === "\n") {
+        if (char === "\r") this.skipLF = true;
+        if (this.line === "") {
+          if (this.data.length) frames.push(this.data.join("\n"));
+          this.data = [];
+          this.frameChars = 0;
+        } else if (this.line === "data" || this.line.startsWith("data:")) {
+          let value = this.line.slice(5);
+          if (value.startsWith(" ")) value = value.slice(1);
+          this.data.push(value);
+        }
+        this.line = "";
+      } else {
+        this.line += char;
+      }
+    }
+    return frames;
+  }
+}
+
+function object(value: unknown, label: string): Record<string, unknown> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new AntigravityStreamError(`Invalid Antigravity ${label}: expected an object`);
+  }
+  return value as Record<string, unknown>;
+}
+
+function optionalString(value: unknown, label: string): string | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value !== "string") throw new AntigravityStreamError(`Invalid Antigravity ${label}: expected a string`);
+  return value;
+}
+
+function deadline(value: number | undefined, fallback: number): number {
+  const ms = value ?? fallback;
+  if (!Number.isFinite(ms) || ms <= 0 || ms > 2 ** 31 - 1) {
+    throw new AntigravityStreamError("Antigravity timeouts must be positive finite milliseconds within the timer range");
+  }
+  return ms;
+}
+
+/** Race even non-cooperative injected I/O/hooks against cancellation; always remove listeners/timers. */
+async function waitFor<T>(work: PromiseLike<T> | T, controller: AbortController, timeoutMs?: number, phase?: string): Promise<T> {
+  const signal = controller.signal;
+  const promise = Promise.resolve(work);
+  if (signal.aborted) {
+    void promise.catch(() => {});
+    signal.throwIfAborted();
+  }
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let abort: () => void = () => {};
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<never>((_, reject) => {
+        abort = () => reject(signal.reason);
+        signal.addEventListener("abort", abort, { once: true });
+        if (timeoutMs !== undefined) {
+          timer = setTimeout(() => controller.abort(new AntigravityStreamError(
+            `Antigravity ${phase} timeout after ${timeoutMs}ms`, { phase: phase ?? "unknown", timeoutMs },
+          )), timeoutMs);
+        }
+      }),
+    ]);
+  } finally {
+    signal.removeEventListener("abort", abort);
+    clearTimeout(timer);
+  }
+}
+
+/** One logical request, one fetch, no internal retry or endpoint failover. */
+export function streamAntigravity(
+  model: Model<Api>,
+  context: TranscriptContext,
+  options: AntigravityStreamOptions | undefined,
+  dependencies: AntigravityStreamDependencies,
+): AssistantMessageEventStream {
+  const stream = createAssistantMessageEventStream();
+  const output: AssistantMessage = {
+    role: "assistant", content: [], api: model.api, provider: model.provider, model: model.id,
+    timestamp: Date.now(), stopReason: "pending",
+    usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+  };
+  const controller = new AbortController();
+  const abort = () => controller.abort(options?.signal?.reason ?? new Error("Request aborted"));
+  options?.signal?.addEventListener("abort", abort, { once: true });
+  if (options?.signal?.aborted) abort();
+  const effectiveOptions: AntigravityStreamOptions = { ...options, signal: controller.signal };
+
+  void (async () => {
+    let reader: ReadableStreamDefaultReader<Uint8Array> | undefined;
+    let currentIndex: number | undefined;
+    let finishReason: string | undefined;
+    const usage: Record<string, number> = {};
+    const closeBlock = () => {
+      if (currentIndex === undefined) return;
+      const block = output.content[currentIndex]!;
+      if (block.type === "text") stream.push({ type: "text_end", contentIndex: currentIndex, content: block.text, partial: output });
+      if (block.type === "thinking") stream.push({ type: "thinking_end", contentIndex: currentIndex, content: block.thinking, partial: output });
+      currentIndex = undefined;
+    };
+    const readUsage = (value: unknown) => {
+      for (const [key, count] of Object.entries(object(value, "usageMetadata"))) {
+        if (!["promptTokenCount", "candidatesTokenCount", "cachedContentTokenCount", "thoughtsTokenCount", "totalTokenCount"].includes(key)) continue;
+        if (typeof count !== "number" || !Number.isSafeInteger(count) || count < 0) {
+          throw new AntigravityStreamError(`Invalid Antigravity usage counter: ${key}`);
+        }
+        usage[key] = count;
+      }
+      const cached = usage.cachedContentTokenCount ?? 0;
+      const prompt = usage.promptTokenCount ?? cached;
+      if (cached > prompt) throw new AntigravityStreamError("Antigravity cached tokens exceed prompt tokens");
+      output.usage.input = prompt - cached;
+      output.usage.cacheRead = cached;
+      output.usage.output = (usage.candidatesTokenCount ?? 0) + (usage.thoughtsTokenCount ?? 0);
+      if (usage.thoughtsTokenCount !== undefined) output.usage.reasoning = usage.thoughtsTokenCount;
+      output.usage.totalTokens = usage.totalTokenCount ?? prompt + output.usage.output;
+      calculateCost(model, output.usage);
+    };
+    const readPart = (value: unknown, explicitBoundary: boolean) => {
+      const part = object(value, "part");
+      const signature = optionalString(part.thoughtSignature, "thoughtSignature");
+      if (part.functionCall !== undefined) {
+        if (finishReason) throw new AntigravityStreamError("Antigravity sent a tool call after the finish reason");
+        if (part.text !== undefined) throw new AntigravityStreamError("Antigravity part contains both text and functionCall");
+        const call = object(part.functionCall, "functionCall");
+        const name = optionalString(call.name, "functionCall.name");
+        if (!name) throw new AntigravityStreamError("Antigravity function call has no name");
+        const id = optionalString(call.id, "functionCall.id") || `agy_${randomUUID()}`;
+        if (output.content.some((b) => b.type === "toolCall" && b.id === id)) {
+          throw new AntigravityStreamError("Antigravity returned a duplicate function-call ID", { id });
+        }
+        const args = object(call.args ?? {}, "functionCall.args") as JsonObject;
+        closeBlock();
+        const toolCall = { type: "toolCall" as const, id, name, arguments: args,
+          ...(signature ? { thoughtSignature: signature } : {}) };
+        const contentIndex = output.content.push(toolCall) - 1;
+        stream.push({ type: "toolcall_start", contentIndex, partial: output });
+        stream.push({ type: "toolcall_delta", contentIndex, delta: JSON.stringify(args), partial: output });
+        stream.push({ type: "toolcall_end", contentIndex, toolCall, partial: output });
+      } else if (part.text !== undefined) {
+        const text = optionalString(part.text, "part.text")!;
+        if (finishReason && text !== "") throw new AntigravityStreamError("Antigravity sent text after the finish reason");
+        if (part.thought !== undefined && typeof part.thought !== "boolean") throw new AntigravityStreamError("Invalid Antigravity thought flag");
+        const type = part.thought === true ? "thinking" : "text";
+        // Separate explicit parts and every signed part. Unindexed, unsigned deltas in
+        // later frames can extend the current block, but signatures never move to it.
+        if (explicitBoundary || signature) closeBlock();
+        if (currentIndex === undefined || output.content[currentIndex]!.type !== type) {
+          closeBlock();
+          currentIndex = output.content.push(type === "text" ? { type, text: "" } : { type, thinking: "" }) - 1;
+          stream.push({ type: type === "text" ? "text_start" : "thinking_start", contentIndex: currentIndex, partial: output });
+        }
+        const block = output.content[currentIndex]!;
+        if (block.type === "text") {
+          block.text += text;
+          if (signature) block.textSignature = signature;
+          stream.push({ type: "text_delta", contentIndex: currentIndex, delta: text, partial: output });
+        } else if (block.type === "thinking") {
+          block.thinking += text;
+          if (signature) block.thinkingSignature = signature;
+          stream.push({ type: "thinking_delta", contentIndex: currentIndex, delta: text, partial: output });
+        }
+      } else {
+        throw new AntigravityStreamError("Unsupported Antigravity response part", { keys: Object.keys(part) });
+      }
+    };
+    const readEvent = async (data: string): Promise<boolean> => {
+      if (data === "[DONE]") return true;
+      let parsed: unknown;
+      try { parsed = JSON.parse(data); } catch {
+        throw new AntigravityStreamError("Antigravity SSE contains invalid JSON");
+      }
+      await waitFor(effectiveOptions.onProviderStreamEvent?.(parsed, model), controller);
+      controller.signal.throwIfAborted();
+      const envelope = object(parsed, "event");
+      if (envelope.error !== undefined) {
+        throw new AntigravityStreamError(`Antigravity stream error: ${JSON.stringify(envelope.error)}`, { body: envelope as JsonObject });
+      }
+      const response = object(envelope.response, "response");
+      if (response.error !== undefined) {
+        throw new AntigravityStreamError(`Antigravity stream error: ${JSON.stringify(response.error)}`, { body: envelope as JsonObject });
+      }
+      output.responseId ||= optionalString(response.responseId, "responseId") || undefined;
+      output.responseModel ||= optionalString(response.modelVersion, "modelVersion") || undefined;
+      // Keep upstream provenance without substituting the requested runtime model for a confirmed model.
+      if (envelope.traceId !== undefined || envelope.metadata !== undefined) {
+        const details: JsonObject = {};
+        if (envelope.traceId !== undefined) details.traceId = optionalString(envelope.traceId, "traceId")!;
+        if (envelope.metadata !== undefined) details.metadata = object(envelope.metadata, "metadata") as JsonObject;
+        const existing = output.diagnostics?.find((d) => d.type === "antigravity.response");
+        if (existing) existing.details = { ...existing.details, ...details };
+        else (output.diagnostics ??= []).push({ type: "antigravity.response", timestamp: Date.now(), details });
+      }
+      if (response.usageMetadata !== undefined) readUsage(response.usageMetadata);
+      if (response.promptFeedback !== undefined) {
+        const feedback = object(response.promptFeedback, "promptFeedback");
+        if (feedback.blockReason) throw new AntigravityStreamError("Antigravity blocked the prompt", { promptFeedback: feedback as JsonObject });
+      }
+      if (response.candidates !== undefined) {
+        if (!Array.isArray(response.candidates) || response.candidates.length > 1) throw new AntigravityStreamError("Invalid Antigravity candidates");
+        if (response.candidates.length) {
+          const candidate = object(response.candidates[0], "candidate");
+          if (candidate.index !== undefined && candidate.index !== 0) throw new AntigravityStreamError("Unsupported Antigravity candidate index");
+          if (candidate.content !== undefined) {
+            const content = object(candidate.content, "content");
+            if (!Array.isArray(content.parts)) throw new AntigravityStreamError("Invalid Antigravity content.parts");
+            for (let i = 0; i < content.parts.length; i++) readPart(content.parts[i], i > 0);
+          }
+          if (candidate.finishReason !== undefined) {
+            const reason = optionalString(candidate.finishReason, "finishReason")!;
+            if (finishReason && finishReason !== reason) throw new AntigravityStreamError("Conflicting Antigravity finish reasons");
+            finishReason = reason;
+            output.rawStopReason = reason;
+            if (reason !== "STOP" && reason !== "MAX_TOKENS") {
+              throw new AntigravityStreamError(`Antigravity stopped with: ${reason}`, { candidate: candidate as JsonObject });
+            }
+          }
+        }
+      }
+      return false;
+    };
+
+    try {
+      controller.signal.throwIfAborted();
+      const headMs = deadline(options?.headTimeoutMs ?? options?.timeoutMs, 30_000);
+      const idleMs = deadline(options?.idleTimeoutMs ?? options?.timeoutMs, 120_000);
+      const credentials = await waitFor(dependencies.resolveCredentials(model, effectiveOptions), controller);
+      if (!credentials.token) throw new AntigravityStreamError("Missing Antigravity access token");
+      const baseUrl = assertOfficialBaseUrl(credentials.baseUrl ?? (model.baseUrl || DEFAULT_BASE_URL));
+      let payload = await waitFor(dependencies.buildPayload(model, context, effectiveOptions), controller);
+      const replacement = await waitFor(effectiveOptions.onPayload?.(payload, model), controller);
+      if (replacement !== undefined) payload = replacement;
+      controller.signal.throwIfAborted();
+      const body = JSON.stringify(payload);
+      if (body === undefined) throw new AntigravityStreamError("Antigravity payload is not JSON serializable");
+      const headers = new Headers({ Authorization: `Bearer ${credentials.token}`, "Content-Type": "application/json", "User-Agent": CLIENT_USER_AGENT });
+      for (const source of [model.headers, options?.headers]) {
+        for (const [key, value] of Object.entries(source ?? {})) {
+          if (value === null) headers.delete(key);
+          else headers.set(key, value);
+        }
+      }
+      const fetching = Promise.resolve((options?.fetch ?? dependencies.fetch ?? globalThis.fetch)(
+        `${baseUrl}/v1internal:streamGenerateContent?alt=sse`,
+        { method: "POST", redirect: "error", headers, body, signal: controller.signal },
+      ));
+      // An injected fetch might ignore abort and resolve late; do not leak its body.
+      void fetching.then((response) => {
+        if (controller.signal.aborted && !reader) void response.body?.cancel().catch(() => {});
+      }, () => {});
+      const response = await waitFor(fetching, controller, headMs, "response-header");
+      reader = response.body?.getReader();
+      await waitFor(effectiveOptions.onResponse?.({ status: response.status, headers: Object.fromEntries(response.headers) }, model), controller);
+      if (!response.ok) {
+        let text = "";
+        let bytes = 0;
+        const decoder = new TextDecoder();
+        if (reader) {
+          while (true) {
+            const chunk = await waitFor(reader.read(), controller, idleMs, "body-idle");
+            if (chunk.done) break;
+            bytes += chunk.value.byteLength;
+            if (bytes > MAX_ERROR_BYTES) throw new AntigravityStreamError(`Antigravity HTTP ${response.status}: error body exceeds the size limit`, { status: response.status });
+            text += decoder.decode(chunk.value, { stream: true });
+          }
+        }
+        text += decoder.decode();
+        let errorBody: unknown = text;
+        try { errorBody = JSON.parse(text); } catch { /* Preserve non-JSON HTTP evidence verbatim. */ }
+        throw new AntigravityStreamError(`Antigravity HTTP ${response.status}: ${text || response.statusText}`, {
+          status: response.status, body: errorBody as JsonObject | string,
+          ...(response.headers.has("retry-after") ? { retryAfter: response.headers.get("retry-after")! } : {}),
+        });
+      }
+      if (!reader) throw new AntigravityStreamError("Antigravity response has no body");
+      if (!/^text\/event-stream(?:\s*;|$)/i.test(response.headers.get("content-type") ?? "")) {
+        throw new AntigravityStreamError("Antigravity response is not text/event-stream");
+      }
+      stream.push({ type: "start", partial: output });
+      const sse = new SseDecoder();
+      let done = false;
+      while (!done) {
+        const chunk = await waitFor(reader.read(), controller, idleMs, "body-idle");
+        controller.signal.throwIfAborted();
+        const frames = chunk.done ? sse.finish() : sse.push(chunk.value);
+        for (const data of frames) {
+          if (done) throw new AntigravityStreamError("Antigravity sent data after [DONE]");
+          done = await readEvent(data);
+        }
+        if (chunk.done) break;
+      }
+      controller.signal.throwIfAborted();
+      if (!finishReason) throw new AntigravityStreamError("Antigravity stream ended without a finish reason");
+      closeBlock();
+      output.stopReason = finishReason === "MAX_TOKENS" ? "length"
+        : output.content.some((b) => b.type === "toolCall") ? "toolUse" : "stop";
+      stream.push({ type: "done", reason: output.stopReason, message: output });
+    } catch (error) {
+      closeBlock();
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = output.stopReason === "aborted" ? "Antigravity request aborted"
+        : error instanceof Error ? error.message : String(error);
+      if (error instanceof AntigravityStreamError) {
+        (output.diagnostics ??= []).push({ type: "antigravity.error", timestamp: Date.now(), details: error.evidence,
+          error: { name: error.name, message: error.message } });
+      }
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+    } finally {
+      options?.signal?.removeEventListener("abort", abort);
+      // Do not let a broken source's cancellation promise hold the terminal result open.
+      if (reader) {
+        void reader.cancel().catch(() => {});
+        reader.releaseLock();
+      }
+      controller.abort();
+      stream.end();
+    }
+  })();
+  return stream;
+}