grok-search-cli 0.1.1 → 0.1.3

package/dist/index.js

@@ -0,0 +1,2 @@
+import { o as e } from "./search-DcS355m9.js";
+export { e as grokSearch };

package/dist/search-DcS355m9.js

@@ -0,0 +1,573 @@
+import { chmodSync as e, existsSync as t, mkdirSync as n, writeFileSync as r } from "node:fs";
+import i from "node:os";
+import a from "node:path";
+import o from "conf";
+import { generateText as s, streamText as c } from "ai";
+import { createOpenAICompatible as l } from "@ai-sdk/openai-compatible";
+import { createXai as ee, xai as u } from "@ai-sdk/xai";
+//#region src/config.ts
+var d = "grok-4-1-fast-non-reasoning", f = a.join(i.homedir(), ".config", "grok-search-cli");
+function p(e) {
+	return typeof e == "string" && e.trim() || void 0;
+}
+function m() {
+	return {
+		XAI_API_KEY: "",
+		XAI_MODEL: d,
+		XAI_BASE_URL: "",
+		XAI_COMPAT_MODE: !1,
+		_examples: {
+			xai: {
+				XAI_API_KEY: "your_xai_api_key",
+				XAI_MODEL: "grok-4-1-fast-non-reasoning"
+			},
+			openrouter: {
+				XAI_API_KEY: "your_openrouter_api_key",
+				XAI_MODEL: "x-ai/grok-4.1-fast",
+				XAI_BASE_URL: "https://openrouter.ai/api/v1"
+			},
+			yunwu: {
+				XAI_API_KEY: "your_yunwu_api_key",
+				XAI_MODEL: "grok-4-fast",
+				XAI_BASE_URL: "https://yunwu.ai/v1",
+				XAI_COMPAT_MODE: !0
+			}
+		}
+	};
+}
+function te() {
+	try {
+		return new o({
+			projectName: "grok-search-cli",
+			configName: "config",
+			cwd: f,
+			defaults: m()
+		});
+	} catch (e) {
+		let t = e instanceof Error ? e.message : String(e);
+		throw Error(`Failed to initialize user config: ${t}`);
+	}
+}
+var h = te(), g = h.path;
+function _() {
+	if (n(a.dirname(g), { recursive: !0 }), !t(g)) {
+		r(g, `${JSON.stringify(m(), null, 2)}\n`, "utf8");
+		try {
+			e(g, 384);
+		} catch {}
+	}
+	return g;
+}
+function v() {
+	let e = h.store;
+	return {
+		apiKey: p(process.env.XAI_API_KEY) ?? e?.XAI_API_KEY,
+		model: p(process.env.XAI_MODEL) ?? e?.XAI_MODEL ?? d,
+		baseUrl: p(process.env.XAI_BASE_URL) ?? e?.XAI_BASE_URL,
+		compatModeRaw: process.env.XAI_COMPAT_MODE?.trim() ?? e?.XAI_COMPAT_MODE
+	};
+}
+function y(e) {
+	return e ? {
+		apiKey: p(e.apiKey),
+		model: p(e.model) ?? d,
+		baseUrl: p(e.baseUrl),
+		compatModeRaw: e.compatMode
+	} : v();
+}
+function b() {
+	let e = h.store;
+	return {
+		apiKey: p(process.env.XAI_API_KEY) ? "env" : e?.XAI_API_KEY ? "config" : "missing",
+		model: p(process.env.XAI_MODEL) ? "env" : e?.XAI_MODEL ? "config" : "default",
+		baseUrl: p(process.env.XAI_BASE_URL) ? "env" : e?.XAI_BASE_URL ? "config" : "default",
+		compatMode: process.env.XAI_COMPAT_MODE?.trim() ? "env" : e?.XAI_COMPAT_MODE == null ? "default" : "config"
+	};
+}
+function ne() {
+	return y().model;
+}
+function x() {
+	return y().baseUrl;
+}
+function re() {
+	let e = v(), t = b(), n = T(), r = C(e.baseUrl);
+	return {
+		configPath: g,
+		apiKeyPresent: !!e.apiKey,
+		model: e.model,
+		baseUrl: e.baseUrl,
+		providerKind: r,
+		apiMode: n,
+		sources: t
+	};
+}
+function S(e) {
+	if (!e) return !1;
+	try {
+		let { hostname: t } = new URL(e);
+		return t === "openrouter.ai" || t.endsWith(".openrouter.ai");
+	} catch {
+		return !1;
+	}
+}
+function C(e) {
+	if (!e) return "xai";
+	if (S(e)) return "openrouter";
+	try {
+		let { hostname: t } = new URL(e);
+		if (t === "x.ai" || t.endsWith(".x.ai")) return "xai";
+	} catch {}
+	return "third-party";
+}
+function w(e) {
+	let { compatModeRaw: t, baseUrl: n } = y(e);
+	return C(n) !== "openrouter" && /^(1|true|yes|on)$/i.test(String(t || ""));
+}
+function T(e) {
+	return w(e) ? "completion" : "responses";
+}
+function E(e, t = x()) {
+	return C(t) === "openrouter" && e === "responses" ? "OpenRouter Responses API Beta" : e === "responses" ? "xAI Responses API" : "OpenAI-compatible /chat/completions";
+}
+function D(e, t) {
+	if (e === "xai") {
+		console.error(t === "responses" ? "xAI Responses API request failed. Check XAI_API_KEY, model name, and search parameters." : "xAI-compatible completion request failed. Check XAI_API_KEY, model name, and gateway settings.");
+		return;
+	}
+	if (e === "openrouter") {
+		console.error("OpenRouter request failed. This CLI uses OpenRouter Responses API web search for openrouter.ai endpoints.");
+		return;
+	}
+	console.error("Third-party gateway request failed. Verify the gateway supports the selected API shape and that web search is enabled on the provider side.");
+}
+//#endregion
+//#region src/output.ts
+function O({ model: e, finishReason: t, requestApi: n, baseUrl: r, durationMs: i, firstTokenLatencyMs: a, usage: o }) {
+	let s = o ?? {}, c = s.outputTokens, l = s.outputTokenDetails?.reasoningTokens;
+	return {
+		model: e,
+		finishReason: t,
+		requestApi: n,
+		baseUrl: r,
+		durationMs: i,
+		firstTokenLatencyMs: a,
+		tokensPerSecond: typeof c == "number" && i > 0 ? Number((c * 1e3 / i).toFixed(2)) : void 0,
+		usage: {
+			inputTokens: s.inputTokens,
+			outputTokens: c,
+			reasoningTokens: l,
+			totalTokens: s.totalTokens
+		}
+	};
+}
+function k(e) {
+	process.stdout.write("\nVerbose:\n"), process.stdout.write(`Model: ${e.model}\n`), process.stdout.write(`Finish reason: ${e.finishReason}\n`), process.stdout.write(`Request API: ${e.requestApi}\n`), e.baseUrl && process.stdout.write(`Base URL: ${e.baseUrl}\n`);
+	let t = [`Duration: ${(e.durationMs / 1e3).toFixed(2)}s`];
+	e.firstTokenLatencyMs != null && t.push(`first token ${(e.firstTokenLatencyMs / 1e3).toFixed(2)}s`), process.stdout.write(`${t.join(", ")}\n`);
+	let n = [
+		e.usage.inputTokens == null ? void 0 : `input=${e.usage.inputTokens}`,
+		e.usage.outputTokens == null ? void 0 : `output=${e.usage.outputTokens}`,
+		e.usage.reasoningTokens == null ? void 0 : `reasoning=${e.usage.reasoningTokens}`,
+		e.usage.totalTokens == null ? void 0 : `total=${e.usage.totalTokens}`
+	].filter(Boolean);
+	n.length > 0 && process.stdout.write(`Usage: ${n.join(", ")}\n`), e.tokensPerSecond != null && process.stdout.write(`TPS: ${e.tokensPerSecond}\n`);
+}
+function ie(e) {
+	process.stdout.write(`${e.text}\n`), e.verbose && k(e.verbose);
+}
+async function ae(e) {
+	let t = !1, n = !1, r;
+	for await (let i of e.stream.textStream) r ??= Date.now() - e.startedAt, t = !0, n = i.endsWith("\n"), process.stdout.write(i);
+	(!t || !n) && process.stdout.write("\n");
+	let i = await e.stream.usage, a = await e.stream.finishReason ?? "unknown", o = {
+		...e.payload,
+		text: await e.stream.text,
+		finishReason: a,
+		usage: i ?? null,
+		sources: await e.stream.sources ?? [],
+		verbose: e.includeVerbose ? O({
+			model: e.payload.model,
+			finishReason: a,
+			requestApi: e.requestApi,
+			baseUrl: e.baseUrl,
+			durationMs: Date.now() - e.startedAt,
+			firstTokenLatencyMs: r,
+			usage: i
+		}) : void 0
+	};
+	o.verbose && (process.stdout.write("\n"), k(o.verbose));
+}
+//#endregion
+//#region node_modules/.pnpm/p-defer@4.0.1/node_modules/p-defer/index.js
+function oe() {
+	let e = {};
+	return e.promise = new Promise((t, n) => {
+		e.resolve = t, e.reject = n;
+	}), e;
+}
+//#endregion
+//#region src/openrouter.ts
+function A(e) {
+	let t = {};
+	return e.allowedDomains.length > 0 && (t.allowed_domains = e.allowedDomains), e.excludedDomains.length > 0 && (t.excluded_domains = e.excludedDomains), se(t) ? {
+		type: "openrouter:web_search",
+		parameters: t
+	} : { type: "openrouter:web_search" };
+}
+function se(e) {
+	return Object.keys(e).length > 0;
+}
+function j(e, t, n) {
+	return {
+		model: t.model,
+		input: e,
+		tools: [A(t)],
+		stream: n
+	};
+}
+async function M(e) {
+	if (!e.ok) throw Error(await e.text());
+	return e;
+}
+function N(e) {
+	return (e.output?.find((e) => e.type === "message"))?.content?.find((e) => e.type === "output_text")?.text ?? "";
+}
+function P(e) {
+	return ((e.output?.find((e) => e.type === "message"))?.content?.find((e) => e.type === "output_text"))?.annotations?.filter((e) => e.type === "url_citation").map((e) => ({
+		sourceType: "url_citation",
+		url: e.url
+	})) ?? [];
+}
+function F(e) {
+	return {
+		inputTokens: e?.input_tokens,
+		outputTokens: e?.output_tokens,
+		totalTokens: e?.total_tokens,
+		outputTokenDetails: {
+			textTokens: e?.output_tokens,
+			reasoningTokens: void 0
+		}
+	};
+}
+function I(e) {
+	return {
+		text: N(e),
+		finishReason: e.status ?? "unknown",
+		usage: F(e.usage),
+		sources: P(e)
+	};
+}
+async function L(e) {
+	return M(await fetch(`${e.baseUrl}/responses`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${e.apiKey}`,
+			"Content-Type": "application/json"
+		},
+		body: JSON.stringify(e.body),
+		signal: e.abortSignal
+	}));
+}
+function R(e) {
+	return (t) => ({
+		...t,
+		tools: [A(e)]
+	});
+}
+function z(e) {
+	if (!e.startsWith("data: ")) return { type: "ignore" };
+	let t = e.slice(6);
+	if (t === "[DONE]") return { type: "done" };
+	let n = JSON.parse(t);
+	return n.type === "response.output_text.delta" && typeof n.delta == "string" ? {
+		type: "delta",
+		text: n.delta
+	} : n.type === "response.completed" ? {
+		type: "completed",
+		response: n.response
+	} : { type: "ignore" };
+}
+async function B(e) {
+	return I(await (await L({
+		baseUrl: e.baseUrl,
+		apiKey: e.apiKey,
+		body: j(e.prompt, e.options, !1),
+		abortSignal: e.abortSignal
+	})).json());
+}
+async function V(e) {
+	let t = (await L({
+		baseUrl: e.baseUrl,
+		apiKey: e.apiKey,
+		body: j(e.prompt, e.options, !0),
+		abortSignal: e.abortSignal
+	})).body?.getReader();
+	if (!t) throw Error("OpenRouter streaming response body is missing.");
+	let n = new TextDecoder(), r = "", i = oe(), a = !1, o = (async function* () {
+		try {
+			for (;;) {
+				let { done: e, value: o } = await t.read();
+				if (e) break;
+				r += n.decode(o, { stream: !0 });
+				let s = r.split("\n");
+				r = s.pop() ?? "";
+				for (let e of s) {
+					let t = z(e);
+					if (t.type === "delta") {
+						yield t.text;
+						continue;
+					}
+					if (t.type === "completed") {
+						a = !0, i.resolve(t.response);
+						continue;
+					}
+					if (t.type === "done") return;
+				}
+			}
+			a || i.reject(/* @__PURE__ */ Error("OpenRouter stream ended before response.completed."));
+		} catch (e) {
+			throw i.reject(e), e;
+		}
+	})(), s = i.promise.then(I);
+	return {
+		textStream: o,
+		text: s.then((e) => e.text),
+		finishReason: s.then((e) => e.finishReason),
+		usage: s.then((e) => e.usage),
+		sources: s.then((e) => e.sources)
+	};
+}
+//#endregion
+//#region src/providers.ts
+function H(e) {
+	return e.stream === !0 ? {
+		...e,
+		stream_options: {
+			...typeof e.stream_options == "object" && e.stream_options != null ? e.stream_options : {},
+			include_usage: !0
+		}
+	} : e;
+}
+function U(e) {
+	return {
+		web_search: u.tools.webSearch({
+			allowedDomains: e.allowedDomains.length > 0 ? e.allowedDomains : void 0,
+			excludedDomains: e.excludedDomains.length > 0 ? e.excludedDomains : void 0,
+			enableImageUnderstanding: e.enableImageUnderstanding || void 0
+		}),
+		x_search: u.tools.xSearch({
+			allowedXHandles: e.allowedHandles.length > 0 ? e.allowedHandles : void 0,
+			excludedXHandles: e.excludedHandles.length > 0 ? e.excludedHandles : void 0,
+			fromDate: e.fromDate,
+			toDate: e.toDate,
+			enableImageUnderstanding: e.enableImageUnderstanding || void 0,
+			enableVideoUnderstanding: e.enableVideoUnderstanding || void 0
+		})
+	};
+}
+function W(e) {
+	let { baseUrl: t } = e;
+	return t ? ee({ baseURL: t }) : u;
+}
+function G(e, t) {
+	let { baseUrl: n, apiKey: r } = e, i = S(n) ? R(t) : void 0;
+	return l({
+		name: "compat",
+		apiKey: r,
+		baseURL: n || "https://api.x.ai/v1",
+		transformRequestBody: (e) => H(i ? i(e) : e)
+	});
+}
+function K(e) {
+	return e.allowedDomains.length > 0 || e.excludedDomains.length > 0 || e.allowedHandles.length > 0 || e.excludedHandles.length > 0 || typeof e.fromDate == "string" || typeof e.toDate == "string" || e.enableImageUnderstanding || e.enableVideoUnderstanding;
+}
+function ce(e) {
+	return e.allowedHandles.length > 0 || e.excludedHandles.length > 0 || typeof e.fromDate == "string" || typeof e.toDate == "string" || e.enableImageUnderstanding || e.enableVideoUnderstanding;
+}
+//#endregion
+//#region src/search.ts
+var le = "grok-4-1-fast-non-reasoning";
+function q(e = le) {
+	return {
+		model: e,
+		timeoutMs: 6e4,
+		verbose: !1,
+		allowedDomains: [],
+		excludedDomains: [],
+		allowedHandles: [],
+		excludedHandles: [],
+		enableImageUnderstanding: !1,
+		enableVideoUnderstanding: !1
+	};
+}
+function ue(e) {
+	let t = q(y(e).model);
+	return {
+		...t,
+		model: e.model?.trim() || t.model,
+		timeoutMs: e.timeoutMs ?? t.timeoutMs,
+		verbose: e.verbose ?? t.verbose,
+		allowedDomains: e.allowedDomains ?? t.allowedDomains,
+		excludedDomains: e.excludedDomains ?? t.excludedDomains,
+		allowedHandles: e.allowedHandles ?? t.allowedHandles,
+		excludedHandles: e.excludedHandles ?? t.excludedHandles,
+		fromDate: e.fromDate,
+		toDate: e.toDate,
+		enableImageUnderstanding: e.enableImageUnderstanding ?? t.enableImageUnderstanding,
+		enableVideoUnderstanding: e.enableVideoUnderstanding ?? t.enableVideoUnderstanding
+	};
+}
+function de(e) {
+	let t = y(e);
+	if (!t.apiKey) throw Error("Missing XAI_API_KEY in grokSearch config.");
+	return t.apiKey;
+}
+function J() {
+	let e = y();
+	if (!e.apiKey) {
+		let e = _();
+		throw Error(`Missing XAI_API_KEY.\n\nEdit ${e} or set XAI_API_KEY in your shell environment.\nThis CLI reads credentials from process.env first, then ${g}.`);
+	}
+	return e.apiKey;
+}
+function fe(e, t, n) {
+	return e === "completion" && K(n) && !S(t);
+}
+function Y(e, t) {
+	return t === "openrouter" && e === "responses";
+}
+function pe(e, t, n) {
+	let r = C(t), i = [];
+	return fe(e, t, n) && i.push("Warning: compatibility mode is enabled, so tool-specific filters are not forwarded. Remove XAI_COMPAT_MODE to use xAI Responses API."), Y(e, r) && ce(n) && i.push("Warning: OpenRouter server-tool mode currently forwards web domain filters only. X-specific filters such as handles, dates, image, and video options are ignored."), i;
+}
+function X(e, t, n, r) {
+	return {
+		prompt: e,
+		runtimeConfig: t,
+		apiMode: r,
+		requestApi: E(r, t.baseUrl),
+		providerKind: C(t.baseUrl),
+		options: n,
+		startedAt: Date.now(),
+		abortSignal: AbortSignal.timeout(n.timeoutMs)
+	};
+}
+function me(e, t) {
+	if (!t) throw Error("grokSearch requires an explicit config object.");
+	return de(t), X(e, y(t), ue(t), T(t));
+}
+function he(e, t) {
+	return J(), X(e, y(), t, T());
+}
+function Z(e) {
+	return {
+		command: e.command,
+		apiMode: e.apiMode,
+		model: e.model,
+		prompt: e.prompt,
+		text: e.result.text,
+		finishReason: e.result.finishReason ?? "unknown",
+		usage: e.result.usage ?? null,
+		sources: e.result.sources ?? [],
+		verbose: e.verbose ? O({
+			model: e.model,
+			finishReason: e.result.finishReason ?? "unknown",
+			requestApi: e.requestApi,
+			baseUrl: e.baseUrl,
+			durationMs: Date.now() - e.startedAt,
+			usage: e.result.usage ?? null
+		}) : void 0
+	};
+}
+function ge(e) {
+	if (e.apiMode === "responses") {
+		let t = c({
+			model: W(e.runtimeConfig).responses(e.options.model),
+			prompt: e.prompt,
+			tools: U(e.options),
+			abortSignal: e.abortSignal
+		});
+		return {
+			textStream: t.textStream,
+			text: t.text,
+			finishReason: t.finishReason,
+			usage: t.usage,
+			sources: t.sources
+		};
+	}
+	let t = c({
+		model: G(e.runtimeConfig, e.options)(e.options.model),
+		prompt: e.prompt,
+		abortSignal: e.abortSignal
+	});
+	return {
+		textStream: t.textStream,
+		text: t.text,
+		finishReason: t.finishReason,
+		usage: t.usage,
+		sources: t.sources
+	};
+}
+async function _e(e) {
+	if (e.apiMode === "responses") {
+		let t = await s({
+			model: W(e.runtimeConfig).responses(e.options.model),
+			prompt: e.prompt,
+			tools: U(e.options),
+			abortSignal: e.abortSignal
+		});
+		return {
+			text: t.text,
+			finishReason: t.finishReason ?? "unknown",
+			usage: t.usage ?? null,
+			sources: t.sources ?? []
+		};
+	}
+	let t = await s({
+		model: G(e.runtimeConfig, e.options)(e.options.model),
+		prompt: e.prompt,
+		abortSignal: e.abortSignal
+	});
+	return {
+		text: t.text,
+		finishReason: t.finishReason ?? "unknown",
+		usage: t.usage ?? null,
+		sources: t.sources ?? []
+	};
+}
+async function Q(e) {
+	return Y(e.apiMode, e.providerKind) ? V({
+		prompt: e.prompt,
+		options: e.options,
+		baseUrl: e.runtimeConfig.baseUrl || "https://openrouter.ai/api/v1",
+		apiKey: e.runtimeConfig.apiKey,
+		abortSignal: e.abortSignal
+	}) : ge(e);
+}
+async function $(e) {
+	return Y(e.apiMode, e.providerKind) ? B({
+		prompt: e.prompt,
+		options: e.options,
+		baseUrl: e.runtimeConfig.baseUrl || "https://openrouter.ai/api/v1",
+		apiKey: e.runtimeConfig.apiKey,
+		abortSignal: e.abortSignal
+	}) : _e(e);
+}
+async function ve(e, t) {
+	if (!t) throw Error("grokSearch requires an explicit config object.");
+	let n = me(e, t), r = await $(n);
+	return Z({
+		command: "all",
+		apiMode: n.apiMode,
+		model: n.options.model,
+		prompt: n.prompt,
+		result: r,
+		verbose: n.options.verbose,
+		requestApi: n.requestApi,
+		baseUrl: n.runtimeConfig.baseUrl,
+		startedAt: n.startedAt
+	});
+}
+//#endregion
+export { D as _, pe as a, Q as c, _ as d, T as f, C as g, ne as h, J as i, ie as l, re as m, he as n, ve as o, x as p, Z as r, $ as s, q as t, ae as u };

package/dist/src/args.d.ts

@@ -0,0 +1,4 @@
+import { ParsedArgs } from './types';
+declare function fail(message: string): never;
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export { fail };

package/dist/src/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/config.d.ts

@@ -0,0 +1,35 @@
+import { ApiMode, GrokSearchConfig, ProviderKind } from './types';
+interface RuntimeConfig {
+    apiKey?: string;
+    model: string;
+    baseUrl?: string;
+    compatModeRaw?: boolean | string;
+}
+interface RuntimeConfigSources {
+    apiKey: "env" | "config" | "default" | "missing";
+    model: "env" | "config" | "default";
+    baseUrl: "env" | "config" | "default";
+    compatMode: "env" | "config" | "default";
+}
+export declare const CONFIG_PATH: string;
+export declare function ensureUserConfigFile(): string;
+export declare function resolveRuntimeConfig(config?: GrokSearchConfig): RuntimeConfig;
+export declare function getDefaultModel(): string;
+export declare function getApiKey(): string | undefined;
+export declare function getBaseUrl(): string | undefined;
+export declare function getConfigDoctorSnapshot(): {
+    configPath: string;
+    apiKeyPresent: boolean;
+    model: string;
+    baseUrl: string | undefined;
+    providerKind: ProviderKind;
+    apiMode: ApiMode;
+    sources: RuntimeConfigSources;
+};
+export declare function isOpenRouterBaseUrl(baseUrl: string | undefined): boolean;
+export declare function getProviderKind(baseUrl: string | undefined): ProviderKind;
+export declare function isCompatModeEnabled(config?: GrokSearchConfig): boolean;
+export declare function getApiMode(config?: GrokSearchConfig): ApiMode;
+export declare function getRequestApiLabel(apiMode: ApiMode, baseUrl?: string | undefined): "OpenRouter Responses API Beta" | "xAI Responses API" | "OpenAI-compatible /chat/completions";
+export declare function printGatewayError(providerKind: ProviderKind, apiMode: ApiMode): void;
+export {};

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export { grokSearch } from './search';
+export type { GrokSearchConfig, SearchResultPayload } from './types';

package/dist/src/openrouter.d.ts

@@ -0,0 +1,38 @@
+import { CompletedResult, OpenRouterResponsesBody, SearchOptions, StreamResult } from './types';
+export declare function buildOpenRouterResponsesBody(prompt: string, options: SearchOptions, stream: boolean): Record<string, unknown>;
+export declare function buildOpenRouterRequestTransform(options: SearchOptions): (body: Record<string, unknown>) => {
+    tools: ({
+        type: string;
+        parameters: Record<string, unknown>;
+    } | {
+        type: string;
+        parameters?: undefined;
+    })[];
+};
+type OpenRouterStreamEvent = {
+    type: "ignore";
+} | {
+    type: "done";
+} | {
+    type: "delta";
+    text: string;
+} | {
+    type: "completed";
+    response: OpenRouterResponsesBody;
+};
+export declare function parseOpenRouterSseLine(line: string): OpenRouterStreamEvent;
+export declare function fetchOpenRouterResponses(params: {
+    prompt: string;
+    options: SearchOptions;
+    baseUrl: string;
+    apiKey: string;
+    abortSignal: AbortSignal;
+}): Promise<CompletedResult>;
+export declare function streamOpenRouterResponses(params: {
+    prompt: string;
+    options: SearchOptions;
+    baseUrl: string;
+    apiKey: string;
+    abortSignal: AbortSignal;
+}): Promise<StreamResult>;
+export {};

package/dist/src/openrouter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/output.d.ts

@@ -0,0 +1,19 @@
+import { SearchResultPayload, StreamResult, VerbosePayload } from './types';
+export declare function buildVerbosePayload({ model, finishReason, requestApi, baseUrl, durationMs, firstTokenLatencyMs, usage, }: {
+    model: string;
+    finishReason: string;
+    requestApi: string;
+    baseUrl?: string;
+    durationMs: number;
+    firstTokenLatencyMs?: number;
+    usage: unknown;
+}): VerbosePayload;
+export declare function printPretty(payload: SearchResultPayload): void;
+export declare function streamPretty(params: {
+    stream: StreamResult;
+    payload: Omit<SearchResultPayload, "text" | "finishReason" | "usage" | "sources" | "verbose">;
+    includeVerbose: boolean;
+    requestApi: string;
+    baseUrl?: string;
+    startedAt: number;
+}): Promise<void>;

package/dist/src/providers.d.ts

@@ -0,0 +1,12 @@
+import { ToolSet } from 'ai';
+import { SearchOptions } from './types';
+interface ProviderRuntimeConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function buildTools(options: SearchOptions): ToolSet;
+export declare function getResponsesProvider(runtimeConfig: ProviderRuntimeConfig): import('@ai-sdk/xai').XaiProvider;
+export declare function getCompletionProvider(runtimeConfig: ProviderRuntimeConfig, options: SearchOptions): import('@ai-sdk/openai-compatible').OpenAICompatibleProvider<string, string, string, string>;
+export declare function hasToolSpecificOptions(options: SearchOptions): boolean;
+export declare function hasOpenRouterUnsupportedSearchOptions(options: SearchOptions): boolean;
+export {};