jeo-code 0.1.0 → 0.4.4

package/src/ai/providers/antigravity.ts

@@ -0,0 +1,219 @@
+import { randomUUID } from "node:crypto";
+import type { Credential } from "../../auth";
+import type { CallOptions, Message, ProviderAdapter } from "../types";
+import { readSse } from "../sse";
+import { providerHttpError } from "./errors";
+
+const ANTIGRAVITY_DAILY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
+const ANTIGRAVITY_SANDBOX_ENDPOINT = "https://daily-cloudcode-pa.sandbox.googleapis.com";
+const ENDPOINTS = [ANTIGRAVITY_DAILY_ENDPOINT, ANTIGRAVITY_SANDBOX_ENDPOINT] as const;
+
+export function getAntigravityUserAgent(): string {
+  const version = process.env.PI_AI_ANTIGRAVITY_VERSION || "1.104.0";
+  const os = process.platform === "win32" ? "windows" : process.platform;
+  const arch = process.arch === "x64" ? "amd64" : process.arch === "ia32" ? "386" : process.arch;
+  return `antigravity/${version} ${os}/${arch}`;
+}
+
+function antigravityModelId(model: string): string {
+  return model.replace(/^antigravity\//, "");
+}
+
+function projectIdFor(credential: Credential): string | undefined {
+  if (credential.kind === "oauth" && credential.projectId) return credential.projectId;
+  return process.env.GOOGLE_CLOUD_PROJECT || process.env.GOOGLE_CLOUD_PROJECT_ID || undefined;
+}
+
+// In-process cache of lazily discovered project ids, keyed by access token so a
+// rotated token re-discovers. Persisted to the stored gemini OAuth record too,
+// so the next process start skips discovery entirely.
+const discoveredProjects = new Map<string, string>();
+
+export interface ResolveProjectOptions {
+  discover?: (accessToken: string) => Promise<string>;
+  persist?: (projectId: string) => Promise<void>;
+  /** Turn abort — threaded into discovery fetches so a stalled loadCodeAssist
+   *  can never hang the first OAuth turn forever (round-5 #2). */
+  signal?: AbortSignal;
+}
+
+/**
+ * Resolve the Cloud Code Assist project id for an Antigravity call:
+ * stored credential → env → lazy loadCodeAssist/onboardUser discovery (gjc parity).
+ * A discovered id is persisted onto the stored gemini OAuth record so users who
+ * logged in before discovery existed are healed without re-login.
+ */
+export async function resolveAntigravityProjectId(
+  credential: Credential,
+  opts: ResolveProjectOptions = {},
+): Promise<string> {
+  if (credential.kind !== "oauth") {
+    throw new Error("Antigravity provider requires Google/Gemini CLI OAuth credentials. Run `jeo auth login gemini`.");
+  }
+  const direct = projectIdFor(credential);
+  if (direct) return direct;
+  const cached = discoveredProjects.get(credential.token);
+  if (cached) return cached;
+
+  const discover = opts.discover ?? (async (token: string) => {
+    const { discoverGoogleProjectId, ANTIGRAVITY_DISCOVERY_METADATA } = await import("../../auth/flows/google-project");
+    // Antigravity-client tokens discover with ANTIGRAVITY metadata; gemini-cli
+    // tokens use the default gemini-cli metadata shape.
+    return discoverGoogleProjectId(token, credential.provider === "antigravity"
+      ? { metadata: { ...ANTIGRAVITY_DISCOVERY_METADATA }, extraHeaders: { "User-Agent": getAntigravityUserAgent() }, signal: opts.signal }
+      : { signal: opts.signal });
+  });
+  let projectId: string;
+  try {
+    projectId = await discover(credential.token);
+  } catch (err) {
+    throw new Error(
+      `Antigravity project auto-discovery failed: ${(err as Error)?.message ?? err}. ` +
+      "Set GOOGLE_CLOUD_PROJECT(_ID) or re-run `jeo auth login gemini`.",
+    );
+  }
+  discoveredProjects.set(credential.token, projectId);
+
+  const persist = opts.persist ?? (async (id: string) => {
+    const { getStoredOAuth, setOauthCredential } = await import("../../auth/storage");
+    const owner = credential.provider === "antigravity" ? "antigravity" : "gemini";
+    const stored = await getStoredOAuth(owner);
+    if (stored && !stored.projectId) await setOauthCredential(owner, { ...stored, projectId: id });
+  });
+  try {
+    await persist(projectId);
+  } catch {
+    // Persistence is best-effort; the in-process cache still serves this session.
+  }
+  return projectId;
+}
+
+type CcaPart = { text: string } | { inlineData: { mimeType: string; data: string } };
+
+function antigravityContents(messages: Message[]): { role: "user" | "model"; parts: CcaPart[] }[] {
+  const contents: { role: "user" | "model"; parts: CcaPart[] }[] = [];
+  for (const m of messages) {
+    if (m.role === "system") continue;
+    const role = m.role === "assistant" ? "model" : "user";
+    // Clipboard-pasted images become inlineData parts alongside the text part.
+    const parts: CcaPart[] = [
+      ...(m.images?.map(img => ({ inlineData: { mimeType: img.mediaType, data: img.data } })) ?? []),
+      { text: m.content },
+    ];
+    const prev = contents[contents.length - 1];
+    if (prev && prev.role === role) prev.parts.push(...parts);
+    else contents.push({ role, parts });
+  }
+  return contents;
+}
+
+function sessionId(messages: Message[]): string {
+  const first = messages.find(m => m.role === "user")?.content ?? `${Date.now()}`;
+  let hash = 0n;
+  for (const ch of new TextEncoder().encode(first)) hash = (hash * 131n + BigInt(ch)) & ((1n << 63n) - 1n);
+  return `-${hash.toString()}`;
+}
+
+export function antigravityRequest(messages: Message[], options: CallOptions, credential: Credential, endpoint = ANTIGRAVITY_DAILY_ENDPOINT, projectId?: string): { url: string; headers: Record<string, string>; body: string } {
+  if (credential.kind !== "oauth") throw new Error("Antigravity provider requires Google/Gemini CLI OAuth credentials.");
+  const project = projectId ?? projectIdFor(credential);
+  if (!project) {
+    throw new Error(
+      "Antigravity needs a Google Cloud projectId and auto-discovery has not run yet. " +
+      "Set GOOGLE_CLOUD_PROJECT(_ID) or re-run `jeo auth login gemini`.",
+    );
+  }
+  const model = antigravityModelId(options.model);
+  const systemPrompt = options.systemPrompt ?? messages.find(m => m.role === "system")?.content;
+  const generationConfig: Record<string, unknown> = {};
+  if (options.temperature !== undefined) generationConfig.temperature = options.temperature;
+  // Upstream Antigravity strips maxOutputTokens for non-Claude models; do the same.
+  if (model.toLowerCase().includes("claude")) generationConfig.maxOutputTokens = options.maxTokens ?? 4000;
+
+  const request: Record<string, unknown> = {
+    contents: antigravityContents(messages),
+    sessionId: sessionId(messages),
+  };
+  if (systemPrompt) request.systemInstruction = { role: "user", parts: [{ text: systemPrompt }] };
+  if (Object.keys(generationConfig).length > 0) request.generationConfig = generationConfig;
+
+  const body = JSON.stringify({
+    project,
+    model,
+    request,
+    requestType: "agent",
+    userAgent: "antigravity",
+    requestId: `agent-${randomUUID()}`,
+  });
+  return {
+    url: `${endpoint}/v1internal:streamGenerateContent?alt=sse`,
+    headers: {
+      authorization: `Bearer ${credential.token}`,
+      "content-type": "application/json",
+      accept: "text/event-stream",
+      "User-Agent": getAntigravityUserAgent(),
+    },
+    body,
+  };
+}
+
+type CcaUsage = { promptTokenCount?: number; candidatesTokenCount?: number; thoughtsTokenCount?: number };
+interface CcaChunk {
+  response?: {
+    candidates?: { content?: { parts?: { text?: string }[] }; finishReason?: string }[];
+    usageMetadata?: CcaUsage;
+  };
+}
+
+function textOf(chunk: CcaChunk): string {
+  return chunk.response?.candidates?.[0]?.content?.parts?.map(p => p.text ?? "").join("") ?? "";
+}
+
+async function fetchAntigravity(messages: Message[], options: CallOptions, credential: Credential): Promise<Response> {
+  // Resolve the project id up front: stored credential → env → lazy
+  // loadCodeAssist/onboardUser discovery (persisted for future sessions).
+  const projectId = await resolveAntigravityProjectId(credential, { signal: options.signal });
+  let last: Response | undefined;
+  for (const endpoint of ENDPOINTS) {
+    const { url, headers, body } = antigravityRequest(messages, options, credential, endpoint, projectId);
+    const res = await fetch(url, { method: "POST", headers, body, signal: options.signal });
+    if (res.ok) return res;
+    last = res;
+    if (res.status !== 404 && res.status !== 503) break;
+  }
+  throw await providerHttpError("Antigravity", last!);
+}
+
+export const antigravityAdapter: ProviderAdapter = {
+  name: "antigravity",
+  async call(messages, options, credential) {
+    const response = await fetchAntigravity(messages, options, credential);
+    if (!response.body) return "";
+    let out = "";
+    let usage: CcaUsage | undefined;
+    for await (const data of readSse(response.body)) {
+      let chunk: CcaChunk;
+      try { chunk = JSON.parse(data); } catch { continue; }
+      out += textOf(chunk);
+      if (chunk.response?.usageMetadata) usage = chunk.response.usageMetadata;
+    }
+    if (usage) options.onUsage?.({ inputTokens: usage.promptTokenCount, outputTokens: (usage.candidatesTokenCount ?? 0) + (usage.thoughtsTokenCount ?? 0) });
+    if (!out) throw new Error("Antigravity Cloud Code Assist returned an empty response.");
+    return out;
+  },
+  async *stream(messages, options, credential) {
+    const response = await fetchAntigravity(messages, options, credential);
+    if (!response.body) return;
+    let yielded = false;
+    let usage: CcaUsage | undefined;
+    for await (const data of readSse(response.body)) {
+      let chunk: CcaChunk;
+      try { chunk = JSON.parse(data); } catch { continue; }
+      const delta = textOf(chunk);
+      if (delta) { yielded = true; yield delta; }
+      if (chunk.response?.usageMetadata) usage = chunk.response.usageMetadata;
+    }
+    if (usage) options.onUsage?.({ inputTokens: usage.promptTokenCount, outputTokens: (usage.candidatesTokenCount ?? 0) + (usage.thoughtsTokenCount ?? 0) });
+    if (!yielded) throw new Error("Antigravity Cloud Code Assist returned an empty response.");
+  },
+};

package/src/ai/providers/errors.ts

@@ -36,6 +36,19 @@ export function parseRetryAfter(value: string | null | undefined): number | unde
   return undefined;
 }
 
+/**
+ * Extract a server-directed retry delay from a 429/503 response *body* (in ms).
+ * Some providers (notably Google/Gemini) omit the `Retry-After` header and instead
+ * put the hint in the JSON, e.g. `"retryDelay": "8s"` or `"Please retry in 8.6s"`.
+ */
+export function parseRetryFromBody(detail: string | null | undefined): number | undefined {
+  if (!detail) return undefined;
+  const m = detail.match(/"retryDelay"\s*:\s*"?([\d.]+)s/i) || detail.match(/retry in ([\d.]+)\s*s/i);
+  if (!m) return undefined;
+  const s = Number(m[1]);
+  return Number.isFinite(s) ? Math.max(0, s * 1000) : undefined;
+}
+
 /**
  * Build a {@link ProviderHttpError} from a non-ok `Response`, capturing the body
  * and any `Retry-After`. Use at every adapter's `!response.ok` site so the retry
@@ -43,5 +56,6 @@ export function parseRetryAfter(value: string | null | undefined): number | unde
  */
 export async function providerHttpError(provider: string, response: Response, context?: string): Promise<ProviderHttpError> {
   const detail = await response.text().catch(() => "");
-  return new ProviderHttpError(provider, response.status, detail, context, parseRetryAfter(response.headers.get("retry-after")));
+  const retryAfterMs = parseRetryAfter(response.headers.get("retry-after")) ?? parseRetryFromBody(detail);
+  return new ProviderHttpError(provider, response.status, detail, context, retryAfterMs);
 }

package/src/ai/providers/gemini.ts

@@ -2,31 +2,83 @@ import type { Credential } from "../../auth";
 import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readSse } from "../sse";
 import { providerHttpError } from "./errors";
+import { jeoEnv } from "../../util/env";
 
-function geminiRequest(messages: Message[], options: CallOptions, credential: Credential, action: "generateContent" | "streamGenerateContent"): { url: string; headers: Record<string, string>; body: string } {
-  const resolvedModel = options.model.startsWith("google/") ? options.model.slice(7) : options.model;
+/** Gemini 2.5+/latest models think by default and BILL thought tokens against
+ *  `maxOutputTokens` — a small-budget call can burn its entire budget on thoughts
+ *  and return MAX_TOKENS with zero text (observed live on `gemini-flash-latest`).
+ *  Pin an explicit budget: off unless reasoning was requested. Pro-class models
+ *  cannot disable thinking (API minimum 128), so they keep a floor instead of 0.
+ *  Older models (1.5/2.0) reject `thinkingConfig` entirely → undefined (omit). */
+export function geminiThinkingBudget(model: string, effort?: CallOptions["reasoningEffort"], maxTokens?: number): number | undefined {
+  const m = model.toLowerCase();
+  const thinkingCapable = /gemini-(2\.5|[3-9])|flash-latest|pro-latest/.test(m);
+  if (!thinkingCapable) return undefined;
+  const floor = m.includes("pro") ? 128 : 0; // pro-class cannot fully disable thinking
+  let budget: number;
+  switch (effort) {
+    case "low": budget = 1024; break;
+    case "medium": budget = 4096; break;
+    case "high": budget = 8192; break;
+    case "minimal":
+    default: budget = floor;
+  }
+  // Thought tokens bill against maxOutputTokens: keep at least ~1K of the output
+  // budget for visible text, or thinking starves the reply to an empty MAX_TOKENS.
+  if (typeof maxTokens === "number") budget = Math.min(budget, Math.max(floor, maxTokens - 1024));
+  return budget;
+}
+
+/** Shared Gemini request payload (contents + generationConfig + systemInstruction)
+ *  used by BOTH the public generativelanguage path (API key) and the Cloud Code
+ *  Assist path (OAuth) — only the envelope/endpoint differs. */
+export function buildGeminiPayload(messages: Message[], options: CallOptions): { geminiModel: string; payload: Record<string, unknown> } {
+  const resolvedModel = options.model.replace(/^(google|gemini)\//, "");
   let geminiModel = resolvedModel;
   if (!geminiModel || geminiModel === "claude-3-5-sonnet") geminiModel = "gemini-2.0-flash";
 
   const systemPrompt = options.systemPrompt ?? messages.find(m => m.role === "system")?.content;
-  const contents = messages
-    .filter(m => m.role !== "system")
-    .map(m => ({ role: m.role === "assistant" ? "model" : "user", parts: [{ text: m.content }] }));
+  // Gemini requires strictly ALTERNATING user/model turns. jeo histories can carry
+  // consecutive same-role messages (a compaction summary prepended before a tool-result,
+  // back-to-back tool results, etc.), so coalesce adjacent same-role turns into one
+  // content block — otherwise the API rejects the request mid-session.
+  const contents: { role: string; parts: ({ text: string } | { inlineData: { mimeType: string; data: string } })[] }[] = [];
+  for (const m of messages) {
+    if (m.role === "system") continue;
+    const role = m.role === "assistant" ? "model" : "user";
+    // Clipboard-pasted images become inlineData parts alongside the text part.
+    const parts: ({ text: string } | { inlineData: { mimeType: string; data: string } })[] = [
+      ...(m.images?.map(img => ({ inlineData: { mimeType: img.mediaType, data: img.data } })) ?? []),
+      { text: m.content },
+    ];
+    const prev = contents[contents.length - 1];
+    if (prev && prev.role === role) {
+      prev.parts.push(...parts);
+    } else {
+      contents.push({ role, parts });
+    }
+  }
 
   const generationConfig: Record<string, unknown> = {
     temperature: options.temperature ?? 0.2,
     maxOutputTokens: options.maxTokens ?? 4000,
   };
   if (options.jsonMode) generationConfig.responseMimeType = "application/json";
+  const thinkingBudget = geminiThinkingBudget(geminiModel, options.reasoningEffort, options.maxTokens);
+  if (thinkingBudget !== undefined) generationConfig.thinkingConfig = { thinkingBudget };
 
   const payload: Record<string, unknown> = { contents, generationConfig };
   if (systemPrompt) payload.systemInstruction = { parts: [{ text: systemPrompt }] };
+  return { geminiModel, payload };
+}
 
+export function geminiRequest(messages: Message[], options: CallOptions, credential: Credential, action: "generateContent" | "streamGenerateContent"): { url: string; headers: Record<string, string>; body: string } {
+  const { geminiModel, payload } = buildGeminiPayload(messages, options);
   const oauth = credential.kind === "oauth" ? credential.token : undefined;
   const apiKey = credential.kind === "api_key" ? credential.token : undefined;
-  let url = `https://generativelanguage.googleapis.com/v1beta/models/${geminiModel}:${action}`;
+  let url = `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(geminiModel)}:${action}`;
   const query = action === "streamGenerateContent" ? "alt=sse" : "";
-  if (!oauth) url += `?${query ? query + "&" : ""}key=${apiKey ?? ""}`;
+  if (!oauth) url += `?${query ? query + "&" : ""}key=${encodeURIComponent(apiKey ?? "")}`;
   else if (query) url += `?${query}`;
   const headers: Record<string, string> = oauth
     ? { "content-type": "application/json", authorization: `Bearer ${oauth}` }
@@ -34,18 +86,125 @@ function geminiRequest(messages: Message[], options: CallOptions, credential: Cr
   return { url, headers, body: JSON.stringify(payload) };
 }
 
+const CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+
+/** gemini-cli identification headers Cloud Code Assist expects (gjc parity). */
+export function getGeminiCliHeaders(modelId?: string): Record<string, string> {
+  const version = jeoEnv("GEMINI_CLI_VERSION") || "0.45.2";
+  return {
+    "User-Agent": `GeminiCLI/${version}/${modelId ?? "gemini-2.5-flash"} (${process.platform}; ${process.arch}; terminal)`,
+    "Client-Metadata": "ideType=IDE_UNSPECIFIED,platform=PLATFORM_UNSPECIFIED,pluginType=GEMINI",
+  };
+}
+
+/**
+ * Cloud Code Assist request for a Google OAuth (gemini-cli) credential — the
+ * gemini-cli/gjc call path. OAuth tokens carry cloud-platform scope and target
+ * cloudcode-pa.googleapis.com, NOT the public generativelanguage API, so a
+ * plain `jeo auth login gemini` works without any GEMINI_API_KEY. The body
+ * wraps the standard payload as `{ project, model, request }`.
+ */
+export function geminiCliRequest(messages: Message[], options: CallOptions, accessToken: string, projectId: string): { url: string; headers: Record<string, string>; body: string } {
+  const { geminiModel, payload } = buildGeminiPayload(messages, options);
+  return {
+    url: `${CODE_ASSIST_ENDPOINT}/v1internal:streamGenerateContent?alt=sse`,
+    headers: {
+      authorization: `Bearer ${accessToken}`,
+      "content-type": "application/json",
+      accept: "text/event-stream",
+      ...getGeminiCliHeaders(geminiModel),
+    },
+    body: JSON.stringify({ project: projectId, model: geminiModel, request: payload }),
+  };
+}
+
 interface GeminiChunk {
-  candidates?: { content?: { parts?: { text?: string }[] } }[];
-  usageMetadata?: { promptTokenCount?: number; candidatesTokenCount?: number };
+  candidates?: { content?: { parts?: { text?: string }[] }; finishReason?: string }[];
+  promptFeedback?: { blockReason?: string };
+  usageMetadata?: { promptTokenCount?: number; candidatesTokenCount?: number; thoughtsTokenCount?: number };
+}
+
+/** Cloud Code Assist wraps each standard chunk under `response`. */
+interface CcaChunk {
+  response?: GeminiChunk;
 }
 
 function textOf(chunk: GeminiChunk): string {
   return chunk.candidates?.[0]?.content?.parts?.map(p => p.text ?? "").join("") ?? "";
 }
 
+/** When Gemini returns HTTP 200 with no text, surface the real cause (safety block /
+ *  RECITATION / MAX_TOKENS) instead of a silent empty string that downstream JSON
+ *  parsing would misreport as "couldn't parse tool call". */
+function blockedReason(chunk: GeminiChunk): string | undefined {
+  const block = chunk.promptFeedback?.blockReason;
+  if (block) return `blockReason=${block}`;
+  const finish = chunk.candidates?.[0]?.finishReason;
+  if (finish === "MAX_TOKENS") {
+    // Only reached when NO text was produced at all (both call/stream paths guard
+    // on emptiness): the output budget was consumed before any visible text —
+    // typically thinking tokens on a 2.5+/latest model.
+    return "finishReason=MAX_TOKENS — output budget exhausted before any text; raise maxTokens or lower the thinking level";
+  }
+  if (finish && finish !== "STOP") return `finishReason=${finish}`;
+  return undefined;
+}
+
+/**
+ * Cloud Code Assist SSE turn for a Google OAuth credential: resolves the
+ * projectId (stored → env → lazy loadCodeAssist/onboardUser discovery), POSTs
+ * the gemini-cli request, and yields text deltas. Usage is reported ONCE after
+ * the stream (thought tokens count as output, gjc parity). Shared by both
+ * `call` (concatenates) and `stream` (yields through).
+ */
+async function* ccaTurn(messages: Message[], options: CallOptions, credential: Credential & { kind: "oauth" }): AsyncGenerator<string> {
+  const { resolveAntigravityProjectId } = await import("./antigravity");
+  const projectId = await resolveAntigravityProjectId(credential, { signal: options.signal });
+  const { url, headers, body } = geminiCliRequest(messages, options, credential.token, projectId);
+  const response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
+  if (!response.ok) throw await providerHttpError("Gemini (Cloud Code Assist)", response);
+  if (!response.body) return;
+  let lastUsage: GeminiChunk["usageMetadata"];
+  let yieldedAny = false;
+  let lastEmptyReason: string | undefined;
+  for await (const data of readSse(response.body)) {
+    let chunk: CcaChunk;
+    try {
+      chunk = JSON.parse(data);
+    } catch {
+      continue;
+    }
+    const inner = chunk.response;
+    if (!inner) continue;
+    const delta = textOf(inner);
+    if (delta) {
+      yieldedAny = true;
+      yield delta;
+    } else {
+      lastEmptyReason = blockedReason(inner) ?? lastEmptyReason;
+    }
+    if (inner.usageMetadata) lastUsage = inner.usageMetadata;
+  }
+  if (!yieldedAny) {
+    throw new Error(`Gemini (Cloud Code Assist) returned no content${lastEmptyReason ? ` (${lastEmptyReason})` : ""}.`);
+  }
+  if (lastUsage) {
+    options.onUsage?.({
+      inputTokens: lastUsage.promptTokenCount,
+      outputTokens: (lastUsage.candidatesTokenCount ?? 0) + (lastUsage.thoughtsTokenCount ?? 0),
+    });
+  }
+}
+
 export const geminiAdapter: ProviderAdapter = {
   name: "gemini",
   async call(messages, options, credential) {
+    // OAuth (gemini-cli login) → Cloud Code Assist; no GEMINI_API_KEY required.
+    if (credential.kind === "oauth") {
+      let out = "";
+      for await (const delta of ccaTurn(messages, options, credential)) out += delta;
+      return out;
+    }
     const { url, headers, body } = geminiRequest(messages, options, credential, "generateContent");
     const response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
     if (!response.ok) throw await providerHttpError("Gemini", response);
@@ -53,13 +212,26 @@ export const geminiAdapter: ProviderAdapter = {
     if (result.usageMetadata) {
       options.onUsage?.({ inputTokens: result.usageMetadata.promptTokenCount, outputTokens: result.usageMetadata.candidatesTokenCount });
     }
-    return textOf(result);
+    const text = textOf(result);
+    if (!text) {
+      const reason = blockedReason(result);
+      if (reason) throw new Error(`Gemini returned no content (${reason}).`);
+    }
+    return text;
   },
   async *stream(messages, options, credential) {
+    // OAuth (gemini-cli login) → Cloud Code Assist; no GEMINI_API_KEY required.
+    if (credential.kind === "oauth") {
+      yield* ccaTurn(messages, options, credential);
+      return;
+    }
     const { url, headers, body } = geminiRequest(messages, options, credential, "streamGenerateContent");
     const response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
     if (!response.ok) throw await providerHttpError("Gemini", response, "(stream)");
     if (!response.body) return;
+    let lastUsage: GeminiChunk["usageMetadata"];
+    let yieldedAny = false;
+    let lastEmptyReason: string | undefined;
     for await (const data of readSse(response.body)) {
       let chunk: GeminiChunk;
       try {
@@ -68,10 +240,21 @@ export const geminiAdapter: ProviderAdapter = {
         continue;
       }
       const delta = textOf(chunk);
-      if (delta) yield delta;
-      if (chunk.usageMetadata) {
-        options.onUsage?.({ inputTokens: chunk.usageMetadata.promptTokenCount, outputTokens: chunk.usageMetadata.candidatesTokenCount });
+      if (delta) {
+        yieldedAny = true;
+        yield delta;
+      } else {
+        lastEmptyReason = blockedReason(chunk) ?? lastEmptyReason;
       }
+      // Gemini emits cumulative usageMetadata on most chunks; capture the last and
+      // report ONCE after the stream so an accumulating sink can't over-count.
+      if (chunk.usageMetadata) lastUsage = chunk.usageMetadata;
+    }
+    if (!yieldedAny && lastEmptyReason) {
+      throw new Error(`Gemini returned no content (${lastEmptyReason}).`);
+    }
+    if (lastUsage) {
+      options.onUsage?.({ inputTokens: lastUsage.promptTokenCount, outputTokens: lastUsage.candidatesTokenCount });
     }
   },
 };

package/src/ai/providers/ollama.ts

@@ -2,13 +2,26 @@ import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readLines } from "../sse";
 import { providerHttpError } from "./errors";
 
+/**
+ * Resolve the Ollama base URL. `OLLAMA_HOST` is documented as a bare host:port
+ * (e.g. `127.0.0.1:11434`), but `fetch` needs a scheme — prepend `http://` when
+ * missing, else `fetch("127.0.0.1:11434/api/chat")` throws "Failed to parse URL".
+ */
+export function normalizeOllamaBaseUrl(baseUrl?: string): string {
+  const v = (baseUrl ?? process.env.OLLAMA_HOST ?? "http://localhost:11434").trim();
+  return (/^https?:\/\//i.test(v) ? v : `http://${v}`).replace(/\/$/, "");
+}
+
 function ollamaRequest(messages: Message[], options: CallOptions, stream: boolean): { url: string; body: string } {
   const model = options.model.startsWith("ollama/") ? options.model.slice(7) : options.model;
   const systemPrompt = options.systemPrompt ?? messages.find(m => m.role === "system")?.content;
-  const chatMessages: { role: string; content: string }[] = [];
+  const chatMessages: { role: string; content: string; images?: string[] }[] = [];
   if (systemPrompt) chatMessages.push({ role: "system", content: systemPrompt });
   for (const msg of messages) {
-    if (msg.role !== "system") chatMessages.push({ role: msg.role, content: msg.content });
+    if (msg.role === "system") continue;
+    // Ollama multimodal models take raw base64 strings in a sibling `images` array.
+    if (msg.images?.length) chatMessages.push({ role: msg.role, content: msg.content, images: msg.images.map(i => i.data) });
+    else chatMessages.push({ role: msg.role, content: msg.content });
   }
   const payload: Record<string, unknown> = {
     model,
@@ -17,38 +30,55 @@ function ollamaRequest(messages: Message[], options: CallOptions, stream: boolea
     options: { temperature: options.temperature ?? 0.2, num_predict: options.maxTokens ?? 4000 },
   };
   if (options.jsonMode) payload.format = "json";
-  const base = (options.baseUrl ?? process.env.OLLAMA_HOST ?? "http://localhost:11434").replace(/\/$/, "");
+  const base = normalizeOllamaBaseUrl(options.baseUrl);
   return { url: `${base}/api/chat`, body: JSON.stringify(payload) };
 }
 
+/** Round-5 #1: surface done_reason when a 200 carries no text (uniform contract). */
+function emptyCompletionError(doneReason: string | undefined): Error {
+  const hint = doneReason === "length"
+    ? " — output budget exhausted before any text; raise maxTokens"
+    : "";
+  return new Error(`Ollama returned no content${doneReason ? ` (done_reason=${doneReason})` : ""}${hint}.`);
+}
+
 export const ollamaAdapter: ProviderAdapter = {
   name: "ollama",
   async call(messages, options) {
     const { url, body } = ollamaRequest(messages, options, false);
     const response = await fetch(url, { method: "POST", headers: { "content-type": "application/json" }, body, signal: options.signal });
     if (!response.ok) throw await providerHttpError("Ollama", response, `at ${url}`);
-    const result = (await response.json()) as { message?: { content?: string }; prompt_eval_count?: number; eval_count?: number; total_duration?: number };
+    const result = (await response.json()) as { message?: { content?: string }; done_reason?: string; prompt_eval_count?: number; eval_count?: number; total_duration?: number };
     options.onUsage?.({ inputTokens: result.prompt_eval_count, outputTokens: result.eval_count, durationMs: result.total_duration ? Math.round(result.total_duration / 1e6) : undefined });
-    return result.message?.content ?? "";
+    const text = result.message?.content ?? "";
+    if (!text) throw emptyCompletionError(result.done_reason);
+    return text;
   },
   async *stream(messages, options) {
     const { url, body } = ollamaRequest(messages, options, true);
     const response = await fetch(url, { method: "POST", headers: { "content-type": "application/json" }, body, signal: options.signal });
     if (!response.ok) throw await providerHttpError("Ollama", response, `(stream) at ${url}`);
     if (!response.body) return;
+    let yieldedAny = false;
+    let doneReason: string | undefined;
     for await (const line of readLines(response.body)) {
-      let chunk: { message?: { content?: string }; done?: boolean; prompt_eval_count?: number; eval_count?: number; total_duration?: number };
+      let chunk: { message?: { content?: string }; done?: boolean; done_reason?: string; prompt_eval_count?: number; eval_count?: number; total_duration?: number };
       try {
         chunk = JSON.parse(line);
       } catch {
         continue;
       }
       const delta = chunk.message?.content;
-      if (delta) yield delta;
+      if (delta) {
+        yieldedAny = true;
+        yield delta;
+      }
       if (chunk.done) {
+        if (chunk.done_reason) doneReason = chunk.done_reason;
         options.onUsage?.({ inputTokens: chunk.prompt_eval_count, outputTokens: chunk.eval_count, durationMs: chunk.total_duration ? Math.round(chunk.total_duration / 1e6) : undefined });
         break;
       }
     }
+    if (!yieldedAny) throw emptyCompletionError(doneReason);
   },
 };