@hiai-gg/hiai-opencode 0.1.5 → 0.1.7

package/src/internals/plugins/websearch-cited/index.ts

@@ -1,306 +0,0 @@
-import { type Plugin, tool } from "@opencode-ai/plugin";
-import type { Config } from "@opencode-ai/sdk";
-
-import { createGoogleWebsearchClient } from "./google";
-import { createOpenAIWebsearchClient, type OpenAIWebsearchConfig } from "./openai";
-import { createOpenRouterWebsearchClient } from "./openrouter";
-import type { GetAuth } from "./types";
-
-export const GOOGLE_PROVIDER_ID = "google";
-export const OPENAI_PROVIDER_ID = "openai";
-export const OPENROUTER_PROVIDER_ID = "openrouter";
-
-const CITED_SEARCH_TOOL_DESCRIPTION =
-	"Performs a Gemini-style grounded web search: returns a concise digest with inline citations and a Sources list of URLs. NOTE: for LLM rate limits, DO NOT parallel this tool > 5";
-
-const WEBSEARCH_ARGS = {
-	query: tool.schema.string().describe("The natural language web search query."),
-} as const;
-
-const WEBSEARCH_ALLOWED_KEYS = new Set(Object.keys(WEBSEARCH_ARGS));
-
-const WEBSEARCH_ALLOWED_KEYS_DESCRIPTION = Array.from(WEBSEARCH_ALLOWED_KEYS)
-	.map((key) => `'${key}'`)
-	.join(", ");
-
-type SelectedProviderID = typeof GOOGLE_PROVIDER_ID | typeof OPENAI_PROVIDER_ID | typeof OPENROUTER_PROVIDER_ID;
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-
-const authRegistry = new Map<string, GetAuth>();
-
-export function registerGetAuth(providerID: string, getAuth: GetAuth): void {
-	authRegistry.set(providerID, getAuth);
-}
-
-export function resolveGetAuth(providerID: string): GetAuth | undefined {
-	return authRegistry.get(providerID);
-}
-
-type SelectedWebsearchConfig = {
-	providerID: SelectedProviderID;
-	model: string;
-};
-
-export type WebsearchCitedFallback = SelectedWebsearchConfig;
-
-type WebsearchCitedSelection = {
-	selected?: SelectedWebsearchConfig;
-	error?: string;
-};
-
-function findFirstWebsearchCitedConfig(config: Config): WebsearchCitedSelection {
-	const providers = config.provider;
-	if (!providers || typeof providers !== "object") {
-		return {};
-	}
-
-	let firstError: string | undefined;
-
-	for (const [providerID, providerConfig] of Object.entries(providers)) {
-		if (!providerConfig || typeof providerConfig !== "object") {
-			continue;
-		}
-
-		const options = (providerConfig as { options?: unknown }).options;
-		if (!isRecord(options)) {
-			continue;
-		}
-
-		if (!("websearch_cited" in options)) {
-			continue;
-		}
-
-		const cited = options.websearch_cited;
-		if (!isRecord(cited)) {
-			firstError ??= `Invalid websearch_cited configuration for provider "${providerID}".`;
-			continue;
-		}
-
-		const candidate = cited.model;
-		if (typeof candidate !== "string" || candidate.trim() === "") {
-			firstError ??= `Missing websearch_cited model for provider "${providerID}".`;
-			continue;
-		}
-
-		if (
-			providerID !== GOOGLE_PROVIDER_ID &&
-			providerID !== OPENAI_PROVIDER_ID &&
-			providerID !== OPENROUTER_PROVIDER_ID
-		) {
-			firstError ??= `Unsupported provider "${providerID}" for websearch_cited.`;
-			continue;
-		}
-
-		return {
-			selected: {
-				providerID: providerID as SelectedProviderID,
-				model: candidate.trim(),
-			},
-		};
-	}
-
-	return firstError ? { error: firstError } : {};
-}
-
-function parseOpenAIOptions(providerConfig: unknown, model: string | undefined): OpenAIWebsearchConfig {
-	if (!isRecord(providerConfig)) {
-		return {};
-	}
-
-	const providerRecord = providerConfig;
-
-	const rawOptions = (providerRecord as { options?: unknown }).options;
-	const baseOptions = isRecord(rawOptions) ? rawOptions : undefined;
-
-	let modelOptions: Record<string, unknown> | undefined;
-	const rawModels = (providerRecord as { models?: unknown }).models;
-	if (model && isRecord(rawModels)) {
-		const modelsRecord: Record<string, unknown> = rawModels;
-		const entry = modelsRecord[model];
-		if (isRecord(entry)) {
-			const entryOptions = (entry as { options?: unknown }).options;
-			if (isRecord(entryOptions)) {
-				modelOptions = entryOptions;
-			}
-		}
-	}
-
-	const merged: Record<string, unknown> = {
-		...(baseOptions ?? {}),
-		...(modelOptions ?? {}),
-	};
-
-	const result: OpenAIWebsearchConfig = {};
-
-	const reasoningEffort = merged.reasoningEffort;
-	if (typeof reasoningEffort === "string" && reasoningEffort.trim() !== "") {
-		result.reasoningEffort = reasoningEffort.trim();
-	}
-
-	const reasoningSummary = merged.reasoningSummary;
-	if (typeof reasoningSummary === "string" && reasoningSummary.trim() !== "") {
-		result.reasoningSummary = reasoningSummary.trim();
-	}
-
-	const textVerbosity = merged.textVerbosity;
-	if (typeof textVerbosity === "string" && textVerbosity.trim() !== "") {
-		result.textVerbosity = textVerbosity.trim();
-	}
-
-	const store = merged.store;
-	if (typeof store === "boolean") {
-		result.store = store;
-	}
-
-	const include = merged.include;
-	if (Array.isArray(include)) {
-		const filtered = include.filter((value) => typeof value === "string" && value.trim() !== "");
-		if (filtered.length > 0) {
-			result.include = filtered;
-		}
-	}
-
-	return result;
-}
-
-const WebsearchCitedPlugin = (_ctx?: unknown, fallback?: WebsearchCitedFallback): Promise<any> => {
-	let selectedProvider: SelectedProviderID | undefined = fallback?.providerID;
-	let selectedModel: string | undefined = fallback?.model;
-	let openaiConfig: OpenAIWebsearchConfig = {};
-	let configError: string | undefined;
-
-	return Promise.resolve({
-		auth: {
-			provider: OPENROUTER_PROVIDER_ID,
-			loader(getAuth: GetAuth) {
-				registerGetAuth(OPENROUTER_PROVIDER_ID, getAuth);
-				return Promise.resolve({});
-			},
-			methods: [
-				{
-					type: "api",
-					label: "OpenRouter API key",
-				},
-			],
-		},
-		config: (config: Config) => {
-			const { selected, error } = findFirstWebsearchCitedConfig(config as any);
-
-			selectedProvider = undefined;
-			selectedModel = undefined;
-			openaiConfig = {};
-			configError = error;
-
-			if (selected) {
-				selectedProvider = selected.providerID;
-				selectedModel = selected.model;
-				if (selectedProvider === OPENAI_PROVIDER_ID) {
-					const openaiProvider = config.provider?.openai;
-					openaiConfig = parseOpenAIOptions(openaiProvider, selectedModel);
-				}
-			} else if (!error && fallback) {
-				selectedProvider = fallback.providerID;
-				selectedModel = fallback.model;
-			}
-
-			return Promise.resolve();
-		},
-		tool: {
-			websearch_cited: tool({
-				description: CITED_SEARCH_TOOL_DESCRIPTION,
-				args: WEBSEARCH_ARGS,
-				async execute(args, context) {
-					const argKeys = Object.keys(args ?? {});
-					const extraKeys = argKeys.filter((key) => !WEBSEARCH_ALLOWED_KEYS.has(key));
-					if (extraKeys.length > 0) {
-						throw new Error(
-							`Unknown argument(s): ${extraKeys.join(", ")}, only ${WEBSEARCH_ALLOWED_KEYS_DESCRIPTION} supported.`
-						);
-					}
-
-					const query = args.query?.trim();
-					if (!query) {
-						throw new Error("The 'query' parameter cannot be empty.");
-					}
-
-					if (configError) {
-						throw new Error(configError);
-					}
-
-					if (!selectedProvider || !selectedModel) {
-						throw new Error("Missing web search model configuration.");
-					}
-
-					if (selectedProvider === OPENAI_PROVIDER_ID) {
-						const getAuth = resolveGetAuth(OPENAI_PROVIDER_ID);
-						if (!getAuth) {
-							throw new Error('Missing auth for provider "openai". Authenticate via `opencode auth login`.');
-						}
-
-						const client = createOpenAIWebsearchClient(selectedModel, openaiConfig);
-						return client.search(query, context.abort, getAuth);
-					}
-
-					if (selectedProvider === OPENROUTER_PROVIDER_ID) {
-						const getAuth = resolveGetAuth(OPENROUTER_PROVIDER_ID);
-						if (!getAuth) {
-							throw new Error('Missing auth for provider "openrouter". Authenticate via `opencode auth login`.');
-						}
-
-						const client = createOpenRouterWebsearchClient(selectedModel);
-						return client.search(query, context.abort, getAuth);
-					}
-
-					const getAuth = resolveGetAuth(GOOGLE_PROVIDER_ID);
-					if (!getAuth) {
-						throw new Error('Missing auth for provider "google". Authenticate via `opencode auth login`.');
-					}
-
-					const client = createGoogleWebsearchClient(selectedModel);
-					return client.search(query, context.abort, getAuth);
-				},
-			}),
-		},
-	});
-};
-
-export const WebsearchCitedGooglePlugin: Plugin = () => {
-	return Promise.resolve({
-		auth: {
-			provider: GOOGLE_PROVIDER_ID,
-			loader(getAuth) {
-				registerGetAuth(GOOGLE_PROVIDER_ID, getAuth);
-				return Promise.resolve({});
-			},
-			methods: [
-				{
-					type: "api",
-					label: "Google API key",
-				},
-			],
-		},
-	});
-};
-
-export const WebsearchCitedOpenAIPlugin: Plugin = () => {
-	return Promise.resolve({
-		auth: {
-			provider: OPENAI_PROVIDER_ID,
-			loader(getAuth) {
-				registerGetAuth(OPENAI_PROVIDER_ID, getAuth);
-				return Promise.resolve({});
-			},
-			methods: [
-				{
-					type: "api",
-					label: "OpenAI API key",
-				},
-			],
-		},
-	});
-};
-
-export default WebsearchCitedPlugin;

package/src/internals/plugins/websearch-cited/openai.ts

@@ -1,407 +0,0 @@
-import type { Auth as ProviderAuth } from "@opencode-ai/sdk";
-import codexPrompt from "./codex_prompt.txt" with { type: "text" };
-import type { GetAuth, WebsearchClient } from "./types.ts";
-
-type OpenAIReasoningConfig = {
-	effort?: string;
-	summary?: string;
-};
-
-type OpenAITextConfig = {
-	verbosity?: string;
-};
-
-type OpenAIInputContent = {
-	type: "input_text";
-	text: string;
-};
-
-type OpenAIInputMessage = {
-	role: "user";
-	content: OpenAIInputContent[];
-};
-
-type OpenAITool = {
-	type: "web_search";
-};
-
-type OpenAIResponsesRequest = {
-	model: string;
-	instructions: string;
-	input: OpenAIInputMessage[];
-	tools: OpenAITool[];
-	reasoning?: OpenAIReasoningConfig;
-	text?: OpenAITextConfig;
-	store?: boolean;
-	include?: string[];
-	stream?: boolean;
-	tool_choice?: string;
-	parallel_tool_calls?: boolean;
-};
-
-function buildWebSearchUserPrompt(query: string): string {
-	const normalized = query.trim();
-	return `perform web search on "${normalized}". Return results with inline citations (**only** source index like [1], no URL in the answer) and end with a Sources list of URLs.`;
-}
-
-type OpenAIWebSearchOptions = {
-	model: string;
-	query: string;
-	abortSignal: AbortSignal;
-	auth: ProviderAuth;
-	reasoningEffort?: string;
-	reasoningSummary?: string;
-	textVerbosity?: string;
-	store?: boolean;
-	include?: string[];
-};
-
-export type OpenAIWebsearchConfig = {
-	reasoningEffort?: string;
-	reasoningSummary?: string;
-	textVerbosity?: string;
-	store?: boolean;
-	include?: string[];
-};
-
-function getAccessToken(auth: ProviderAuth): string {
-	if (auth.type === "oauth") {
-		const access = auth.access.trim();
-		if (!access) {
-			throw new Error("Missing OpenAI OAuth access token");
-		}
-		return access;
-	}
-
-	if (auth.type === "api") {
-		const key = auth.key.trim();
-		if (!key) {
-			throw new Error("Missing OpenAI API key");
-		}
-		return key;
-	}
-
-	const token = auth.token.trim();
-	if (!token) {
-		throw new Error("Missing OpenAI token");
-	}
-	return token;
-}
-
-function extractChatGPTAccountId(auth: ProviderAuth): string | undefined {
-	if (auth.type !== "oauth") {
-		return undefined;
-	}
-
-	const access = auth.access.trim();
-	if (!access) {
-		return undefined;
-	}
-
-	const parts = access.split(".");
-	if (parts.length !== 3) {
-		return undefined;
-	}
-
-	try {
-		const payload = parts[1];
-		if (!payload) {
-			return undefined;
-		}
-		const decoded = Buffer.from(payload, "base64").toString("utf8");
-		const parsed = JSON.parse(decoded) as unknown;
-		if (!parsed || typeof parsed !== "object") {
-			return undefined;
-		}
-		const root = parsed as { [key: string]: unknown };
-		const claim = root["https://api.openai.com/auth"];
-		if (!claim || typeof claim !== "object") {
-			return undefined;
-		}
-		const accountId = (claim as { chatgpt_account_id?: unknown }).chatgpt_account_id;
-		if (typeof accountId !== "string") {
-			return undefined;
-		}
-		const trimmed = accountId.trim();
-		return trimmed === "" ? undefined : trimmed;
-	} catch {
-		return undefined;
-	}
-}
-
-async function runOpenAIWebSearch(options: OpenAIWebSearchOptions): Promise<string> {
-	const normalizedModel = options.model.trim();
-	if (!normalizedModel) {
-		throw new Error("Invalid OpenAI web search model");
-	}
-
-	const normalizedQuery = options.query.trim();
-	if (!normalizedQuery) {
-		throw new Error("Query must not be empty");
-	}
-
-	const accessToken = getAccessToken(options.auth);
-	const isOAuth = options.auth.type === "oauth";
-
-	const body: OpenAIResponsesRequest = {
-		model: normalizedModel,
-		instructions: "",
-		input: [
-			{
-				role: "user",
-				content: [
-					{
-						type: "input_text",
-						text: buildWebSearchUserPrompt(normalizedQuery),
-					},
-				],
-			},
-		],
-		tools: [{ type: "web_search" }],
-		include: ["web_search_call.action.sources"],
-	};
-
-	if (options.reasoningEffort || options.reasoningSummary) {
-		body.reasoning = {
-			effort: options.reasoningEffort,
-			summary: options.reasoningSummary,
-		};
-	}
-	body.store = false;
-
-	if (options.textVerbosity) {
-		body.text = {
-			verbosity: options.textVerbosity,
-		};
-	}
-
-	if (Array.isArray(options.include) && options.include.length > 0) {
-		const filtered = options.include.filter((value) => typeof value === "string" && value.trim() !== "");
-		if (filtered.length > 0) {
-			body.include = filtered;
-		}
-	}
-
-	body.stream = true;
-	body.tool_choice = "auto";
-	body.parallel_tool_calls = true;
-
-	if (isOAuth) {
-		// NOTE: Do not modify Codex backend instructions; invalid instructions will be rejected.
-		body.instructions = codexPrompt;
-	} else {
-		body.instructions = "You are an AI assistant answering a single web search query for the user.";
-	}
-
-	const url = isOAuth ? "https://chatgpt.com/backend-api/codex/responses" : "https://api.openai.com/v1/responses";
-
-	const headers: Record<string, string> = {
-		Authorization: `Bearer ${accessToken}`,
-		"Content-Type": "application/json",
-		"OpenAI-Beta": "responses=experimental",
-	};
-
-	if (isOAuth) {
-		const accountId = extractChatGPTAccountId(options.auth);
-		if (accountId) {
-			headers["chatgpt-account-id"] = accountId;
-		}
-		headers.originator = "codex_cli_rs";
-	}
-
-	const response = await fetch(url, {
-		method: "POST",
-		headers,
-		body: JSON.stringify(body),
-		signal: options.abortSignal,
-	});
-
-	if (!response.ok) {
-		const message = await buildErrorDetails(response, url, body);
-		throw new Error(message);
-	}
-
-	const payload = await readOpenAIResponsePayload(response);
-	const text = extractOpenAIText(payload);
-
-	if (!text || !text.trim()) {
-		return `Web search completed for "${normalizedQuery}", but no results were returned.`;
-	}
-
-	return text;
-}
-
-export function createOpenAIWebsearchClient(model: string, config: OpenAIWebsearchConfig): WebsearchClient {
-	const normalizedModel = model.trim();
-	if (!normalizedModel) {
-		throw new Error("Invalid OpenAI web search model");
-	}
-
-	return {
-		async search(query, abortSignal, getAuth: GetAuth) {
-			const normalizedQuery = query.trim();
-			if (!normalizedQuery) {
-				throw new Error("Query must not be empty");
-			}
-
-			const auth = await getAuth();
-			if (!auth) {
-				throw new Error('Missing auth for provider "openai"');
-			}
-
-			return runOpenAIWebSearch({
-				model: normalizedModel,
-				query: normalizedQuery,
-				abortSignal,
-				auth,
-				reasoningEffort: config.reasoningEffort,
-				reasoningSummary: config.reasoningSummary,
-				textVerbosity: config.textVerbosity,
-				store: config.store,
-				include: config.include,
-			});
-		},
-	};
-}
-
-function extractOpenAIText(payload: unknown): string | undefined {
-	if (!payload || typeof payload !== "object") {
-		return undefined;
-	}
-
-	const root = payload as { output?: unknown };
-	const output = root.output;
-	if (!Array.isArray(output) || output.length === 0) {
-		return undefined;
-	}
-
-	let combined = "";
-
-	for (const item of output) {
-		if (!item || typeof item !== "object") {
-			continue;
-		}
-
-		const content = (item as { content?: unknown }).content;
-		if (!Array.isArray(content)) {
-			continue;
-		}
-
-		for (const part of content) {
-			if (!part || typeof part !== "object") {
-				continue;
-			}
-
-			const kind = (part as { type?: unknown }).type;
-			if (kind !== "output_text") {
-				continue;
-			}
-
-			const textField = (part as { text?: unknown }).text;
-			if (typeof textField === "string") {
-				combined += textField;
-			} else if (textField && typeof textField === "object") {
-				const obj = textField as { value?: unknown };
-				if (typeof obj.value === "string") {
-					combined += obj.value;
-				}
-			}
-		}
-	}
-
-	return combined || undefined;
-}
-
-async function buildErrorDetails(response: Response, url: string, body: OpenAIResponsesRequest): Promise<string> {
-	const parts: string[] = [];
-	parts.push(`status=${response.status}`);
-	parts.push(`url=${url}`);
-	const safeBody: OpenAIResponsesRequest = { ...body };
-	if (typeof safeBody.instructions === "string") {
-		const value = safeBody.instructions;
-		const maxLength = 512;
-		if (value.length > maxLength) {
-			const headLength = 256;
-			const tailLength = 128;
-			const head = value.slice(0, headLength);
-			const tail = value.slice(-tailLength);
-			const omitted = value.length - headLength - tailLength;
-			safeBody.instructions = `${head} ... [${omitted} chars truncated] ... ${tail}`;
-		}
-	}
-	parts.push(`requestBody=${JSON.stringify(safeBody)}`);
-
-	let rawText: string | undefined;
-	try {
-		rawText = await response.text();
-	} catch {}
-
-	if (rawText) {
-		let parsedMessage: string | undefined;
-		try {
-			const parsed = JSON.parse(rawText) as { error?: { message?: unknown } };
-			const message = parsed.error?.message;
-			if (typeof message === "string" && message.trim() !== "") {
-				parsedMessage = message.trim();
-			}
-		} catch {}
-
-		if (parsedMessage) {
-			parts.unshift(`error=${parsedMessage}`);
-		}
-
-		parts.push(`responseBody=${rawText}`);
-	}
-
-	return parts.join(" | ");
-}
-
-type OpenAISseEvent = {
-	type?: string;
-	response?: object;
-};
-
-async function readOpenAIResponsePayload(response: Response): Promise<unknown> {
-	const text = await response.text();
-	const trimmed = text.trim();
-	if (trimmed === "") {
-		return {};
-	}
-
-	if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-		try {
-			const parsed = JSON.parse(trimmed) as unknown;
-			return parsed;
-		} catch {}
-	}
-
-	const extracted = extractOpenAIResponseFromSse(text);
-	if (extracted !== undefined) {
-		return extracted;
-	}
-
-	throw new Error("Failed to parse JSON");
-}
-
-function extractOpenAIResponseFromSse(sseText: string): object | undefined {
-	const lines = sseText.split("\n");
-
-	for (const line of lines) {
-		if (!line.startsWith("data: ")) {
-			continue;
-		}
-		const payload = line.slice(6).trim();
-		if (!payload || payload === "[DONE]") {
-			continue;
-		}
-		try {
-			const parsed = JSON.parse(payload) as OpenAISseEvent;
-			const kind = parsed.type ?? "";
-			if (kind === "response.done" || kind === "response.completed") {
-				return parsed.response;
-			}
-		} catch {}
-	}
-
-	return undefined;
-}