@gaodefa/daocore 2026.5.74 → 2026.5.76

package/dist/web-search-LuWKS3f2.js

@@ -0,0 +1,62 @@
+import { t as createBaseWebSearchProviderContractFields } from "./provider-web-search-contract-fields-DIG8SRmz.js";
+//#region extensions/xai/web-search.ts
+const XAI_CREDENTIAL_PATH = "plugins.entries.xai.config.webSearch.apiKey";
+let xaiWebSearchProviderRuntimePromise;
+function loadXaiWebSearchProviderRuntime() {
+	xaiWebSearchProviderRuntimePromise ??= import("./web-search-provider.runtime-CmbTFxDm.js");
+	return xaiWebSearchProviderRuntimePromise;
+}
+const GenericXaiSearchSchema = {
+	type: "object",
+	properties: {
+		query: {
+			type: "string",
+			description: "Search query string."
+		},
+		count: {
+			type: "number",
+			description: "Number of results to return (1-10).",
+			minimum: 1,
+			maximum: 10
+		}
+	},
+	additionalProperties: false
+};
+async function runXaiSearchProviderSetup(ctx) {
+	return await (await loadXaiWebSearchProviderRuntime()).runXaiSearchProviderSetup(ctx);
+}
+function createXaiWebSearchProvider() {
+	return {
+		id: "grok",
+		label: "Grok (xAI)",
+		hint: "Uses xAI OAuth or API key · xAI web-grounded responses",
+		onboardingScopes: ["text-inference"],
+		credentialLabel: "xAI API key",
+		envVars: ["XAI_API_KEY"],
+		authProviderId: "xai",
+		placeholder: "xai-...",
+		signupUrl: "https://console.x.ai/",
+		docsUrl: "https://daocore-ai.vercel.app",
+		autoDetectOrder: 30,
+		credentialPath: XAI_CREDENTIAL_PATH,
+		...createBaseWebSearchProviderContractFields({
+			credentialPath: XAI_CREDENTIAL_PATH,
+			searchCredential: {
+				type: "scoped",
+				scopeId: "grok"
+			},
+			configuredCredential: { pluginId: "xai" }
+		}),
+		runSetup: runXaiSearchProviderSetup,
+		createTool: (ctx) => ({
+			description: "Search the web using xAI Grok. Returns AI-synthesized answers with citations from real-time web search.",
+			parameters: GenericXaiSearchSchema,
+			execute: async (args) => {
+				const { executeXaiWebSearchProviderTool } = await loadXaiWebSearchProviderRuntime();
+				return await executeXaiWebSearchProviderTool(ctx, args);
+			}
+		})
+	};
+}
+//#endregion
+export { createXaiWebSearchProvider as t };

package/dist/web-search-provider.runtime-CmbTFxDm.js

@@ -0,0 +1,2 @@
+import { n as runXaiSearchProviderSetup, r as testing, t as executeXaiWebSearchProviderTool } from "./web-search-provider.runtime-DZXMqd4W.js";
+export { testing as __testing, testing, executeXaiWebSearchProviderTool, runXaiSearchProviderSetup };

package/dist/web-search-provider.runtime-DZXMqd4W.js

@@ -0,0 +1,328 @@
+import { t as formatCliCommand } from "./command-format-tWmMYcvZ.js";
+import { c as isRecord } from "./utils-CNnMhEDp.js";
+import { o as coerceSecretRef } from "./types.secrets-Ct1DNG7D.js";
+import { s as resolveDefaultAgentDir } from "./agent-scope-config-CJUQxn7u.js";
+import { n as ensureAuthProfileStore } from "./store-Ik30AbRk.js";
+import { f as readNumberParam, g as readStringParam } from "./common-vJyw6dD-.js";
+import { p as readProviderJsonObjectResponse } from "./provider-http-errors-CT7OJDS_.js";
+import { a as wrapWebContent } from "./external-content-BWPoz0BU.js";
+import { i as readCache, l as writeCache, o as resolveCacheTtlMs, r as normalizeCacheKey, s as resolveTimeoutSeconds } from "./web-shared-CYJpPo1M.js";
+import { u as postTrustedWebToolsJson } from "./web-search-provider-common-Dk-Y7yAj.js";
+import { a as listUsableProviderAuthProfileIds } from "./provider-auth-BcCl82SN.js";
+import "./agent-runtime-DDBYT9PU.js";
+import { o as resolveApiKeyForProvider } from "./provider-auth-runtime-BERb3HXh.js";
+import "./provider-http-2hRxmq57.js";
+import { i as resolveProviderWebSearchPluginConfig, r as mergeScopedSearchConfig, t as getScopedCredentialValue } from "./web-search-provider-config-CM5VNRaS.js";
+import { n as resolveWebSearchProviderCredential } from "./provider-web-search-B1lA2MA5.js";
+import { t as normalizeXaiModelId } from "./model-id-BRM_wbb3.js";
+import "./tool-config-shared-CMTrblqN.js";
+import { n as setPluginXSearchConfigValue, t as resolveEffectiveXSearchConfig } from "./x-search-config-C7u2Ot4b.js";
+import { a as requireXaiResponseTextCitationsAndInline, n as buildXaiResponsesToolBody, o as resolveXaiResponsesEndpoint, r as extractXaiWebSearchContent } from "./responses-tool-shared-Czzu3i8c.js";
+import { t as XAI_DEFAULT_X_SEARCH_MODEL } from "./x-search-shared-BEWq7FYk.js";
+//#region extensions/xai/src/web-search-shared.ts
+const XAI_DEFAULT_WEB_SEARCH_MODEL = "grok-4-1-fast";
+function buildXaiWebSearchPayload(params) {
+	return {
+		query: params.query,
+		provider: params.provider,
+		model: params.model,
+		tookMs: params.tookMs,
+		externalContent: {
+			untrusted: true,
+			source: "web_search",
+			provider: params.provider,
+			wrapped: true
+		},
+		content: wrapWebContent(params.content, "web_search"),
+		citations: params.citations,
+		...params.inlineCitations ? { inlineCitations: params.inlineCitations } : {}
+	};
+}
+function resolveXaiSearchConfig(searchConfig) {
+	return (isRecord(searchConfig?.grok) ? searchConfig.grok : void 0) ?? {};
+}
+function resolveXaiWebSearchModel(searchConfig) {
+	const config = resolveXaiSearchConfig(searchConfig);
+	return typeof config.model === "string" && config.model.trim() ? normalizeXaiModelId(config.model.trim()) : XAI_DEFAULT_WEB_SEARCH_MODEL;
+}
+function resolveXaiWebSearchEndpoint(searchConfig) {
+	return resolveXaiResponsesEndpoint(resolveXaiSearchConfig(searchConfig).baseUrl);
+}
+function resolveXaiInlineCitations(searchConfig) {
+	return resolveXaiSearchConfig(searchConfig).inlineCitations === true;
+}
+function isAbortError(error) {
+	return error instanceof Error && (error.name === "AbortError" || error.message === "This operation was aborted");
+}
+function wrapXaiWebSearchError(error, timeoutSeconds) {
+	if (isAbortError(error)) throw new Error(`xAI web search timed out after ${timeoutSeconds}s. Increase tools.web.search.timeoutSeconds if queries are complex.`, { cause: error });
+	throw error;
+}
+async function requestXaiWebSearch(params) {
+	return await postTrustedWebToolsJson({
+		url: params.endpoint,
+		timeoutSeconds: params.timeoutSeconds,
+		apiKey: params.apiKey,
+		body: buildXaiResponsesToolBody({
+			model: params.model,
+			inputText: params.query,
+			tools: [{ type: "web_search" }]
+		}),
+		errorLabel: "xAI"
+	}, async (response) => {
+		return requireXaiResponseTextCitationsAndInline(await readProviderJsonObjectResponse(response, "xAI web search failed"), "xAI web search failed", params.inlineCitations);
+	}).catch((error) => wrapXaiWebSearchError(error, params.timeoutSeconds));
+}
+//#endregion
+//#region extensions/xai/src/web-search-provider.runtime.ts
+const XAI_WEB_SEARCH_CACHE = /* @__PURE__ */ new Map();
+const XAI_WEB_SEARCH_DEFAULT_TIMEOUT_SECONDS = 60;
+const XAI_PROVIDER_ID = "xai";
+const X_SEARCH_MODEL_OPTIONS = [{
+	value: XAI_DEFAULT_X_SEARCH_MODEL,
+	label: XAI_DEFAULT_X_SEARCH_MODEL,
+	hint: "default · fast, no reasoning"
+}, {
+	value: "grok-4-1-fast",
+	label: "grok-4-1-fast",
+	hint: "fast with reasoning"
+}];
+function resolveXSearchConfigRecord(config) {
+	return resolveEffectiveXSearchConfig(config);
+}
+async function runXaiSearchProviderSetup(ctx) {
+	const existingXSearch = resolveXSearchConfigRecord(ctx.config);
+	if (existingXSearch?.enabled === false) return ctx.config;
+	await ctx.prompter.note([
+		"x_search lets your agent search X (formerly Twitter) posts via xAI.",
+		"It reuses the same xAI credential you configured for Grok web search.",
+		`You can change this later with ${formatCliCommand("daocore configure --section web")}.`
+	].join("\n"), "X search");
+	if (await ctx.prompter.select({
+		message: "Enable x_search too?",
+		options: [{
+			value: "yes",
+			label: "Yes, enable x_search",
+			hint: "Search X posts with the same xAI credential"
+		}, {
+			value: "skip",
+			label: "Skip for now",
+			hint: "Keep Grok web_search only"
+		}],
+		initialValue: existingXSearch?.enabled === true || ctx.quickstartDefaults ? "yes" : "skip"
+	}) === "skip") return ctx.config;
+	const existingModel = typeof existingXSearch?.model === "string" && existingXSearch.model.trim() ? existingXSearch.model.trim() : "";
+	const knownModel = X_SEARCH_MODEL_OPTIONS.find((entry) => entry.value === existingModel)?.value;
+	const modelPick = await ctx.prompter.select({
+		message: "Grok model for x_search",
+		options: [...X_SEARCH_MODEL_OPTIONS, {
+			value: "__custom__",
+			label: "Enter custom model name",
+			hint: ""
+		}],
+		initialValue: knownModel ?? "grok-4-1-fast-non-reasoning"
+	});
+	let model = modelPick;
+	if (modelPick === "__custom__") model = (await ctx.prompter.text({
+		message: "Custom Grok model name",
+		initialValue: existingModel || "grok-4-1-fast-non-reasoning",
+		placeholder: "grok-4-1-fast-non-reasoning"
+	})).trim() || "grok-4-1-fast-non-reasoning";
+	const next = structuredClone(ctx.config);
+	setPluginXSearchConfigValue(next, "enabled", true);
+	setPluginXSearchConfigValue(next, "model", model || "grok-4-1-fast-non-reasoning");
+	return next;
+}
+function runXaiWebSearch(params) {
+	const cacheKey = normalizeCacheKey(`grok:${params.endpoint}:${params.model}:${String(params.inlineCitations)}:${params.query}`);
+	const cached = readCache(XAI_WEB_SEARCH_CACHE, cacheKey);
+	if (cached) return Promise.resolve({
+		...cached.value,
+		cached: true
+	});
+	return (async () => {
+		const startedAt = Date.now();
+		const result = await requestXaiWebSearch({
+			query: params.query,
+			model: params.model,
+			apiKey: params.apiKey,
+			endpoint: params.endpoint,
+			timeoutSeconds: params.timeoutSeconds,
+			inlineCitations: params.inlineCitations
+		});
+		const payload = buildXaiWebSearchPayload({
+			query: params.query,
+			provider: "grok",
+			model: params.model,
+			tookMs: Date.now() - startedAt,
+			content: result.content,
+			citations: result.citations,
+			inlineCitations: result.inlineCitations
+		});
+		writeCache(XAI_WEB_SEARCH_CACHE, cacheKey, payload, params.cacheTtlMs);
+		return payload;
+	})();
+}
+function resolveXaiToolSearchConfig(ctx) {
+	return mergeScopedSearchConfig(ctx.searchConfig, "grok", resolveProviderWebSearchPluginConfig(ctx.config, "xai"));
+}
+function resolveXaiWebSearchCredential(searchConfig) {
+	return resolveWebSearchProviderCredential({
+		credentialValue: getScopedCredentialValue(searchConfig, "grok"),
+		path: "tools.web.search.grok.apiKey",
+		envVars: ["XAI_API_KEY"]
+	});
+}
+function resolveConfiguredXaiWebSearchCredential(searchConfig) {
+	return resolveWebSearchProviderCredential({
+		credentialValue: getScopedCredentialValue(searchConfig, "grok"),
+		path: "tools.web.search.grok.apiKey",
+		envVars: []
+	});
+}
+function hasConfiguredXaiWebSearchCredentialRef(searchConfig) {
+	return coerceSecretRef(getScopedCredentialValue(searchConfig, "grok")) !== null;
+}
+async function resolveXaiProviderAuthCredential(params) {
+	try {
+		const config = params.config;
+		const agentDir = params.agentDir?.trim() || (config ? resolveDefaultAgentDir(config) : void 0);
+		const resolved = await resolveApiKeyForProvider({
+			provider: XAI_PROVIDER_ID,
+			cfg: config,
+			...agentDir ? { agentDir } : {},
+			...params.profileId ? {
+				profileId: params.profileId,
+				lockedProfile: true
+			} : {},
+			...params.forceRefresh ? { forceRefresh: true } : {},
+			...params.credentialPrecedence ? { credentialPrecedence: params.credentialPrecedence } : {}
+		});
+		const apiKey = typeof resolved.apiKey === "string" ? resolved.apiKey.trim() : "";
+		if (!apiKey) return;
+		return {
+			apiKey,
+			mode: resolved.mode,
+			...resolved.profileId ? { profileId: resolved.profileId } : {}
+		};
+	} catch {
+		return;
+	}
+}
+async function resolveXaiProviderApiKeyProfileFallback(params) {
+	const config = params.config;
+	const usableProfiles = listUsableProviderAuthProfileIds({
+		agentDir: params.agentDir,
+		cfg: config,
+		provider: XAI_PROVIDER_ID
+	});
+	if (!usableProfiles.agentDir || usableProfiles.profileIds.length === 0) return;
+	const store = ensureAuthProfileStore(usableProfiles.agentDir, { allowKeychainPrompt: false });
+	for (const profileId of usableProfiles.profileIds) {
+		const profile = store.profiles[profileId];
+		if (!profile || profile.provider !== XAI_PROVIDER_ID || profile.type === "oauth") continue;
+		const resolved = await resolveXaiProviderAuthCredential({
+			agentDir: usableProfiles.agentDir,
+			config: params.config,
+			profileId
+		});
+		if (resolved?.apiKey && resolved.mode !== "oauth") return resolved;
+	}
+}
+async function resolveXaiWebSearchAuth(ctx, searchConfig, options) {
+	const providerAuth = await resolveXaiProviderAuthCredential({
+		agentDir: ctx.agentDir,
+		config: ctx.config,
+		forceRefresh: options?.forceRefresh,
+		profileId: options?.profileId
+	});
+	if (providerAuth?.mode === "oauth") return providerAuth;
+	const configured = resolveConfiguredXaiWebSearchCredential(searchConfig);
+	if (configured) return {
+		apiKey: configured,
+		mode: "api-key"
+	};
+	if (hasConfiguredXaiWebSearchCredentialRef(searchConfig)) return;
+	return providerAuth;
+}
+async function resolveXaiWebSearchApiKeyFallback(ctx, searchConfig) {
+	const configured = resolveConfiguredXaiWebSearchCredential(searchConfig);
+	if (configured) return {
+		apiKey: configured,
+		mode: "api-key"
+	};
+	if (hasConfiguredXaiWebSearchCredentialRef(searchConfig)) return;
+	const providerAuth = await resolveXaiProviderAuthCredential({
+		agentDir: ctx.agentDir,
+		config: ctx.config,
+		credentialPrecedence: "env-first"
+	});
+	if (providerAuth?.apiKey && providerAuth.mode !== "oauth") return providerAuth;
+	return await resolveXaiProviderApiKeyProfileFallback({
+		agentDir: ctx.agentDir,
+		config: ctx.config
+	});
+}
+function isXaiUnauthorizedError(error) {
+	return error instanceof Error && error.message.includes("xAI API error (401)");
+}
+function resolveXaiWebSearchTimeoutSeconds(searchConfig) {
+	return resolveTimeoutSeconds(searchConfig?.timeoutSeconds, XAI_WEB_SEARCH_DEFAULT_TIMEOUT_SECONDS);
+}
+async function executeXaiWebSearchProviderTool(ctx, args) {
+	const searchConfig = resolveXaiToolSearchConfig(ctx);
+	const auth = await resolveXaiWebSearchAuth(ctx, searchConfig);
+	if (!auth) return {
+		error: "missing_xai_api_key",
+		message: "web_search (grok) needs xAI credentials. Run `daocore onboard --auth-choice xai-oauth` to sign in with Grok, run `daocore onboard --auth-choice xai-api-key`, set `XAI_API_KEY` in the Gateway environment, or configure `plugins.entries.xai.config.webSearch.apiKey`. If you do not want to configure search credentials, use web_fetch for a specific URL or the browser tool for interactive pages.",
+		docs: "https://daocore-ai.vercel.app"
+	};
+	const query = readStringParam(args, "query", { required: true });
+	readNumberParam(args, "count", { integer: true });
+	const request = {
+		query,
+		model: resolveXaiWebSearchModel(searchConfig),
+		endpoint: resolveXaiWebSearchEndpoint(searchConfig),
+		timeoutSeconds: resolveXaiWebSearchTimeoutSeconds(searchConfig),
+		inlineCitations: resolveXaiInlineCitations(searchConfig),
+		cacheTtlMs: resolveCacheTtlMs(searchConfig?.cacheTtlMinutes, 15)
+	};
+	try {
+		return await runXaiWebSearch({
+			...request,
+			apiKey: auth.apiKey
+		});
+	} catch (error) {
+		if (!isXaiUnauthorizedError(error) || !auth.profileId) throw error;
+		if (auth.mode === "oauth") {
+			const refreshed = await resolveXaiWebSearchAuth(ctx, searchConfig, {
+				forceRefresh: true,
+				profileId: auth.profileId
+			});
+			if (refreshed?.apiKey && refreshed.apiKey !== auth.apiKey) return await runXaiWebSearch({
+				...request,
+				apiKey: refreshed.apiKey
+			});
+		}
+		const fallback = await resolveXaiWebSearchApiKeyFallback(ctx, searchConfig);
+		if (!fallback?.apiKey || fallback.apiKey === auth.apiKey) throw error;
+		return await runXaiWebSearch({
+			...request,
+			apiKey: fallback.apiKey
+		});
+	}
+}
+const testing = {
+	buildXaiWebSearchPayload,
+	extractXaiWebSearchContent,
+	resolveXaiToolSearchConfig,
+	resolveXaiWebSearchAuth,
+	resolveXaiInlineCitations,
+	resolveXaiWebSearchCredential,
+	resolveXaiWebSearchEndpoint,
+	resolveXaiWebSearchModel,
+	resolveXaiWebSearchTimeoutSeconds,
+	requestXaiWebSearch
+};
+//#endregion
+export { runXaiSearchProviderSetup as n, testing as r, executeXaiWebSearchProviderTool as t };

package/dist/web-search-provider.runtime.js

@@ -1 +1 @@
-export * from "./web-search-provider.runtime-Ckon24db.js";
+export * from "./web-search-provider.runtime-CmbTFxDm.js";

package/dist/webhook-targets-C9cJD_kB.d.ts

@@ -0,0 +1,99 @@
+import { n as registerPluginHttpRoute } from "./http-registry-D3Cdok5J.js";
+import { f as FixedWindowRateLimiter, i as WebhookInFlightLimiter } from "./webhook-request-guards-CQf6yUy9.js";
+import { IncomingMessage, ServerResponse } from "node:http";
+
+//#region src/plugin-sdk/webhook-targets.d.ts
+type RegisteredWebhookTarget<T> = {
+  target: T;
+  unregister: () => void;
+};
+type RegisterWebhookTargetOptions<T extends {
+  path: string;
+}> = {
+  onFirstPathTarget?: (params: {
+    path: string;
+    target: T;
+  }) => void | (() => void);
+  onLastPathTargetRemoved?: (params: {
+    path: string;
+  }) => void;
+};
+type RegisterPluginHttpRouteParams = Parameters<typeof registerPluginHttpRoute>[0];
+type RegisterWebhookPluginRouteOptions = Omit<RegisterPluginHttpRouteParams, "path" | "fallbackPath">;
+/** Register a webhook target and lazily install the matching plugin HTTP route on first use. */
+declare function registerWebhookTargetWithPluginRoute<T extends {
+  path: string;
+}>(params: {
+  targetsByPath: Map<string, T[]>;
+  target: T;
+  route: RegisterWebhookPluginRouteOptions;
+  onLastPathTargetRemoved?: RegisterWebhookTargetOptions<T>["onLastPathTargetRemoved"];
+}): RegisteredWebhookTarget<T>;
+/** Add a normalized target to a path bucket and clean up route state when the last target leaves. */
+declare function registerWebhookTarget<T extends {
+  path: string;
+}>(targetsByPath: Map<string, T[]>, target: T, opts?: RegisterWebhookTargetOptions<T>): RegisteredWebhookTarget<T>;
+/** Resolve all registered webhook targets for the incoming request path. */
+declare function resolveWebhookTargets<T>(req: IncomingMessage, targetsByPath: Map<string, T[]>): {
+  path: string;
+  targets: T[];
+} | null;
+/** Run common webhook guards, then dispatch only when the request path resolves to live targets. */
+declare function withResolvedWebhookRequestPipeline<T>(params: {
+  req: IncomingMessage;
+  res: ServerResponse;
+  targetsByPath: Map<string, T[]>;
+  allowMethods?: readonly string[];
+  rateLimiter?: FixedWindowRateLimiter;
+  rateLimitKey?: string;
+  nowMs?: number;
+  requireJsonContentType?: boolean;
+  inFlightLimiter?: WebhookInFlightLimiter;
+  inFlightKey?: string | ((args: {
+    req: IncomingMessage;
+    path: string;
+    targets: T[];
+  }) => string);
+  inFlightLimitStatusCode?: number;
+  inFlightLimitMessage?: string;
+  handle: (args: {
+    path: string;
+    targets: T[];
+  }) => Promise<boolean | void> | boolean | void;
+}): Promise<boolean>;
+type WebhookTargetMatchResult<T> = {
+  kind: "none";
+} | {
+  kind: "single";
+  target: T;
+} | {
+  kind: "ambiguous";
+};
+/** Match exactly one synchronous target or report whether resolution was empty or ambiguous. */
+declare function resolveSingleWebhookTarget<T>(targets: readonly T[], isMatch: (target: T) => boolean): WebhookTargetMatchResult<T>;
+/** Async variant of single-target resolution for auth checks that need I/O. */
+declare function resolveSingleWebhookTargetAsync<T>(targets: readonly T[], isMatch: (target: T) => Promise<boolean>): Promise<WebhookTargetMatchResult<T>>;
+/** Resolve an authorized target and send the standard unauthorized or ambiguous response on failure. */
+declare function resolveWebhookTargetWithAuthOrReject<T>(params: {
+  targets: readonly T[];
+  res: ServerResponse;
+  isMatch: (target: T) => boolean | Promise<boolean>;
+  unauthorizedStatusCode?: number;
+  unauthorizedMessage?: string;
+  ambiguousStatusCode?: number;
+  ambiguousMessage?: string;
+}): Promise<T | null>;
+/** Synchronous variant of webhook auth resolution for cheap in-memory match checks. */
+declare function resolveWebhookTargetWithAuthOrRejectSync<T>(params: {
+  targets: readonly T[];
+  res: ServerResponse;
+  isMatch: (target: T) => boolean;
+  unauthorizedStatusCode?: number;
+  unauthorizedMessage?: string;
+  ambiguousStatusCode?: number;
+  ambiguousMessage?: string;
+}): T | null;
+/** Reject non-POST webhook requests with the conventional Allow header. */
+declare function rejectNonPostWebhookRequest(req: IncomingMessage, res: ServerResponse): boolean;
+//#endregion
+export { registerWebhookTarget as a, resolveSingleWebhookTarget as c, resolveWebhookTargetWithAuthOrRejectSync as d, resolveWebhookTargets as f, WebhookTargetMatchResult as i, resolveSingleWebhookTargetAsync as l, RegisterWebhookTargetOptions as n, registerWebhookTargetWithPluginRoute as o, withResolvedWebhookRequestPipeline as p, RegisteredWebhookTarget as r, rejectNonPostWebhookRequest as s, RegisterWebhookPluginRouteOptions as t, resolveWebhookTargetWithAuthOrReject as u };