@gajae-code/coding-agent 0.7.1 → 0.7.3

package/src/web/search/providers/anthropic.ts

@@ -25,6 +25,7 @@ import type {
 import { SearchProviderError } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
+import { extractTextSources } from "./text-citations";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 const DEFAULT_MODEL = "claude-haiku-4-5";
@@ -87,9 +88,10 @@ async function callSearch(
 	maxTokens?: number,
 	temperature?: number,
 	signal?: AbortSignal,
+	extraHeaders?: Record<string, string>,
 ): Promise<AnthropicApiResponse> {
 	const url = buildAnthropicUrl(auth);
-	const headers = buildAnthropicSearchHeaders(auth);
+	const headers = { ...(extraHeaders ?? {}), ...buildAnthropicSearchHeaders(auth) };
 
 	const systemBlocks = buildSystemBlocks(auth, model, systemPrompt);
 
@@ -191,7 +193,7 @@ function parseResponse(response: AnthropicApiResponse): SearchResponse {
 			if (block.input?.query) {
 				searchQueries.push(block.input.query);
 			}
-		} else if (block.type === "web_search_tool_result" && block.content) {
+		} else if (block.type === "web_search_tool_result" && Array.isArray(block.content)) {
 			// Search results
 			for (const result of block.content) {
 				if (result.type === "web_search_result") {
@@ -235,6 +237,34 @@ function parseResponse(response: AnthropicApiResponse): SearchResponse {
 	};
 }
 
+/**
+ * Whether the response carries proof that a web search actually ran: a
+ * `web_search_tool_result` block, a `web_search` server tool call, or a
+ * non-zero `server_tool_use.web_search_requests` usage counter.
+ */
+function anthropicSearchPerformed(response: AnthropicApiResponse): boolean {
+	if (response.usage?.server_tool_use?.web_search_requests) return true;
+	for (const block of response.content ?? []) {
+		if (block.type === "web_search_tool_result") {
+			// `content` is an array of results on success but an error OBJECT
+			// (`web_search_tool_result_error`) on failure; only count a result
+			// array with at least one real result as proof of search.
+			if (Array.isArray(block.content) && block.content.some(result => result.type === "web_search_result")) {
+				return true;
+			}
+			continue;
+		}
+		if (
+			block.type === "server_tool_use" &&
+			block.name &&
+			stripClaudeToolPrefix(block.name) === WEB_SEARCH_TOOL_NAME
+		) {
+			return true;
+		}
+	}
+	return false;
+}
+
 /**
  * Executes a web search using Anthropic's Anthropic model with built-in web search tool.
  * @param params - Search parameters including query and optional settings
@@ -248,6 +278,10 @@ export async function searchAnthropic(
 	const searchApiKey = $env.ANTHROPIC_SEARCH_API_KEY;
 	const searchBaseUrl = $env.ANTHROPIC_SEARCH_BASE_URL;
 	let auth: AnthropicAuthConfig | undefined;
+	// When reusing the active model's own credentials (native search over a
+	// proxy), prefer its wire model id and carry its request headers through.
+	let modelOverride: string | undefined;
+	let extraHeaders: Record<string, string> | undefined;
 
 	if (searchApiKey) {
 		auth = buildAnthropicAuthConfig(searchApiKey, searchBaseUrl);
@@ -256,6 +290,23 @@ export async function searchAnthropic(
 			signal: params.signal,
 		});
 		if (apiKey) auth = buildAnthropicAuthConfig(apiKey);
+
+		// Fall back to the active model's own credentials + baseUrl when no
+		// canonical Anthropic key exists but the active model speaks the
+		// Anthropic wire (e.g. Claude served through a proxy).
+		const ctx = params.activeModelContext;
+		if (!auth && ctx && ctx.api === "anthropic-messages") {
+			const ctxKey = await params.authStorage.getApiKey(ctx.provider, params.sessionId, {
+				baseUrl: ctx.baseUrl,
+				modelId: ctx.modelId,
+				signal: params.signal,
+			});
+			if (ctxKey) {
+				auth = buildAnthropicAuthConfig(ctxKey, ctx.baseUrl);
+				modelOverride = ctx.wireModelId ?? ctx.modelId;
+				extraHeaders = ctx.headers;
+			}
+		}
 	}
 
 	if (!auth) {
@@ -264,7 +315,7 @@ export async function searchAnthropic(
 		);
 	}
 
-	const model = getModel();
+	const model = modelOverride ?? getModel();
 	const systemPrompt = "authStorage" in params ? params.systemPrompt : params.system_prompt;
 	const maxTokens = "authStorage" in params ? params.maxOutputTokens : params.max_tokens;
 	const response = await callSearch(
@@ -275,9 +326,25 @@ export async function searchAnthropic(
 		maxTokens,
 		params.temperature,
 		params.signal,
+		extraHeaders,
 	);
 
 	const result = parseResponse(response);
+	const searched = anthropicSearchPerformed(response);
+
+	// When a search ran but the model wrote its citations inline instead of as
+	// structured `web_search_result_location` blocks, recover sources from the
+	// answer text so a genuinely grounded result is not discarded.
+	if (result.sources.length === 0 && searched && result.answer) {
+		const inline = extractTextSources(result.answer);
+		if (inline.length > 0) result.sources = inline;
+	}
+
+	// Fail closed so the chain falls through to DuckDuckGo when Claude answered
+	// from stable knowledge without running a web search.
+	if (result.sources.length === 0 && !(result.citations && result.citations.length > 0) && !searched) {
+		throw new SearchProviderError("anthropic", "Anthropic web search returned no grounded sources", 424);
+	}
 
 	const numResults = "authStorage" in params ? (params.numSearchResults ?? params.limit) : params.num_results;
 	if (numResults && result.sources.length > numResults) {

package/src/web/search/providers/codex.ts

@@ -15,6 +15,7 @@ import type { SearchResponse, SearchSource } from "../../../web/search/types";
 import { SearchProviderError } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
+import { addSource, extractTextSources } from "./text-citations";
 import { classifyProviderHttpError, withHardTimeout } from "./utils";
 
 const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
@@ -118,125 +119,6 @@ function isImagePlaceholderAnswer(text: string): boolean {
 	return text.trim().toLowerCase() === "(see attached image)";
 }
 
-function addSource(sources: SearchSource[], source: SearchSource): void {
-	if (!sources.some(existing => existing.url === source.url)) {
-		sources.push(source);
-	}
-}
-
-function countCharacter(text: string, target: string): number {
-	let count = 0;
-	for (const char of text) {
-		if (char === target) {
-			count += 1;
-		}
-	}
-	return count;
-}
-
-/**
- * Strips prose punctuation and unmatched closing delimiters from extracted URLs.
- * OpenAI code backend often returns links in markdown or sentence text without structured annotations.
- */
-function normalizeExtractedUrl(candidate: string): string | null {
-	let url = candidate.trim();
-
-	while (url.length > 0) {
-		const lastCharacter = url.at(-1);
-		if (!lastCharacter) break;
-		if (/[.,!?;:'"]/u.test(lastCharacter)) {
-			url = url.slice(0, -1);
-			continue;
-		}
-		if (lastCharacter === ")" && countCharacter(url, ")") > countCharacter(url, "(")) {
-			url = url.slice(0, -1);
-			continue;
-		}
-		if (lastCharacter === "]" && countCharacter(url, "]") > countCharacter(url, "[")) {
-			url = url.slice(0, -1);
-			continue;
-		}
-		if (lastCharacter === "}" && countCharacter(url, "}") > countCharacter(url, "{")) {
-			url = url.slice(0, -1);
-			continue;
-		}
-		break;
-	}
-
-	if (!/^https?:\/\//.test(url)) {
-		return null;
-	}
-
-	try {
-		return new URL(url).toString();
-	} catch {
-		return null;
-	}
-}
-
-function findMarkdownLinkUrlEnd(text: string, openParenIndex: number): number | null {
-	let depth = 0;
-
-	for (let index = openParenIndex; index < text.length; index += 1) {
-		const character = text[index];
-		if (!character || character === "\n") {
-			return null;
-		}
-		if (character === "(") {
-			depth += 1;
-			continue;
-		}
-		if (character !== ")") {
-			continue;
-		}
-		depth -= 1;
-		if (depth === 0) {
-			return index;
-		}
-		if (depth < 0) {
-			return null;
-		}
-	}
-
-	return null;
-}
-
-/**
- * Extracts citation sources from markdown links and bare URLs in the answer text.
- * Used as a fallback when the OpenAI code backend response omits `url_citation` annotations.
- */
-function extractTextSources(text: string): SearchSource[] {
-	const sources: SearchSource[] = [];
-
-	for (let index = 0; index < text.length; index += 1) {
-		if (text[index] !== "[") {
-			continue;
-		}
-		const titleEnd = text.indexOf("]", index + 1);
-		if (titleEnd === -1 || text[titleEnd + 1] !== "(") {
-			continue;
-		}
-		const urlEnd = findMarkdownLinkUrlEnd(text, titleEnd + 1);
-		if (urlEnd === null) {
-			continue;
-		}
-		const title = text.slice(index + 1, titleEnd).trim();
-		const url = normalizeExtractedUrl(text.slice(titleEnd + 2, urlEnd));
-		if (url) {
-			addSource(sources, { title: title || url, url });
-		}
-		index = urlEnd;
-	}
-
-	for (const match of text.matchAll(/https?:\/\/\S+/g)) {
-		const url = normalizeExtractedUrl(match[0] ?? "");
-		if (!url) continue;
-		addSource(sources, { title: url, url });
-	}
-
-	return sources;
-}
-
 /**
  * Extracts account ID from a OpenAI code backend access token.
  * @param accessToken - JWT access token

package/src/web/search/providers/gemini.ts

@@ -425,6 +425,98 @@ export async function searchGemini(params: GeminiSearchParams): Promise<SearchRe
 	};
 }
 
+/**
+ * Native Gemini web search over the public Generative Language REST API
+ * (`{baseUrl}/v1beta/models/{model}:generateContent`), reusing the ACTIVE
+ * model's own API key + baseUrl. This is the "native search over a proxy" path
+ * for `google-generative-ai` wire models whose canonical gemini-cli/antigravity
+ * OAuth is absent. Distinct from {@link searchGemini}, which speaks the Cloud
+ * Code Assist API with OAuth.
+ */
+async function searchGeminiViaGenerativeLanguage(params: SearchParams): Promise<SearchResponse> {
+	const ctx = params.activeModelContext;
+	if (!ctx) throw new SearchProviderError("gemini", "Gemini web search requires active model context", 400);
+	const apiKey = await params.authStorage.getApiKey(ctx.provider, params.sessionId, {
+		baseUrl: ctx.baseUrl,
+		modelId: ctx.modelId,
+		signal: params.signal,
+	});
+	if (!apiKey) throw new SearchProviderError("gemini", `No credentials for ${ctx.provider}`, 401);
+
+	const model = ctx.wireModelId ?? ctx.modelId;
+	const base = (ctx.baseUrl ?? "https://generativelanguage.googleapis.com").replace(/\/+$/, "");
+	// Respect an already-versioned active baseUrl (e.g. a proxy exposing `…/v1beta`)
+	// instead of double-appending the version segment.
+	const versionedBase = /\/v1(beta|alpha)?$/.test(base) ? base : `${base}/v1beta`;
+	const url = `${versionedBase}/models/${encodeURIComponent(model)}:generateContent`;
+	const systemPrompt = params.systemPrompt?.toWellFormed();
+	const body: Record<string, unknown> = {
+		contents: [{ role: "user", parts: [{ text: params.query }] }],
+		tools: buildGeminiRequestTools({ google_search: params.googleSearch }),
+		...(systemPrompt ? { systemInstruction: { parts: [{ text: systemPrompt }] } } : {}),
+	};
+	if (params.maxOutputTokens !== undefined || params.temperature !== undefined) {
+		const generationConfig: Record<string, number> = {};
+		if (params.maxOutputTokens !== undefined) generationConfig.maxOutputTokens = params.maxOutputTokens;
+		if (params.temperature !== undefined) generationConfig.temperature = params.temperature;
+		body.generationConfig = generationConfig;
+	}
+
+	const response = await fetch(url, {
+		method: "POST",
+		headers: { ...(ctx.headers ?? {}), "x-goog-api-key": apiKey, "Content-Type": "application/json" },
+		body: JSON.stringify(body),
+		signal: withHardTimeout(params.signal),
+	});
+	const text = await response.text();
+	if (!response.ok) {
+		const classified = classifyProviderHttpError("gemini", response.status, text);
+		if (classified) throw classified;
+		throw new SearchProviderError("gemini", `Gemini API error (${response.status}): ${text}`, response.status);
+	}
+
+	const json = text ? JSON.parse(text) : {};
+	const candidate = json.candidates?.[0];
+	const grounding: GeminiGroundingMetadata | undefined = candidate?.groundingMetadata;
+	const answer = (candidate?.content?.parts ?? []).map((part: { text?: string }) => part.text ?? "").join("");
+
+	const sources: SearchSource[] = [];
+	const citations: SearchCitation[] = [];
+	const searchQueries: string[] = [];
+	const seenUrls = new Set<string>();
+	const chunks = grounding?.groundingChunks ?? [];
+	for (const grChunk of chunks) {
+		const uri = grChunk.web?.uri;
+		if (uri && !seenUrls.has(uri)) {
+			seenUrls.add(uri);
+			sources.push({ title: grChunk.web?.title ?? uri, url: uri });
+		}
+	}
+	for (const support of grounding?.groundingSupports ?? []) {
+		const citedText = support.segment?.text;
+		for (const idx of support.groundingChunkIndices ?? []) {
+			const uri = chunks[idx]?.web?.uri;
+			if (uri) citations.push({ url: uri, title: chunks[idx]?.web?.title ?? uri, citedText });
+		}
+	}
+	for (const q of grounding?.webSearchQueries ?? []) {
+		if (!searchQueries.includes(q)) searchQueries.push(q);
+	}
+
+	if (sources.length === 0) {
+		throw new SearchProviderError("gemini", "Gemini native search returned no grounding sources", 424);
+	}
+	const limit = params.numSearchResults ?? params.limit;
+	return {
+		provider: "gemini",
+		answer: answer || undefined,
+		sources: limit && sources.length > limit ? sources.slice(0, limit) : sources,
+		citations: citations.length > 0 ? citations : undefined,
+		searchQueries: searchQueries.length > 0 ? searchQueries : undefined,
+		model: json.modelVersion ?? model,
+	};
+}
+
 /** Search provider for Google Gemini web search. */
 export class GeminiProvider extends SearchProvider {
 	readonly id = "gemini";
@@ -438,6 +530,13 @@ export class GeminiProvider extends SearchProvider {
 	}
 
 	search(params: SearchParams): Promise<SearchResponse> {
+		// Native-over-proxy: when canonical gemini-cli/antigravity OAuth is
+		// absent but the active model speaks the Generative Language wire, reuse
+		// its own API key + baseUrl instead of failing closed.
+		const ctx = params.activeModelContext;
+		if (!hasGeminiOAuth(params.authStorage) && ctx?.api === "google-generative-ai") {
+			return searchGeminiViaGenerativeLanguage(params);
+		}
 		return searchGemini({
 			query: params.query,
 			system_prompt: params.systemPrompt,