kaijibot 2026.8.21 → 2026.8.23

package/dist/text-runtime-asv4kIxS.js

@@ -1,313 +0,0 @@
-import { i as normalizeLowercaseStringOrEmpty } from "./string-coerce-xZwG7Dq8.js";
-import "./redact-DyEgYeWM.js";
-import "./logger-Bz3k34Xs.js";
-import "./utils-C8dt4mi-.js";
-import "./logger-DVwUvJjR.js";
-import "./safe-text-CZ-GyZdm.js";
-import "./diagnostic-BLwuJXPT.js";
-import { o as sliceMarkdownIR, r as chunkMarkdownIR } from "./tables-BGTNKk6h.js";
-//#region src/markdown/render-aware-chunking.ts
-function renderMarkdownIRChunksWithinLimit(options) {
-	if (!options.ir.text) return [];
-	const normalizedLimit = Math.max(1, Math.floor(options.limit));
-	const pending = chunkMarkdownIR(options.ir, normalizedLimit);
-	const finalized = [];
-	while (pending.length > 0) {
-		const chunk = pending.shift();
-		if (!chunk) continue;
-		const rendered = options.renderChunk(chunk);
-		if (options.measureRendered(rendered) <= normalizedLimit || chunk.text.length <= 1) {
-			finalized.push(chunk);
-			continue;
-		}
-		const split = splitMarkdownIRByRenderedLimit(chunk, normalizedLimit, options);
-		if (split.length <= 1) {
-			finalized.push(chunk);
-			continue;
-		}
-		pending.unshift(...split);
-	}
-	return coalesceWhitespaceOnlyMarkdownIRChunks(finalized, normalizedLimit, options).map((source) => ({
-		source,
-		rendered: options.renderChunk(source)
-	}));
-}
-function splitMarkdownIRByRenderedLimit(chunk, renderedLimit, options) {
-	const currentTextLength = chunk.text.length;
-	if (currentTextLength <= 1) return [chunk];
-	const splitLimit = findLargestChunkTextLengthWithinRenderedLimit(chunk, renderedLimit, options);
-	if (splitLimit <= 0) return [chunk];
-	const split = splitMarkdownIRPreserveWhitespace(chunk, splitLimit);
-	const firstChunk = split[0];
-	if (firstChunk && options.measureRendered(options.renderChunk(firstChunk)) <= renderedLimit) return split;
-	return [sliceMarkdownIR(chunk, 0, splitLimit), sliceMarkdownIR(chunk, splitLimit, currentTextLength)];
-}
-function findLargestChunkTextLengthWithinRenderedLimit(chunk, renderedLimit, options) {
-	const currentTextLength = chunk.text.length;
-	if (currentTextLength <= 1) return currentTextLength;
-	for (let candidateLength = currentTextLength - 1; candidateLength >= 1; candidateLength -= 1) {
-		const candidate = sliceMarkdownIR(chunk, 0, candidateLength);
-		const rendered = options.renderChunk(candidate);
-		if (options.measureRendered(rendered) <= renderedLimit) return candidateLength;
-	}
-	return 0;
-}
-function findMarkdownIRPreservedSplitIndex(text, start, limit) {
-	const maxEnd = Math.min(text.length, start + limit);
-	if (maxEnd >= text.length) return text.length;
-	let lastOutsideParenNewlineBreak = -1;
-	let lastOutsideParenWhitespaceBreak = -1;
-	let lastOutsideParenWhitespaceRunStart = -1;
-	let lastAnyNewlineBreak = -1;
-	let lastAnyWhitespaceBreak = -1;
-	let lastAnyWhitespaceRunStart = -1;
-	let parenDepth = 0;
-	let sawNonWhitespace = false;
-	for (let index = start; index < maxEnd; index += 1) {
-		const char = text[index];
-		if (char === "(") {
-			sawNonWhitespace = true;
-			parenDepth += 1;
-			continue;
-		}
-		if (char === ")" && parenDepth > 0) {
-			sawNonWhitespace = true;
-			parenDepth -= 1;
-			continue;
-		}
-		if (!/\s/.test(char)) {
-			sawNonWhitespace = true;
-			continue;
-		}
-		if (!sawNonWhitespace) continue;
-		if (char === "\n") {
-			lastAnyNewlineBreak = index + 1;
-			if (parenDepth === 0) lastOutsideParenNewlineBreak = index + 1;
-			continue;
-		}
-		const whitespaceRunStart = index === start || !/\s/.test(text[index - 1] ?? "") ? index : lastAnyWhitespaceRunStart;
-		lastAnyWhitespaceBreak = index + 1;
-		lastAnyWhitespaceRunStart = whitespaceRunStart;
-		if (parenDepth === 0) {
-			lastOutsideParenWhitespaceBreak = index + 1;
-			lastOutsideParenWhitespaceRunStart = whitespaceRunStart;
-		}
-	}
-	const resolveWhitespaceBreak = (breakIndex, runStart) => {
-		if (breakIndex <= start) return breakIndex;
-		if (runStart <= start) return breakIndex;
-		return /\s/.test(text[breakIndex] ?? "") ? runStart : breakIndex;
-	};
-	if (lastOutsideParenNewlineBreak > start) return lastOutsideParenNewlineBreak;
-	if (lastOutsideParenWhitespaceBreak > start) return resolveWhitespaceBreak(lastOutsideParenWhitespaceBreak, lastOutsideParenWhitespaceRunStart);
-	if (lastAnyNewlineBreak > start) return lastAnyNewlineBreak;
-	if (lastAnyWhitespaceBreak > start) return resolveWhitespaceBreak(lastAnyWhitespaceBreak, lastAnyWhitespaceRunStart);
-	return maxEnd;
-}
-function splitMarkdownIRPreserveWhitespace(ir, limit) {
-	if (!ir.text) return [];
-	const normalizedLimit = Math.max(1, Math.floor(limit));
-	if (normalizedLimit <= 0 || ir.text.length <= normalizedLimit) return [ir];
-	const chunks = [];
-	let cursor = 0;
-	while (cursor < ir.text.length) {
-		const end = findMarkdownIRPreservedSplitIndex(ir.text, cursor, normalizedLimit);
-		chunks.push(sliceMarkdownIR(ir, cursor, end));
-		cursor = end;
-	}
-	return chunks;
-}
-function mergeAdjacentStyleSpans(styles) {
-	const merged = [];
-	for (const span of styles) {
-		const last = merged.at(-1);
-		if (last && last.style === span.style && span.start <= last.end) {
-			last.end = Math.max(last.end, span.end);
-			continue;
-		}
-		merged.push({ ...span });
-	}
-	return merged;
-}
-function mergeAdjacentLinkSpans(links) {
-	const merged = [];
-	for (const link of links) {
-		const last = merged.at(-1);
-		if (last && last.href === link.href && link.start <= last.end) {
-			last.end = Math.max(last.end, link.end);
-			continue;
-		}
-		merged.push({ ...link });
-	}
-	return merged;
-}
-function mergeMarkdownIRChunks(left, right) {
-	const offset = left.text.length;
-	return {
-		text: left.text + right.text,
-		styles: mergeAdjacentStyleSpans([...left.styles, ...right.styles.map((span) => ({
-			...span,
-			start: span.start + offset,
-			end: span.end + offset
-		}))]),
-		links: mergeAdjacentLinkSpans([...left.links, ...right.links.map((link) => ({
-			...link,
-			start: link.start + offset,
-			end: link.end + offset
-		}))])
-	};
-}
-function coalesceWhitespaceOnlyMarkdownIRChunks(chunks, renderedLimit, options) {
-	const coalesced = [];
-	let index = 0;
-	while (index < chunks.length) {
-		const chunk = chunks[index];
-		if (!chunk) {
-			index += 1;
-			continue;
-		}
-		if (chunk.text.trim().length > 0) {
-			coalesced.push(chunk);
-			index += 1;
-			continue;
-		}
-		const prev = coalesced.at(-1);
-		const next = chunks[index + 1];
-		const chunkLength = chunk.text.length;
-		const canMerge = (candidate) => options.measureRendered(options.renderChunk(candidate)) <= renderedLimit;
-		if (prev) {
-			const mergedPrev = mergeMarkdownIRChunks(prev, chunk);
-			if (canMerge(mergedPrev)) {
-				coalesced[coalesced.length - 1] = mergedPrev;
-				index += 1;
-				continue;
-			}
-		}
-		if (next) {
-			const mergedNext = mergeMarkdownIRChunks(chunk, next);
-			if (canMerge(mergedNext)) {
-				chunks[index + 1] = mergedNext;
-				index += 1;
-				continue;
-			}
-		}
-		if (prev && next) for (let prefixLength = chunkLength - 1; prefixLength >= 1; prefixLength -= 1) {
-			const prefix = sliceMarkdownIR(chunk, 0, prefixLength);
-			const suffix = sliceMarkdownIR(chunk, prefixLength, chunkLength);
-			const mergedPrev = mergeMarkdownIRChunks(prev, prefix);
-			const mergedNext = mergeMarkdownIRChunks(suffix, next);
-			if (canMerge(mergedPrev) && canMerge(mergedNext)) {
-				coalesced[coalesced.length - 1] = mergedPrev;
-				chunks[index + 1] = mergedNext;
-				break;
-			}
-		}
-		index += 1;
-	}
-	return coalesced;
-}
-const FILE_REF_EXTENSIONS_WITH_TLD = new Set([
-	"md",
-	"go",
-	"py",
-	"pl",
-	"sh",
-	"am",
-	"at",
-	"be",
-	"cc"
-]);
-function isAutoLinkedFileRef(href, label) {
-	if (href.replace(/^https?:\/\//i, "") !== label) return false;
-	const dotIndex = label.lastIndexOf(".");
-	if (dotIndex < 1) return false;
-	const ext = normalizeLowercaseStringOrEmpty(label.slice(dotIndex + 1));
-	if (!FILE_REF_EXTENSIONS_WITH_TLD.has(ext)) return false;
-	const segments = label.split("/");
-	if (segments.length > 1) {
-		for (let i = 0; i < segments.length - 1; i += 1) if (segments[i]?.includes(".")) return false;
-	}
-	return true;
-}
-//#endregion
-//#region src/shared/text/strip-markdown.ts
-/**
-* Strip lightweight markdown formatting from text while preserving readable
-* plain-text structure for TTS and channel fallbacks.
-*/
-function stripMarkdown(text) {
-	let result = text;
-	result = result.replace(/\*\*(.+?)\*\*/g, "$1");
-	result = result.replace(/__(.+?)__/g, "$1");
-	result = result.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "$1");
-	result = result.replace(/(?<![\p{L}\p{N}])_(?!_)(.+?)(?<!_)_(?![\p{L}\p{N}])/gu, "$1");
-	result = result.replace(/~~(.+?)~~/g, "$1");
-	result = result.replace(/^#{1,6}\s+(.+)$/gm, "$1");
-	result = result.replace(/^>\s?(.*)$/gm, "$1");
-	result = result.replace(/^[-*_]{3,}$/gm, "");
-	result = result.replace(/`([^`]+)`/g, "$1");
-	result = result.replace(/\n{3,}/g, "\n\n");
-	return result.trim();
-}
-//#endregion
-//#region src/utils/chunk-items.ts
-function chunkItems(items, size) {
-	if (size <= 0) return [Array.from(items)];
-	const rows = [];
-	for (let i = 0; i < items.length; i += size) rows.push(items.slice(i, i + size));
-	return rows;
-}
-//#endregion
-//#region src/utils/reaction-level.ts
-const LEVELS = new Set([
-	"off",
-	"ack",
-	"minimal",
-	"extensive"
-]);
-function parseLevel(value) {
-	if (value === void 0 || value === null) return { kind: "missing" };
-	if (typeof value !== "string") return { kind: "invalid" };
-	const trimmed = value.trim();
-	if (!trimmed) return { kind: "missing" };
-	if (LEVELS.has(trimmed)) return {
-		kind: "ok",
-		value: trimmed
-	};
-	return { kind: "invalid" };
-}
-function resolveReactionLevel(params) {
-	const parsed = parseLevel(params.value);
-	switch (parsed.kind === "ok" ? parsed.value : parsed.kind === "missing" ? params.defaultLevel : params.invalidFallback) {
-		case "off": return {
-			level: "off",
-			ackEnabled: false,
-			agentReactionsEnabled: false
-		};
-		case "ack": return {
-			level: "ack",
-			ackEnabled: true,
-			agentReactionsEnabled: false
-		};
-		case "minimal": return {
-			level: "minimal",
-			ackEnabled: false,
-			agentReactionsEnabled: true,
-			agentReactionGuidance: "minimal"
-		};
-		case "extensive": return {
-			level: "extensive",
-			ackEnabled: false,
-			agentReactionsEnabled: true,
-			agentReactionGuidance: "extensive"
-		};
-		default: return {
-			level: "minimal",
-			ackEnabled: false,
-			agentReactionsEnabled: true,
-			agentReactionGuidance: "minimal"
-		};
-	}
-}
-//#endregion
-export { isAutoLinkedFileRef as a, FILE_REF_EXTENSIONS_WITH_TLD as i, chunkItems as n, renderMarkdownIRChunksWithinLimit as o, stripMarkdown as r, resolveReactionLevel as t };

package/dist/thread-bindings-BCRWofo_.js

@@ -1,223 +0,0 @@
-import { s as normalizeOptionalString } from "./string-coerce-xZwG7Dq8.js";
-import { n as normalizeAccountId } from "./account-id-QKaaEf0c.js";
-import { u as resolveAgentIdFromSessionKey } from "./session-key-Dny5dRer.js";
-import { a as registerSessionBindingAdapter, o as unregisterSessionBindingAdapter } from "./session-binding-service-BdDm07I2.js";
-import { l as resolveThreadBindingMaxAgeMsForChannel, o as resolveThreadBindingIdleTimeoutMsForChannel } from "./thread-bindings-policy-eUVk8lQk.js";
-import "./routing-BDKVP1lm.js";
-import "./conversation-runtime-D-YmpVS2.js";
-import { t as resolveThreadBindingConversationIdFromBindingId } from "./thread-binding-id-Mpyi3xy-.js";
-import "./text-runtime-asv4kIxS.js";
-//#region extensions/feishu/src/thread-bindings.ts
-const FEISHU_THREAD_BINDINGS_STATE_KEY = Symbol.for("kaijibot.feishuThreadBindingsState");
-let state;
-function getState() {
-	if (!state) {
-		const globalStore = globalThis;
-		state = globalStore[FEISHU_THREAD_BINDINGS_STATE_KEY] ?? {
-			managersByAccountId: /* @__PURE__ */ new Map(),
-			bindingsByAccountConversation: /* @__PURE__ */ new Map()
-		};
-		globalStore[FEISHU_THREAD_BINDINGS_STATE_KEY] = state;
-	}
-	return state;
-}
-function resolveBindingKey(params) {
-	return `${params.accountId}:${params.conversationId}`;
-}
-function toSessionBindingTargetKind(raw) {
-	return raw === "subagent" ? "subagent" : "session";
-}
-function toFeishuTargetKind(raw) {
-	return raw === "subagent" ? "subagent" : "acp";
-}
-function toSessionBindingRecord(record, defaults) {
-	const idleExpiresAt = defaults.idleTimeoutMs > 0 ? record.lastActivityAt + defaults.idleTimeoutMs : void 0;
-	const maxAgeExpiresAt = defaults.maxAgeMs > 0 ? record.boundAt + defaults.maxAgeMs : void 0;
-	const expiresAt = idleExpiresAt != null && maxAgeExpiresAt != null ? Math.min(idleExpiresAt, maxAgeExpiresAt) : idleExpiresAt ?? maxAgeExpiresAt;
-	return {
-		bindingId: resolveBindingKey({
-			accountId: record.accountId,
-			conversationId: record.conversationId
-		}),
-		targetSessionKey: record.targetSessionKey,
-		targetKind: toSessionBindingTargetKind(record.targetKind),
-		conversation: {
-			channel: "feishu",
-			accountId: record.accountId,
-			conversationId: record.conversationId,
-			parentConversationId: record.parentConversationId
-		},
-		status: "active",
-		boundAt: record.boundAt,
-		expiresAt,
-		metadata: {
-			agentId: record.agentId,
-			label: record.label,
-			boundBy: record.boundBy,
-			deliveryTo: record.deliveryTo,
-			deliveryThreadId: record.deliveryThreadId,
-			lastActivityAt: record.lastActivityAt,
-			idleTimeoutMs: defaults.idleTimeoutMs,
-			maxAgeMs: defaults.maxAgeMs
-		}
-	};
-}
-function createFeishuThreadBindingManager(params) {
-	const accountId = normalizeAccountId(params.accountId);
-	const existing = getState().managersByAccountId.get(accountId);
-	if (existing) return existing;
-	const idleTimeoutMs = resolveThreadBindingIdleTimeoutMsForChannel({
-		cfg: params.cfg,
-		channel: "feishu",
-		accountId
-	});
-	const maxAgeMs = resolveThreadBindingMaxAgeMsForChannel({
-		cfg: params.cfg,
-		channel: "feishu",
-		accountId
-	});
-	const manager = {
-		accountId,
-		getByConversationId: (conversationId) => getState().bindingsByAccountConversation.get(resolveBindingKey({
-			accountId,
-			conversationId
-		})),
-		listBySessionKey: (targetSessionKey) => [...getState().bindingsByAccountConversation.values()].filter((record) => record.accountId === accountId && record.targetSessionKey === targetSessionKey),
-		bindConversation: ({ conversationId, parentConversationId, targetKind, targetSessionKey, metadata }) => {
-			const normalizedConversationId = conversationId.trim();
-			if (!normalizedConversationId || !targetSessionKey.trim()) return null;
-			const now = Date.now();
-			const record = {
-				accountId,
-				conversationId: normalizedConversationId,
-				parentConversationId: normalizeOptionalString(parentConversationId),
-				deliveryTo: typeof metadata?.deliveryTo === "string" && metadata.deliveryTo.trim() ? metadata.deliveryTo.trim() : void 0,
-				deliveryThreadId: typeof metadata?.deliveryThreadId === "string" && metadata.deliveryThreadId.trim() ? metadata.deliveryThreadId.trim() : void 0,
-				targetKind: toFeishuTargetKind(targetKind),
-				targetSessionKey: targetSessionKey.trim(),
-				agentId: typeof metadata?.agentId === "string" && metadata.agentId.trim() ? metadata.agentId.trim() : resolveAgentIdFromSessionKey(targetSessionKey),
-				label: typeof metadata?.label === "string" && metadata.label.trim() ? metadata.label.trim() : void 0,
-				boundBy: typeof metadata?.boundBy === "string" && metadata.boundBy.trim() ? metadata.boundBy.trim() : void 0,
-				boundAt: now,
-				lastActivityAt: now
-			};
-			getState().bindingsByAccountConversation.set(resolveBindingKey({
-				accountId,
-				conversationId: normalizedConversationId
-			}), record);
-			return record;
-		},
-		touchConversation: (conversationId, at = Date.now()) => {
-			const key = resolveBindingKey({
-				accountId,
-				conversationId
-			});
-			const existingRecord = getState().bindingsByAccountConversation.get(key);
-			if (!existingRecord) return null;
-			const updated = {
-				...existingRecord,
-				lastActivityAt: at
-			};
-			getState().bindingsByAccountConversation.set(key, updated);
-			return updated;
-		},
-		unbindConversation: (conversationId) => {
-			const key = resolveBindingKey({
-				accountId,
-				conversationId
-			});
-			const existingRecord = getState().bindingsByAccountConversation.get(key);
-			if (!existingRecord) return null;
-			getState().bindingsByAccountConversation.delete(key);
-			return existingRecord;
-		},
-		unbindBySessionKey: (targetSessionKey) => {
-			const removed = [];
-			for (const record of getState().bindingsByAccountConversation.values()) {
-				if (record.accountId !== accountId || record.targetSessionKey !== targetSessionKey) continue;
-				getState().bindingsByAccountConversation.delete(resolveBindingKey({
-					accountId,
-					conversationId: record.conversationId
-				}));
-				removed.push(record);
-			}
-			return removed;
-		},
-		stop: () => {
-			for (const key of getState().bindingsByAccountConversation.keys()) if (key.startsWith(`${accountId}:`)) getState().bindingsByAccountConversation.delete(key);
-			getState().managersByAccountId.delete(accountId);
-			unregisterSessionBindingAdapter({
-				channel: "feishu",
-				accountId,
-				adapter: sessionBindingAdapter
-			});
-		}
-	};
-	const sessionBindingAdapter = {
-		channel: "feishu",
-		accountId,
-		capabilities: { placements: ["current"] },
-		bind: async (input) => {
-			if (input.conversation.channel !== "feishu" || input.placement === "child") return null;
-			const bound = manager.bindConversation({
-				conversationId: input.conversation.conversationId,
-				parentConversationId: input.conversation.parentConversationId,
-				targetKind: input.targetKind,
-				targetSessionKey: input.targetSessionKey,
-				metadata: input.metadata
-			});
-			return bound ? toSessionBindingRecord(bound, {
-				idleTimeoutMs,
-				maxAgeMs
-			}) : null;
-		},
-		listBySession: (targetSessionKey) => manager.listBySessionKey(targetSessionKey).map((entry) => toSessionBindingRecord(entry, {
-			idleTimeoutMs,
-			maxAgeMs
-		})),
-		resolveByConversation: (ref) => {
-			if (ref.channel !== "feishu") return null;
-			const found = manager.getByConversationId(ref.conversationId);
-			return found ? toSessionBindingRecord(found, {
-				idleTimeoutMs,
-				maxAgeMs
-			}) : null;
-		},
-		touch: (bindingId, at) => {
-			const conversationId = resolveThreadBindingConversationIdFromBindingId({
-				accountId,
-				bindingId
-			});
-			if (conversationId) manager.touchConversation(conversationId, at);
-		},
-		unbind: async (input) => {
-			if (input.targetSessionKey?.trim()) return manager.unbindBySessionKey(input.targetSessionKey.trim()).map((entry) => toSessionBindingRecord(entry, {
-				idleTimeoutMs,
-				maxAgeMs
-			}));
-			const conversationId = resolveThreadBindingConversationIdFromBindingId({
-				accountId,
-				bindingId: input.bindingId
-			});
-			if (!conversationId) return [];
-			const removed = manager.unbindConversation(conversationId);
-			return removed ? [toSessionBindingRecord(removed, {
-				idleTimeoutMs,
-				maxAgeMs
-			})] : [];
-		}
-	};
-	registerSessionBindingAdapter(sessionBindingAdapter);
-	getState().managersByAccountId.set(accountId, manager);
-	return manager;
-}
-function getFeishuThreadBindingManager(accountId) {
-	return getState().managersByAccountId.get(normalizeAccountId(accountId)) ?? null;
-}
-const __testing = { resetFeishuThreadBindingsForTests() {
-	for (const manager of getState().managersByAccountId.values()) manager.stop();
-	getState().managersByAccountId.clear();
-	getState().bindingsByAccountConversation.clear();
-} };
-//#endregion
-export { createFeishuThreadBindingManager as n, getFeishuThreadBindingManager as r, __testing as t };

package/dist/tool-auth-shared-BWZwTobX.js

@@ -1,53 +0,0 @@
-import { i as coerceSecretRef, l as normalizeSecretInputString } from "./types.secrets-i3-0qtd4.js";
-import { m as resolveNonEnvSecretRefApiKeyMarker } from "./model-auth-markers-BR92KCie.js";
-import { f as readConfiguredSecretString, p as readProviderEnvValue } from "./web-search-provider-common-B9jozd8T.js";
-import "./secret-input-3Eg4v2Lp.js";
-import "./provider-auth-DwgUXcgu.js";
-import { i as resolveProviderWebSearchPluginConfig } from "./web-search-provider-config-DCqeS6ct.js";
-import "./provider-web-search-CyGNmODH.js";
-//#region extensions/xai/src/tool-auth-shared.ts
-function readConfiguredOrManagedApiKey(value) {
-	const literal = normalizeSecretInputString(value);
-	if (literal) return literal;
-	const ref = coerceSecretRef(value);
-	return ref ? resolveNonEnvSecretRefApiKeyMarker(ref.source) : void 0;
-}
-function readLegacyGrokFallbackAuth(cfg) {
-	const search = cfg?.tools?.web?.search;
-	if (!search || typeof search !== "object") return;
-	const grok = search.grok;
-	const apiKey = readConfiguredOrManagedApiKey(grok && typeof grok === "object" ? grok.apiKey : void 0);
-	return apiKey ? {
-		apiKey,
-		source: "tools.web.search.grok.apiKey"
-	} : void 0;
-}
-function readLegacyGrokApiKey(cfg) {
-	const search = cfg?.tools?.web?.search;
-	if (!search || typeof search !== "object") return;
-	const grok = search.grok;
-	return readConfiguredSecretString(grok && typeof grok === "object" ? grok.apiKey : void 0, "tools.web.search.grok.apiKey");
-}
-function readPluginXaiWebSearchApiKey(cfg) {
-	return readConfiguredSecretString(resolveProviderWebSearchPluginConfig(cfg, "xai")?.apiKey, "plugins.entries.xai.config.webSearch.apiKey");
-}
-function resolveFallbackXaiAuth(cfg) {
-	const pluginApiKey = readConfiguredOrManagedApiKey(resolveProviderWebSearchPluginConfig(cfg, "xai")?.apiKey);
-	if (pluginApiKey) return {
-		apiKey: pluginApiKey,
-		source: "plugins.entries.xai.config.webSearch.apiKey"
-	};
-	return readLegacyGrokFallbackAuth(cfg);
-}
-function resolveFallbackXaiApiKey(cfg) {
-	return readPluginXaiWebSearchApiKey(cfg) ?? readLegacyGrokApiKey(cfg);
-}
-function resolveXaiToolApiKey(params) {
-	return resolveFallbackXaiApiKey(params.runtimeConfig) ?? resolveFallbackXaiApiKey(params.sourceConfig) ?? readProviderEnvValue(["XAI_API_KEY"]);
-}
-function isXaiToolEnabled(params) {
-	if (params.enabled === false) return false;
-	return Boolean(resolveXaiToolApiKey(params));
-}
-//#endregion
-export { resolveFallbackXaiAuth as n, resolveXaiToolApiKey as r, isXaiToolEnabled as t };

package/dist/tool-config-shared-BleK697I.js

@@ -1,19 +0,0 @@
-import { l as isRecord } from "./utils-C8dt4mi-.js";
-import "./text-runtime-asv4kIxS.js";
-import { t as normalizeXaiModelId } from "./model-id-josvS7_f.js";
-//#region extensions/xai/src/tool-config-shared.ts
-function coerceXaiToolConfig(config) {
-	return isRecord(config) ? config : {};
-}
-function resolveNormalizedXaiToolModel(params) {
-	const value = coerceXaiToolConfig(params.config).model;
-	return typeof value === "string" && value.trim() ? normalizeXaiModelId(value.trim()) : params.defaultModel;
-}
-function resolvePositiveIntegerToolConfig(config, key) {
-	const raw = coerceXaiToolConfig(config)[key];
-	if (typeof raw !== "number" || !Number.isFinite(raw)) return;
-	const normalized = Math.trunc(raw);
-	return normalized > 0 ? normalized : void 0;
-}
-//#endregion
-export { resolveNormalizedXaiToolModel as n, resolvePositiveIntegerToolConfig as r, coerceXaiToolConfig as t };