nolo-cli 0.105.0-alpha.2 → 0.105.0

package/chunk-YK5MHOWM.js

@@ -0,0 +1,915 @@
+import {
+  streamSseDataValues
+} from "./chunk-GMZLP5DV.js";
+import {
+  getAntigravityUserAgent,
+  readAntigravityProjectId,
+  resolveAntigravityCloudCodeBaseUrl
+} from "./chunk-UA324D4O.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/core/chat/upstreamErrorBody.ts
+function parseUpstreamErrorBody(errorText, statusText) {
+  if (errorText) {
+    try {
+      const parsed = JSON.parse(errorText);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const error = parsed.error;
+        if (error && typeof error === "object" && !Array.isArray(error)) {
+          return parsed;
+        }
+      }
+    } catch {
+    }
+  }
+  return { error: { message: errorText || statusText } };
+}
+
+// packages/agent-runtime/antigravityCloudCodeProvider.ts
+import { randomUUID } from "node:crypto";
+
+// packages/agent-runtime/antigravityWireModel.ts
+var WIRE_PROFILES = {
+  // Antigravity discovery exposes 3.7 Flash as one tiered wire model.
+  // The UI labels its effort variants (Low/Medium/High), but the literal
+  // -medium/-high ids return 404 from streamGenerateContent.
+  "gemini-3.7-flash-tiered": { modelEnum: "MODEL_PLACEHOLDER_M301", maxOutputTokens: 65536 },
+  // Gemini 3.8 Flash 沿用 3.7 的 tiered 兼容策略：仓库内暂无 Antigravity discovery
+  // 证据确认 3.8 的 wire modelEnum，禁止虚构，先只声明同档输出上限；enum 待
+  // discovery 证据到位后补齐。
+  "gemini-3.8-flash-tiered": { maxOutputTokens: 65536 },
+  "gemini-3.6-flash-low": { maxOutputTokens: 65536 },
+  "gemini-3.6-flash-medium": { maxOutputTokens: 65536 },
+  "gemini-3.6-flash-high": { maxOutputTokens: 65536 },
+  // 旧模型 wire 映射保留：存量自定义 agent 仍可能引用（注册表已下线不影响此处）。
+  "gemini-3.5-flash-extra-low": { modelEnum: "MODEL_PLACEHOLDER_M187", maxOutputTokens: 65536 },
+  "gemini-3.5-flash-low": { modelEnum: "MODEL_PLACEHOLDER_M20", maxOutputTokens: 65536 },
+  "gemini-3-flash-agent": { modelEnum: "MODEL_PLACEHOLDER_M132", maxOutputTokens: 65536 },
+  "gemini-3.1-pro-low": { modelEnum: "MODEL_PLACEHOLDER_M36", maxOutputTokens: 65535 },
+  "gemini-pro-agent": { modelEnum: "MODEL_PLACEHOLDER_M16", maxOutputTokens: 65535 },
+  "claude-sonnet-5": { maxOutputTokens: 64e3 },
+  "claude-sonnet-4-6": { maxOutputTokens: 64e3 },
+  "claude-opus-4-6-thinking": { maxOutputTokens: 64e3 },
+  "gemini-2.5-flash": { maxOutputTokens: 65536 },
+  "gemini-2.5-pro": { maxOutputTokens: 65536 }
+};
+function resolveAntigravityWireModel(logicalModelId) {
+  const id = logicalModelId.trim();
+  const lower = id.toLowerCase();
+  if (lower === "gemini-3.5-flash") {
+    const wireModelId = "gemini-3.5-flash-low";
+    return { wireModelId, profile: WIRE_PROFILES[wireModelId] };
+  }
+  if (lower === "gemini-3.7-flash" || ["gemini-3.7-flash-low", "gemini-3.7-flash-medium", "gemini-3.7-flash-high"].includes(lower)) {
+    const wireModelId = "gemini-3.7-flash-tiered";
+    return { wireModelId, profile: WIRE_PROFILES[wireModelId] };
+  }
+  if (lower === "gemini-3.8-flash" || ["gemini-3.8-flash-low", "gemini-3.8-flash-medium", "gemini-3.8-flash-high"].includes(lower)) {
+    const wireModelId = "gemini-3.8-flash-tiered";
+    return { wireModelId, profile: WIRE_PROFILES[wireModelId] };
+  }
+  if (lower === "gemini-3.6-flash") {
+    const wireModelId = "gemini-3.6-flash-low";
+    return { wireModelId, profile: WIRE_PROFILES[wireModelId] };
+  }
+  if (lower === "gemini-3.1-pro" || lower === "gemini-3.1-pro-preview") {
+    const wireModelId = "gemini-3.1-pro-low";
+    return { wireModelId, profile: WIRE_PROFILES[wireModelId] };
+  }
+  if (WIRE_PROFILES[id]) {
+    return { wireModelId: id, profile: WIRE_PROFILES[id] };
+  }
+  return { wireModelId: id };
+}
+
+// packages/agent-runtime/sseDataLine.ts
+function parseSseDataLineJson(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("data:")) return null;
+  const payload = trimmed.slice(5).trim();
+  if (!payload || payload === "[DONE]") return null;
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return null;
+  }
+}
+function parseSseDataLineObject(line) {
+  const parsed = parseSseDataLineJson(line);
+  return parsed && typeof parsed === "object" ? parsed : null;
+}
+
+// packages/agent-runtime/geminiNativeShared.ts
+var SKIP_THOUGHT_SIGNATURE = "skip_thought_signature_validator";
+function resolveGeminiModelQuirks(modelId) {
+  const lower = modelId.toLowerCase();
+  const isGemini3 = lower.includes("gemini-3");
+  const isStrictSignatureModel = lower.includes("gemini-3.5") || lower.includes("flash-preview");
+  const isClaude = lower.includes("claude");
+  return {
+    requiresThoughtSignature: isGemini3,
+    allowsThoughtSignatureSentinel: isGemini3 && !isStrictSignatureModel,
+    isClaudeCrossModel: isClaude
+  };
+}
+function isGemini3Model(modelId) {
+  return resolveGeminiModelQuirks(modelId).requiresThoughtSignature;
+}
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter(
+    (part) => part?.type === "text"
+  ).map((part) => part.text).join("\n").trim();
+}
+function parseDataUrlToInlineData(url) {
+  const match = /^data:([A-Za-z0-9.+-]+\/[A-Za-z0-9.+-]+);base64,([A-Za-z0-9+/=]*)$/.exec(
+    url
+  );
+  if (!match) return null;
+  return { mimeType: match[1], data: match[2] };
+}
+function extractInlineDataParts(content) {
+  if (!Array.isArray(content)) return [];
+  const parts = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") continue;
+    if (part.type !== "image_url") continue;
+    const url = part.image_url?.url;
+    if (typeof url !== "string" || !url.trim()) continue;
+    const inline = parseDataUrlToInlineData(url);
+    if (inline) parts.push({ inlineData: inline });
+  }
+  return parts;
+}
+function convertOpenAiMessagesToGemini(messages, options) {
+  const contents = [];
+  const systemTexts = [];
+  let toolCallIndex = 0;
+  let pendingFunctionCalls = [];
+  const pushOrMergeContent = (role, parts) => {
+    if (parts.length === 0) return;
+    const last = contents[contents.length - 1];
+    if (last && last.role === role) {
+      last.parts.push(...parts);
+    } else {
+      contents.push({ role, parts });
+    }
+  };
+  const flushPendingFunctionCalls = () => {
+    if (pendingFunctionCalls.length === 0) return;
+    const dummyResponses = pendingFunctionCalls.map(
+      ({ name, id }) => ({
+        functionResponse: {
+          name,
+          response: { output: "{}" },
+          ...id ? { id } : {}
+        }
+      })
+    );
+    pendingFunctionCalls = [];
+    pushOrMergeContent("user", dummyResponses);
+  };
+  for (const raw of messages) {
+    if (!raw || typeof raw !== "object" || !("role" in raw)) continue;
+    const role = String(raw.role);
+    const content = "content" in raw ? raw.content : null;
+    if (role === "system") {
+      const text = messageText(
+        content
+      );
+      if (text) systemTexts.push(text);
+      continue;
+    }
+    if (role === "user") {
+      flushPendingFunctionCalls();
+      const text = messageText(
+        content
+      );
+      const imageParts = extractInlineDataParts(
+        content
+      );
+      if (!text && imageParts.length === 0) continue;
+      const parts = [];
+      if (text) parts.push({ text });
+      for (const img of imageParts) parts.push(img);
+      pushOrMergeContent("user", parts);
+      continue;
+    }
+    if (role === "assistant") {
+      flushPendingFunctionCalls();
+      const text = messageText(
+        content
+      );
+      const toolCalls = "tool_calls" in raw && Array.isArray(raw.tool_calls) ? raw.tool_calls ?? [] : [];
+      const parts = [];
+      if (text) {
+        parts.push({ text });
+      }
+      for (const call of toolCalls) {
+        const name = call?.function?.name?.trim();
+        if (!name) continue;
+        const id = call.id?.trim() || `${name}_${toolCallIndex++}`;
+        pendingFunctionCalls.push({ name, id });
+        const realSignature = typeof call.thought_signature === "string" && call.thought_signature ? call.thought_signature : void 0;
+        const isFirstFunctionCallPart = !parts.some(
+          (p) => "functionCall" in p
+        );
+        const signature = realSignature ?? (options.attachSkipThoughtSignature && isFirstFunctionCallPart ? SKIP_THOUGHT_SIGNATURE : void 0);
+        const part = {
+          functionCall: {
+            name,
+            args: parseToolArgs(call.function?.arguments),
+            ...id ? { id } : {}
+          },
+          ...signature ? { thoughtSignature: signature } : {}
+        };
+        parts.push(part);
+      }
+      pushOrMergeContent("model", parts);
+      continue;
+    }
+    if (role === "tool") {
+      const toolCallId = "tool_call_id" in raw && typeof raw.tool_call_id === "string" ? raw.tool_call_id : "";
+      const rawName = "name" in raw && typeof raw.name === "string" ? raw.name.trim() : "";
+      const pendingIndex = pendingFunctionCalls.findIndex(
+        (p) => toolCallId ? p.id === toolCallId : rawName ? p.name === rawName : true
+      );
+      if (pendingIndex === -1) continue;
+      const [{ name, id }] = pendingFunctionCalls.splice(pendingIndex, 1);
+      const output = messageText(content) || "{}";
+      pushOrMergeContent("user", [
+        {
+          functionResponse: {
+            name,
+            response: { output },
+            // 保留 OpenAI tool_call_id：antigravity Cloud Code Assist 网关把
+            // Gemini contents 转成 Claude messages 时需要 functionResponse →
+            // tool_result 的 tool_use_id；缺 id 时网关报
+            // "tool_result.tool_use_id: Field required"（HTTP 400）。
+            ...id ? { id } : {}
+          }
+        }
+      ]);
+    }
+  }
+  flushPendingFunctionCalls();
+  if (contents.length > 0 && contents[0]?.role === "model") {
+    contents.unshift({
+      role: "user",
+      parts: [{ text: "Continue the conversation." }]
+    });
+  }
+  return { contents, systemTexts };
+}
+function parseToolArgs(raw) {
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    return raw;
+  }
+  return {};
+}
+function sanitizeGeminiSchemaNode(node, active) {
+  const out = {};
+  if (!node || typeof node !== "object" || Array.isArray(node)) {
+    return { type: "string" };
+  }
+  if (active?.has(node)) {
+    return { type: "object", description: "(circular schema reference)" };
+  }
+  const seen = active ?? /* @__PURE__ */ new WeakSet();
+  seen.add(node);
+  try {
+    return sanitizeGeminiSchemaNodeInner(node, out, seen);
+  } finally {
+    seen.delete(node);
+  }
+}
+var enumMetaByNode = /* @__PURE__ */ new WeakMap();
+function enumMetaOf(node) {
+  return node && typeof node === "object" ? enumMetaByNode.get(node) : void 0;
+}
+function rawEnumValues(src) {
+  if (Array.isArray(src.enum) && src.enum.length > 0) return src.enum;
+  if ("const" in src && src.const !== void 0) return [src.const];
+  return void 0;
+}
+function geminiEnumFields(values, baseDescription) {
+  if (values.every((v) => typeof v === "string")) {
+    return {
+      enum: [...new Set(values)],
+      description: baseDescription
+    };
+  }
+  if (values.every((v) => typeof v === "number" || typeof v === "boolean")) {
+    const allowed2 = [...new Set(values.map((v) => String(v)))].join(", ");
+    const note2 = `(allowed: ${allowed2})`;
+    return {
+      description: baseDescription ? `${baseDescription} ${note2}` : note2
+    };
+  }
+  const allowed = [...new Set(values.map(geminiEnumLiteral))].join(", ");
+  const note = `(allowed: ${allowed})`;
+  return {
+    description: baseDescription ? `${baseDescription} ${note}` : note
+  };
+}
+function geminiEnumLiteral(value) {
+  const json = JSON.stringify(value);
+  return json === void 0 ? String(value) : json;
+}
+function applyGeminiEnum(out, fields) {
+  if (fields.enum) out.enum = fields.enum;
+  if (fields.description !== void 0) out.description = fields.description;
+}
+function sanitizeGeminiSchemaNodeInner(src, out, seen) {
+  if (Array.isArray(src.type)) {
+    const firstNonNull = src.type.find((t) => t !== "null");
+    if (typeof firstNonNull === "string") out.type = firstNonNull;
+    out.nullable = true;
+  } else if (typeof src.type === "string") {
+    out.type = src.type;
+  }
+  if (typeof src.description === "string") out.description = src.description;
+  if (typeof src.minimum === "number") out.minimum = src.minimum;
+  if (typeof src.maximum === "number") out.maximum = src.maximum;
+  if (src.nullable === true) out.nullable = true;
+  const enumValues = rawEnumValues(src);
+  if (enumValues) {
+    const baseDescription = typeof src.description === "string" ? src.description : void 0;
+    enumMetaByNode.set(out, { values: enumValues, baseDescription });
+    applyGeminiEnum(out, geminiEnumFields(enumValues, baseDescription));
+  }
+  const variantBranches = [
+    ...Array.isArray(src.oneOf) ? src.oneOf : [],
+    ...Array.isArray(src.anyOf) ? src.anyOf : []
+  ];
+  if (variantBranches.length > 0) {
+    const mergedProperties = {};
+    let requiredIntersection;
+    for (const branch of variantBranches) {
+      const sanitized = sanitizeGeminiSchemaNode(branch, seen);
+      const branchProperties = sanitized.properties ?? {};
+      for (const [key, value] of Object.entries(branchProperties)) {
+        const previous = mergedProperties[key];
+        const prevMeta = enumMetaOf(previous);
+        const nextMeta = enumMetaOf(value);
+        if (prevMeta && nextMeta) {
+          const values = [...prevMeta.values, ...nextMeta.values];
+          const baseDescription = nextMeta.baseDescription ?? prevMeta.baseDescription;
+          const node = {
+            ...value
+          };
+          delete node.enum;
+          delete node.description;
+          applyGeminiEnum(node, geminiEnumFields(values, baseDescription));
+          enumMetaByNode.set(node, { values, baseDescription });
+          mergedProperties[key] = node;
+        } else {
+          mergedProperties[key] = value;
+        }
+      }
+      const branchRequired = Array.isArray(sanitized.required) ? sanitized.required : [];
+      requiredIntersection = requiredIntersection === void 0 ? [...branchRequired] : requiredIntersection.filter((r) => branchRequired.includes(r));
+    }
+    out.properties = {
+      ...out.properties ?? {},
+      ...mergedProperties
+    };
+    if (requiredIntersection !== void 0 && requiredIntersection.length > 0) {
+      out.required = requiredIntersection;
+    }
+    if (typeof out.type !== "string") out.type = "object";
+  }
+  if (Array.isArray(src.allOf)) {
+    for (const branch of src.allOf) {
+      const sanitized = sanitizeGeminiSchemaNode(branch, seen);
+      out.properties = {
+        ...out.properties ?? {},
+        ...sanitized.properties ?? {}
+      };
+      if (Array.isArray(sanitized.required)) {
+        out.required = [
+          .../* @__PURE__ */ new Set([
+            ...out.required ?? [],
+            ...sanitized.required ?? []
+          ])
+        ];
+      }
+    }
+    if (typeof out.type !== "string") out.type = "object";
+  }
+  if (src.properties && typeof src.properties === "object") {
+    const properties = {};
+    for (const [key, value] of Object.entries(
+      src.properties
+    )) {
+      properties[key] = sanitizeGeminiSchemaNode(value, seen);
+    }
+    out.properties = properties;
+    if (typeof out.type !== "string") out.type = "object";
+  }
+  if (Array.isArray(src.required)) {
+    const properties = out.properties ?? {};
+    const required = [...new Set(src.required)].filter(
+      (r) => typeof r === "string" && r in properties
+    );
+    if (required.length > 0) out.required = required;
+  }
+  if (src.items !== void 0) {
+    out.items = sanitizeGeminiSchemaNode(src.items, seen);
+    if (typeof out.type !== "string") out.type = "array";
+  }
+  if (typeof out.type !== "string") out.type = "object";
+  return out;
+}
+function convertOpenAiToolsToGemini(tools) {
+  if (!Array.isArray(tools) || tools.length === 0) return void 0;
+  const declarations = [];
+  for (const tool of tools) {
+    if (!tool || typeof tool !== "object" || !("function" in tool)) continue;
+    const fn = tool.function;
+    const name = typeof fn.name === "string" ? fn.name : "";
+    if (!name) continue;
+    declarations.push({
+      name,
+      description: typeof fn.description === "string" ? fn.description : "",
+      parameters: sanitizeGeminiSchemaNode(
+        fn.parameters ?? { type: "object", properties: {} }
+      )
+    });
+  }
+  if (declarations.length === 0) return void 0;
+  return [{ functionDeclarations: declarations }];
+}
+function createGeminiAccumulatorState() {
+  return {
+    text: "",
+    toolCalls: [],
+    reasoning: "",
+    events: []
+  };
+}
+function applyGeminiChunk(chunk, state, options) {
+  if (!chunk || typeof chunk !== "object") return;
+  const response = "response" in chunk && chunk.response && typeof chunk.response === "object" ? chunk.response : chunk;
+  if ("usageMetadata" in response && response.usageMetadata && typeof response.usageMetadata === "object") {
+    const meta = response.usageMetadata;
+    const prompt = typeof meta.promptTokenCount === "number" ? meta.promptTokenCount : 0;
+    const candidates2 = typeof meta.candidatesTokenCount === "number" ? meta.candidatesTokenCount : 0;
+    const total = typeof meta.totalTokenCount === "number" ? meta.totalTokenCount : prompt + candidates2;
+    const cached = typeof meta.cachedContentTokenCount === "number" && Number.isFinite(meta.cachedContentTokenCount) ? (
+      // cached ⊆ prompt；对畸形上游防御性钳位，避免 cache_read > input 破坏归一化与计费
+      Math.min(Math.max(0, Math.floor(meta.cachedContentTokenCount)), prompt)
+    ) : 0;
+    state.usage = {
+      prompt_tokens: prompt,
+      completion_tokens: candidates2,
+      total_tokens: total,
+      ...cached > 0 ? { cache_read_input_tokens: cached } : {}
+    };
+    state.events.push({ kind: "usage", usage: state.usage });
+  }
+  const candidates = Array.isArray(response.candidates) ? response.candidates : [];
+  for (const candidate of candidates) {
+    if (!candidate || typeof candidate !== "object") continue;
+    const candidateFinishReason = candidate.finishReason;
+    if (typeof candidateFinishReason === "string" && candidateFinishReason.trim()) {
+      state.finishReason = candidateFinishReason.trim();
+      state.events.push({ kind: "finish", reason: state.finishReason });
+    }
+    const parts = Array.isArray(
+      candidate.content?.parts
+    ) ? candidate.content.parts : [];
+    for (const part of parts) {
+      if (!part || typeof part !== "object") continue;
+      const partSignature = part.thoughtSignature;
+      const isThought = Boolean(part.thought);
+      if ("text" in part && typeof part.text === "string") {
+        const piece = part.text;
+        if (!isThought) {
+          state.text += piece;
+          if (piece) {
+            state.events.push({ kind: "text", text: piece });
+            if (options?.onTextDelta) options.onTextDelta(piece);
+          }
+        } else {
+          state.reasoning += piece;
+          if (piece) {
+            state.events.push({ kind: "reasoning", text: piece });
+            if (options?.onReasoningDelta) options.onReasoningDelta(piece);
+          }
+        }
+      }
+      if (isThought && typeof partSignature === "string" && partSignature) {
+        state.pendingThoughtSignature = partSignature;
+      }
+      if ("functionCall" in part && part.functionCall) {
+        const call = part.functionCall;
+        const name = typeof call.name === "string" ? call.name : "tool";
+        const id = typeof call.id === "string" ? call.id : `${name}_${state.toolCalls.length}`;
+        const argsObj = call.args && typeof call.args === "object" ? call.args : {};
+        const resolvedSignature = typeof partSignature === "string" && partSignature ? partSignature : state.pendingThoughtSignature;
+        state.pendingThoughtSignature = void 0;
+        const toolCall = {
+          id,
+          type: "function",
+          function: { name, arguments: JSON.stringify(argsObj) },
+          ...typeof resolvedSignature === "string" && resolvedSignature ? { thought_signature: resolvedSignature } : {}
+        };
+        state.toolCalls.push(toolCall);
+        state.events.push({ kind: "tool_call", toolCall });
+      }
+    }
+  }
+}
+function accumulateGeminiChunks(chunks, options) {
+  const state = createGeminiAccumulatorState();
+  for (const chunk of chunks) {
+    applyGeminiChunk(chunk, state, options);
+  }
+  return {
+    text: state.text,
+    toolCalls: state.toolCalls,
+    usage: state.usage,
+    finishReason: state.finishReason,
+    reasoningContent: state.reasoning,
+    events: state.events
+  };
+}
+async function accumulateGeminiStream(stream, options) {
+  const state = createGeminiAccumulatorState();
+  for await (const chunk of stream) {
+    applyGeminiChunk(chunk, state, options);
+  }
+  return {
+    text: state.text,
+    toolCalls: state.toolCalls,
+    usage: state.usage,
+    finishReason: state.finishReason,
+    reasoningContent: state.reasoning,
+    events: state.events
+  };
+}
+function shouldUseGeminiNativeToolRoute(provider, model, tools, isImageModel) {
+  return provider === "google" && !isImageModel(model) && isGemini3Model(model) && Array.isArray(tools) && tools.length > 0;
+}
+function buildGeminiGenerateContentRequest(args) {
+  const { contents, systemTexts } = convertOpenAiMessagesToGemini(
+    args.messages,
+    { attachSkipThoughtSignature: args.attachSkipThoughtSignature }
+  );
+  const request = { contents };
+  if (systemTexts.length > 0) {
+    request.systemInstruction = {
+      role: "user",
+      parts: systemTexts.map((text) => ({ text }))
+    };
+  }
+  const toolsResult = convertOpenAiToolsToGemini(args.tools);
+  if (toolsResult) {
+    request.tools = toolsResult;
+    request.toolConfig = { functionCallingConfig: { mode: "AUTO" } };
+  }
+  const generationConfig = {};
+  if (typeof args.maxTokens === "number" && args.maxTokens > 0) {
+    generationConfig.maxOutputTokens = args.maxTokens;
+  }
+  if (typeof args.temperature === "number") {
+    generationConfig.temperature = args.temperature;
+  }
+  if (Object.keys(generationConfig).length > 0) {
+    request.generationConfig = generationConfig;
+  }
+  return request;
+}
+
+// packages/agent-runtime/antigravityCloudCodeProvider.ts
+var STREAM_PATH = "/v1internal:streamGenerateContent?alt=sse";
+function buildCloudCodeAssistPayload(args) {
+  const projectId = readAntigravityProjectId(args.metadata);
+  if (!projectId) {
+    throw new Error(
+      "Antigravity OAuth credential is missing metadata.projectId. Re-run `nolo auth antigravity`."
+    );
+  }
+  const logicalModel = asOptionalTrimmedString(args.openAiBody.model) ?? asOptionalTrimmedString(args.agentConfig.model) ?? "gemini-3.1-pro";
+  const { wireModelId: model, profile } = resolveAntigravityWireModel(logicalModel);
+  const rawMessages = Array.isArray(args.openAiBody.messages) ? args.openAiBody.messages : [];
+  const quirks = resolveGeminiModelQuirks(model);
+  const isClaude = quirks.isClaudeCrossModel;
+  const { contents, systemTexts } = convertOpenAiMessagesToGemini(rawMessages, {
+    attachSkipThoughtSignature: quirks.allowsThoughtSignatureSentinel
+  });
+  if (contents.length === 0) {
+    throw new Error("Antigravity Cloud Code Assist request has no user/model contents.");
+  }
+  const prompt = args.agentConfig.prompt?.trim();
+  if (prompt) systemTexts.unshift(prompt);
+  const request = { contents };
+  if (systemTexts.length > 0) {
+    request.systemInstruction = {
+      role: "user",
+      parts: systemTexts.map((text) => ({ text }))
+    };
+  }
+  const tools = convertOpenAiToolsToGemini(
+    Array.isArray(args.openAiBody.tools) ? args.openAiBody.tools : void 0
+  );
+  if (tools) {
+    request.tools = tools;
+    request.toolConfig = { functionCallingConfig: { mode: "AUTO" } };
+  }
+  const generationConfig = {};
+  if (profile?.maxOutputTokens) {
+    generationConfig.maxOutputTokens = profile.maxOutputTokens;
+  } else if (typeof args.agentConfig.max_tokens === "number" && args.agentConfig.max_tokens > 0) {
+    generationConfig.maxOutputTokens = args.agentConfig.max_tokens;
+  }
+  if (typeof args.agentConfig.temperature === "number") {
+    generationConfig.temperature = args.agentConfig.temperature;
+  }
+  if (Object.keys(generationConfig).length > 0) {
+    request.generationConfig = generationConfig;
+  }
+  const agentId = randomUUID();
+  const trajectoryId = randomUUID();
+  const step = 2;
+  const requestId = `agent/${agentId}/${Date.now()}/${trajectoryId}/${step}`;
+  const labels = {
+    trajectory_id: trajectoryId,
+    last_step_index: String(step - 1),
+    used_claude: String(isClaude),
+    used_claude_conservative: String(isClaude)
+  };
+  if (profile?.modelEnum) {
+    labels.model_enum = profile.modelEnum;
+  }
+  request.labels = labels;
+  request.sessionId = `-${Math.floor(Math.random() * 9e15)}`;
+  return {
+    url: `${resolveAntigravityCloudCodeBaseUrl(args.agentConfig.customProviderUrl)}${STREAM_PATH}`,
+    envelope: {
+      project: projectId,
+      model,
+      request,
+      requestId,
+      requestType: "agent",
+      userAgent: "antigravity"
+    }
+  };
+}
+function resolveAntigravityFinishReason(upstream) {
+  const normalized = (upstream ?? "").trim().toUpperCase();
+  if (normalized === "MAX_TOKENS") return "length";
+  if (normalized === "SAFETY" || normalized === "RECITATION" || normalized === "PROHIBITED_CONTENT" || normalized === "BLOCKLIST") {
+    return "content_filter";
+  }
+  return "stop";
+}
+function normalizeAntigravityCompletion(decoded) {
+  const { text, toolCalls, usage, finishReason, reasoningContent, events } = decoded;
+  const normalizedFinishReason = (finishReason ?? "").trim().toUpperCase();
+  if (!text && !reasoningContent && toolCalls.length === 0 && !finishReason && !usage) {
+    const body = {
+      error: {
+        message: "antigravity upstream returned an empty stream (no content, finishReason or usage); channel degradation, not model emptiness"
+      },
+      provider_events: events
+    };
+    return {
+      status: 502,
+      text: "",
+      toolCalls: [],
+      providerEvents: events,
+      body
+    };
+  }
+  if (normalizedFinishReason === "MALFORMED_FUNCTION_CALL") {
+    const message2 = "antigravity upstream returned MALFORMED_FUNCTION_CALL (model generated an invalid function call or tool arguments were rejected by upstream)";
+    const providerFailure = {
+      kind: "provider_failure",
+      provider: "antigravity",
+      code: "MALFORMED_FUNCTION_CALL",
+      message: message2,
+      providerReason: "MALFORMED_FUNCTION_CALL",
+      retryable: false,
+      status: 502
+    };
+    return {
+      status: 502,
+      text: "",
+      toolCalls: [],
+      finishReason,
+      providerEvents: events,
+      providerFailure,
+      runtimeProviderFailure: {
+        message: providerFailure.message,
+        retryable: providerFailure.retryable
+      },
+      body: {
+        error: {
+          message: message2,
+          code: "MALFORMED_FUNCTION_CALL",
+          category: "malformed_function_call",
+          providerReason: "MALFORMED_FUNCTION_CALL",
+          retryable: false
+        },
+        provider_failure: providerFailure,
+        provider_events: events
+      }
+    };
+  }
+  const message = {
+    role: "assistant",
+    content: text || null
+  };
+  if (toolCalls.length > 0) message.tool_calls = toolCalls;
+  if (reasoningContent) message.reasoning_content = reasoningContent;
+  return {
+    status: 200,
+    text,
+    ...reasoningContent ? { reasoningContent } : {},
+    toolCalls,
+    ...usage ? { usage } : {},
+    ...finishReason ? { finishReason } : {},
+    providerEvents: events,
+    body: {
+      choices: [{
+        index: 0,
+        message,
+        finish_reason: toolCalls.length > 0 ? "tool_calls" : resolveAntigravityFinishReason(finishReason)
+      }],
+      ...usage ? { usage } : {},
+      provider_events: events
+    }
+  };
+}
+async function fetchAntigravityCloudCodeCompletion(args) {
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const { url, envelope } = buildCloudCodeAssistPayload(args);
+  const response = await fetchImpl(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.accessToken}`,
+      "Content-Type": "application/json",
+      "User-Agent": getAntigravityUserAgent()
+    },
+    body: JSON.stringify(envelope),
+    signal: args.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    return {
+      status: response.status,
+      text: "",
+      toolCalls: [],
+      providerEvents: [],
+      // 保留上游结构：Antigravity 的限流 body 同样携带结构化的重置信息，
+      // 压成字符串会让冷却退化成 5 分钟默认值。
+      body: parseUpstreamErrorBody(errorText, response.statusText)
+    };
+  }
+  const chunkStream = streamSseDataValues(response, parseSseDataLineJson);
+  const { text, toolCalls, usage, finishReason, reasoningContent, events } = await accumulateGeminiStream(chunkStream, {
+    onTextDelta: args.onTextDelta,
+    onReasoningDelta: args.onReasoningDelta
+  });
+  const normalized = normalizeAntigravityCompletion({
+    text,
+    toolCalls,
+    usage,
+    finishReason,
+    reasoningContent,
+    events
+  });
+  if (normalized.status !== 200 || !text && toolCalls.length === 0) {
+    console.warn(
+      `[antigravity] empty completion: finishReason=${JSON.stringify(finishReason)} reasoningLen=${reasoningContent?.length ?? 0} usage=${JSON.stringify(usage) ?? "none"} model=${String(envelope.model)} base=${new URL(url).host}`
+    );
+  }
+  return normalized;
+}
+
+// packages/agent-runtime/devinOAuth.ts
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEVIN_CONNECT_URL = "https://server.codeium.com/exa.api_server_pb.ApiServerService/GetChatMessage";
+function buildDevinAuthUrl(orgId) {
+  const cleanOrg = orgId?.trim();
+  if (cleanOrg) {
+    return `https://app.devin.ai/org/${encodeURIComponent(cleanOrg)}/settings/keys`;
+  }
+  return "https://app.devin.ai/settings/keys";
+}
+function extractDevinToken(input) {
+  const raw = input?.trim();
+  if (!raw) return null;
+  if (/^https?:\/\//i.test(raw)) {
+    try {
+      const url = new URL(raw);
+      const queryToken = url.searchParams.get("token") || url.searchParams.get("access_token") || url.searchParams.get("auth_token");
+      if (queryToken?.trim()) return queryToken.trim();
+      if (url.hash) {
+        const hashParams = new URLSearchParams(url.hash.replace(/^#/, ""));
+        const hashToken = hashParams.get("token") || hashParams.get("access_token") || hashParams.get("auth_token");
+        if (hashToken?.trim()) return hashToken.trim();
+      }
+    } catch {
+    }
+  }
+  return raw || null;
+}
+function parseDevinCredentialsToml(content) {
+  for (const line of content.split(/\r?\n/)) {
+    const cogMatch = line.match(/(cog_[A-Za-z0-9_-]+)/);
+    if (cogMatch?.[1]) {
+      return cogMatch[1].trim();
+    }
+    const match = line.match(
+      /^\s*(?:windsurf_api_key|devin_api_key|api_key|api_token|token)\s*=\s*"([^"]+)"\s*$/i
+    );
+    if (match?.[1]) {
+      return match[1].trim();
+    }
+  }
+  return null;
+}
+function detectLocalDevinCredentials(options) {
+  const baseHome = options?.homeDir || homedir();
+  const xdgData = process.env.XDG_DATA_HOME;
+  const candidateCliPaths = [
+    xdgData ? join(xdgData, "devin", "credentials.toml") : null,
+    join(baseHome, ".local", "share", "devin", "credentials.toml"),
+    process.env.APPDATA ? join(process.env.APPDATA, "devin", "credentials.toml") : null
+  ].filter((p) => Boolean(p));
+  for (const credPath of candidateCliPaths) {
+    if (existsSync(credPath)) {
+      try {
+        const content = readFileSync(credPath, "utf-8");
+        const token = parseDevinCredentialsToml(content);
+        if (token) {
+          return {
+            found: true,
+            token,
+            source: "devin-cli",
+            sourcePath: credPath
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  const codeiumPath = join(baseHome, ".codeium", "config.json");
+  if (existsSync(codeiumPath)) {
+    try {
+      const parsed = JSON.parse(readFileSync(codeiumPath, "utf-8"));
+      const token = parsed.apiKey || parsed.api_key;
+      if (token?.trim()) {
+        return {
+          found: true,
+          token: token.trim(),
+          source: "codeium-config",
+          sourcePath: codeiumPath
+        };
+      }
+    } catch {
+    }
+  }
+  return { found: false };
+}
+function buildDevinOAuthCredential(token, now = Date.now()) {
+  return {
+    provider: "devin",
+    accessToken: token.trim(),
+    obtainedAt: now
+  };
+}
+
+export {
+  parseSseDataLineJson,
+  parseSseDataLineObject,
+  parseUpstreamErrorBody,
+  isGemini3Model,
+  accumulateGeminiChunks,
+  shouldUseGeminiNativeToolRoute,
+  buildGeminiGenerateContentRequest,
+  resolveAntigravityFinishReason,
+  fetchAntigravityCloudCodeCompletion,
+  DEVIN_CONNECT_URL,
+  buildDevinAuthUrl,
+  extractDevinToken,
+  detectLocalDevinCredentials,
+  buildDevinOAuthCredential
+};