@od-oneapp/ai-platform 0.1.0

package/dist/tools.mjs

@@ -0,0 +1,1921 @@
+import { t as __exportAll } from "./chunk-CkzbjWQW.mjs";
+import { $ as generateObject, Ft as tool, et as generateText } from "./ai-runtime-CDzQztTt.mjs";
+import { a as createTimeoutAbort, c as createToolFactory, d as wrapToolHandler, i as combineAbortSignals, l as createToolWithContext, n as executeWithFallback, o as isAbortError, r as ToolAbortError, s as withAbortHandling, t as executeToolSafely, u as createTools } from "./tool-safety-DXtYDXod.mjs";
+import { createBashTool, createComputerTool } from "./tools-computer.mjs";
+import { _ as MCPErrorUtils, a as MCPHealthStatus, c as MCPTransportError, d as createMCPToolsFromConfigs, f as createTransportFromConfig, g as MCPErrorHandlerFactory, h as AISDKCompatibleMCPError, i as MCPHealthMonitor, m as withRetryAndTimeout, n as DEFAULT_RETRY_CONFIG, o as MCPRequestManager, p as globalMCPHealthMonitor, r as MCPConnectionError, s as MCPRetryableError, t as DEFAULT_HEALTH_CHECK_CONFIG, u as createMCPToolsForRequest } from "./client-CpacYDIE.mjs";
+import { C as testMCPConnectivity, D as createMCPStreamLifecycleManager, E as StreamLifecyclePhase, S as createMCPToolsWithStreamLifecycle, T as MCPStreamLifecycleManager, _ as MCPConnectionManager, a as createEdgeMCPTools, b as createMCPToolsForStreamText, c as edgeMCPTransports, d as DEFAULT_POOL_CONFIG, f as MCPConnectionPool, g as globalMCPToolCache, h as MCPToolCache, i as selectTransportForUseCase, l as getEdgeCompatibleConfigs, m as DEFAULT_CACHE_CONFIG, n as globalTransportSelector, o as createSmartMCPTools, p as globalMCPConnectionPool, r as selectOptimalTransport, s as discoverEdgeMCPServers, t as MCPTransportSelector, u as isEdgeRuntime, v as createPooledMCPTools, w as DEFAULT_STREAM_LIFECYCLE_CONFIG, x as createMCPToolsWithDefaults, y as getGlobalConnectionManager } from "./transport-selector-D-Ib05X1.mjs";
+import { a as mcpTransports, i as validateMCPEnvironment, r as getMCPServers, t as discoverMCPServersFromEnvironment } from "./environment-CSoJb0SW.mjs";
+import { $ as AgentDispatchOutputSchema, A as writeSkill, B as FINISHING_BRANCH_SYSTEM_PROMPT, C as runSubagentDev, D as testSkill, E as systematicDebug, F as CONDITION_BASED_WAITING_SYSTEM_PROMPT, G as SHARING_SKILLS_SYSTEM_PROMPT, H as PLANNER_SYSTEM_PROMPT, I as DEFENSE_IN_DEPTH_SYSTEM_PROMPT, J as TDD_SYSTEM_PROMPT, K as SUBAGENT_DRIVEN_DEV_SYSTEM_PROMPT, L as DESIGN_REVIEW_SYSTEM_PROMPT, M as BRAINSTORM_SYSTEM_PROMPT, N as CODE_REVIEW_SYSTEM_PROMPT, O as traceRootCause, P as COMMIT_ANALYSIS_SYSTEM_PROMPT, Q as systemPrompts, R as DISPATCHING_AGENTS_SYSTEM_PROMPT, S as reviewDesign, T as shareSkill, U as RECEIVING_CODE_REVIEW_SYSTEM_PROMPT, V as GIT_WORKTREE_SYSTEM_PROMPT, W as ROOT_CAUSE_TRACING_SYSTEM_PROMPT, X as USING_SUPERPOWERS_SYSTEM_PROMPT, Y as TESTING_SKILLS_SYSTEM_PROMPT, Z as WRITING_SKILLS_SYSTEM_PROMPT, _ as planningTools, _t as SystematicDebuggingOutputSchema, a as codeReviewTools, at as CodeReviewResponseOutputSchema, b as refineRequirements, c as detectAntiPatterns, ct as DesignReviewOutputSchema, d as finishBranch, dt as RootCauseTracingOutputSchema, et as AntiPatternOutputSchema, f as gitTools, ft as SkillShareOutputSchema, g as metaTools, gt as SuperpowersIntroOutputSchema, h as manageWorktree, ht as SubagentDevOutputSchema, i as analyzeDefenseInDepth, it as CodeReviewOutputSchema, j as ANTI_PATTERN_SYSTEM_PROMPT, k as workflowTools, l as dispatchAgents, lt as PlanExecutionOutputSchema, m as introduceSuperpowers, mt as SkillWriteOutputSchema, n as analyzeAsyncPatterns, nt as BrainstormOutputSchema, o as consultArchitect, ot as CommitAnalysisOutputSchema, p as initSuperpowers, pt as SkillTestOutputSchema, q as SYSTEMATIC_DEBUGGING_SYSTEM_PROMPT, r as analyzeCommit, rt as BranchFinishOutputSchema, s as debuggingTools, st as DefenseInDepthOutputSchema, t as allSuperpowerTools, tt as AsyncPatternsOutputSchema, u as executePlan, ut as PlanOutputSchema, v as processCodeReview, vt as TDDOutputSchema, w as runTDDCycle, x as reviewCode, y as qualityTools, yt as WorktreeOutputSchema, z as EXECUTING_PLANS_SYSTEM_PROMPT } from "./tools-BuS2Uv0q.mjs";
+import { z } from "zod";
+import { z as z$1 } from "zod/v4";
+import { existsSync, promises } from "node:fs";
+import path from "node:path";
+import "server-only";
+
+//#region src/tools/simple-factory.ts
+/**
+* @fileoverview Simple Tool Factory
+*
+* Utilities for creating tools with pre-built Zod schemas.
+* For JSON-to-Zod schema conversion, use {@link createJsonSchemaTool} from `tools/generic/json-schema-tool`.
+*
+* @module @od-oneapp/ai-platform/tools/simple-factory
+*/
+/**
+* Creates a tool from a pre-built Zod schema.
+*
+* For creating tools from JSON-style schema definitions,
+* use {@link createJsonSchemaTool} from `tools/generic/json-schema-tool`.
+*
+* @param description - Tool description.
+* @param schema - Zod schema instance.
+* @param execute - Execution function.
+*
+* @example
+* ```ts
+* const searchTool = createToolFromZodSchema(
+*   'Search the web for information',
+*   z.object({ query: z.string() }),
+*   async ({ query }) => fetch(`/search?q=${query}`)
+* );
+* ```
+*/
+function createToolFromZodSchema(description, schema, execute) {
+	return tool({
+		description,
+		inputSchema: schema,
+		execute
+	});
+}
+/**
+* @deprecated Use `createToolFromZodSchema` instead.
+* This alias exists for backward compatibility.
+*/
+const createSimpleTool = createToolFromZodSchema;
+
+//#endregion
+//#region src/tools/validation-wrapper.ts
+/**
+* Wraps a tool with an additional runtime validation step.
+*
+* Vercel AI SDK v6 tools already validate input against Zod schemas.
+* Use this wrapper when you need custom business-rule validation
+* (e.g., authorization checks, rate limiting, cross-field constraints)
+* that runs before the tool's execute function.
+*
+* @param t - The tool to wrap
+* @param options - Validation options
+* @param options.validate - Custom validator returning true/false (sync or async)
+* @returns A new tool that validates input before executing
+*
+* @example
+* ```ts
+* const safeTool = withValidation(deleteTool, {
+*   validate: (input) => input.userId === currentUser.id,
+* });
+* ```
+*/
+function withValidation(t, options = {}) {
+	if (!options.validate) return t;
+	const wrappedTool = { ...t };
+	const wrappedExecute = (input, executionOptions) => {
+		const { validate } = options;
+		const run = () => {
+			if (!t.execute) throw new Error("Strict tool wrapper requires a tool execute function");
+			return t.execute(input, executionOptions);
+		};
+		const isAsyncIterable = (value) => {
+			return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+		};
+		if (!validate) return run();
+		const validationResult = validate(input);
+		const isPromiseLike = (value) => typeof value?.then === "function";
+		if (isPromiseLike(validationResult)) return (async () => {
+			if (!await validationResult) throw new Error(`Strict validation failed for tool ${t.description?.slice(0, 20)}...`);
+			const result = run();
+			if (isAsyncIterable(result)) throw new Error("Async validation is not supported for streaming tool results");
+			return result;
+		})();
+		if (!validationResult) throw new Error(`Strict validation failed for tool ${t.description?.slice(0, 20)}...`);
+		const result = run();
+		if (isAsyncIterable(result)) return result;
+		return result;
+	};
+	wrappedTool.execute = wrappedExecute;
+	return wrappedTool;
+}
+
+//#endregion
+//#region src/tools/generic/json-schema-tool.ts
+/**
+* @fileoverview JSON Schema tool creation utilities.
+*
+* Creates AI SDK tools from plain JSON-style schema definitions
+* (as opposed to pre-built Zod schemas). Useful for tools defined
+* at runtime or loaded from configuration files.
+*
+* @module @od-oneapp/ai-platform/tools/generic/json-schema-tool
+*/
+/**
+* Creates a Zod schema from a parameter definition.
+*/
+function parameterToZod(param) {
+	let schema;
+	switch (param.type) {
+		case "string":
+			if (param.enum) schema = z.enum(param.enum);
+			else schema = z.string();
+			break;
+		case "number": {
+			let numSchema = z.number();
+			if (param.minimum !== void 0) numSchema = numSchema.min(param.minimum);
+			if (param.maximum !== void 0) numSchema = numSchema.max(param.maximum);
+			schema = numSchema;
+			break;
+		}
+		case "boolean":
+			schema = z.boolean();
+			break;
+		case "array":
+			schema = z.array(param.items ? parameterToZod(param.items) : z.unknown());
+			break;
+		case "object":
+			if (param.properties) {
+				const shape = {};
+				for (const [key, prop] of Object.entries(param.properties)) shape[key] = parameterToZod(prop);
+				schema = z.object(shape);
+			} else schema = z.record(z.string(), z.unknown());
+			break;
+		default: schema = z.unknown();
+	}
+	return schema.describe(param.description);
+}
+/**
+* Creates a Zod schema from a dynamic tool schema.
+*/
+function schemaToZod(schema) {
+	const shape = {};
+	for (const [name, param] of Object.entries(schema.parameters)) {
+		const zodParam = parameterToZod(param);
+		shape[name] = schema.required?.includes(name) ? zodParam : zodParam.optional();
+	}
+	return z.object(shape);
+}
+/**
+* Creates an AI SDK tool from a JSON-style schema definition.
+*
+* Converts the plain-object schema to Zod internally, so callers
+* don't need to depend on Zod directly. For pre-built Zod schemas,
+* use {@link createToolFromZodSchema} from `tools/simple-factory` instead.
+*
+* @param schema - Tool schema with name, description, and parameter definitions
+* @param execute - Async function that receives validated params and returns a result
+* @returns AI SDK tool instance
+*
+* @example
+* ```ts
+* const calcTool = createJsonSchemaTool({
+*   name: 'calculate',
+*   description: 'Perform calculations',
+*   parameters: {
+*     operation: { type: 'string', description: 'Operation', enum: ['add', 'sub'] },
+*     a: { type: 'number', description: 'First number' },
+*     b: { type: 'number', description: 'Second number' },
+*   },
+*   required: ['operation', 'a', 'b'],
+* }, async ({ operation, a, b }) => {
+*   return operation === 'add' ? a + b : a - b;
+* });
+* ```
+*/
+function createJsonSchemaTool(schema, execute) {
+	return tool({
+		description: schema.description,
+		inputSchema: schemaToZod(schema),
+		execute: async (params) => execute(params)
+	});
+}
+/**
+* Registry for managing tools created from JSON schema definitions.
+*
+* Stores tools and their schemas by name, supporting lookup, filtering,
+* and bulk retrieval. For tools created from Zod schemas, use them directly
+* without a registry.
+*/
+var JsonSchemaToolRegistry = class {
+	tools = /* @__PURE__ */ new Map();
+	schemas = /* @__PURE__ */ new Map();
+	/**
+	* Registers a tool with schema.
+	*/
+	register(schema, execute) {
+		const t = createJsonSchemaTool(schema, execute);
+		this.tools.set(schema.name, t);
+		this.schemas.set(schema.name, schema);
+	}
+	/**
+	* Gets a tool by name.
+	*/
+	get(name) {
+		return this.tools.get(name);
+	}
+	/**
+	* Gets schema by name.
+	*/
+	getSchema(name) {
+		return this.schemas.get(name);
+	}
+	/**
+	* Gets all tools.
+	*/
+	all() {
+		return Object.fromEntries(this.tools);
+	}
+	/**
+	* Gets all schemas.
+	*/
+	allSchemas() {
+		return Array.from(this.schemas.values());
+	}
+	/**
+	* Filters tools by pattern.
+	* Note: String patterns are escaped to prevent ReDoS attacks.
+	* To use regex patterns, pass a RegExp object directly.
+	*/
+	filter(pattern) {
+		const regex = typeof pattern === "string" ? new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")) : pattern;
+		const filtered = {};
+		for (const [name, t] of this.tools) if (regex.test(name)) filtered[name] = t;
+		return filtered;
+	}
+	/**
+	* Removes a tool.
+	*/
+	remove(name) {
+		this.schemas.delete(name);
+		return this.tools.delete(name);
+	}
+	/**
+	* Clears all tools.
+	*/
+	clear() {
+		this.tools.clear();
+		this.schemas.clear();
+	}
+};
+/**
+* Creates a tool that can be dynamically enabled/disabled.
+*
+* @param baseTool - The base tool
+* @param isEnabled - Function to check if tool is enabled
+* @returns Conditional tool
+*/
+function createConditionalTool(baseTool, isEnabled) {
+	const { execute } = baseTool;
+	return {
+		...baseTool,
+		execute: execute ? async (...args) => {
+			if (!await isEnabled()) return { error: "Tool is currently disabled" };
+			return execute(...args);
+		} : void 0
+	};
+}
+/**
+* Composes multiple tools into a single tool with routing.
+*
+* @param tools - Map of route patterns to tools
+* @param router - Function to determine route from input
+* @returns Composed tool
+*/
+function composeTools(tools, router) {
+	return tool({
+		description: `Composed tool with routes: ${Object.keys(tools).join(", ")}`,
+		inputSchema: z.object({}).passthrough(),
+		execute: async (input, options) => {
+			const typedInput = input;
+			const route = router(typedInput);
+			const selectedTool = tools[route];
+			if (!selectedTool) return { error: `Unknown route: ${route}` };
+			return selectedTool.execute?.(typedInput, options);
+		}
+	});
+}
+
+//#endregion
+//#region src/tools/generic/web-search.ts
+/**
+* Create a web search tool using an Exa API client.
+*
+* @param config - Exa search configuration
+* @param exaClient - Exa client instance (from `exa-js`)
+* @returns AI SDK tool for web search via Exa
+*
+* @example
+* ```ts
+* import Exa from 'exa-js';
+* import { createExaSearchTool } from '@od-oneapp/ai-platform/tools';
+*
+* const exa = new Exa(process.env.EXA_API_KEY!);
+* const searchTool = createExaSearchTool(
+*   { apiKey: process.env.EXA_API_KEY!, numResults: 5 },
+*   exa,
+* );
+* ```
+*/
+function createExaSearchTool(config, exaClient) {
+	return tool({
+		description: "Search the web for up-to-date information using Exa",
+		inputSchema: z$1.object({ query: z$1.string().min(1).max(100).describe("The search query") }),
+		execute: async ({ query }) => {
+			const { results } = await exaClient.searchAndContents(query, {
+				livecrawl: config.livecrawl ?? "always",
+				numResults: config.numResults ?? 3
+			});
+			return results.map((result) => ({
+				title: result.title,
+				url: result.url,
+				content: result.text?.slice(0, 1e3) ?? result.title ?? "",
+				publishedDate: result.publishedDate
+			}));
+		}
+	});
+}
+/**
+* Create a generic web search tool with a custom search function.
+*
+* @param searchFunction - Custom search implementation
+* @returns AI SDK tool for web search
+*
+* @example
+* ```ts
+* import { createWebSearchTool } from '@od-oneapp/ai-platform/tools';
+*
+* const tool = createWebSearchTool(async (query) => {
+*   const resp = await fetch(`https://api.search.com?q=${query}`);
+*   return resp.json();
+* });
+* ```
+*/
+function createWebSearchTool(searchFunction) {
+	return tool({
+		description: "Search the web for up-to-date information",
+		inputSchema: z$1.object({ query: z$1.string().min(1).max(100).describe("The search query") }),
+		execute: async ({ query }) => {
+			return searchFunction(query);
+		}
+	});
+}
+/**
+* Pre-configured search tool factories for common APIs.
+*/
+const webSearchTools = {
+	exa: (exaClient, options) => createExaSearchTool(options ?? { apiKey: "" }, exaClient),
+	custom: (searchFunction) => createWebSearchTool(searchFunction)
+};
+
+//#endregion
+//#region src/tools/generic/web-search-tool.ts
+/**
+* @fileoverview Pre-configured web search tool.
+*
+* Drop-in replacement for the legacy @od-oneapp/ai webSearchTool.
+* Auto-configures from environment (EXA_API_KEY).
+*/
+let cachedExaTool = null;
+const webSearchInputSchema = z.object({
+	query: z.string().min(1).describe("Search query"),
+	maxResults: z.number().int().positive().default(5).describe("Maximum results"),
+	timeRange: z.string().optional().describe("Time range filter"),
+	region: z.string().optional().describe("Geographic region")
+});
+/**
+* Pre-configured web search tool that auto-detects Exa API key from environment.
+*
+* @example
+* ```ts
+* import { webSearchTool } from '@od-oneapp/ai-platform/tools';
+*
+* const result = await generateText({
+*   model,
+*   tools: { webSearch: webSearchTool },
+*   prompt: 'Search for...',
+* });
+* ```
+*/
+const webSearchTool = tool({
+	description: "Search the web using Exa when configured",
+	inputSchema: webSearchInputSchema,
+	execute: async ({ query, maxResults, timeRange, region }) => {
+		const apiKey = process.env.EXA_API_KEY;
+		if (apiKey) {
+			if (!cachedExaTool) cachedExaTool = createExaSearchTool({
+				apiKey,
+				numResults: maxResults ?? 5
+			}, void 0);
+			try {
+				const timeoutMs = Number(process.env.AI_WEBSEARCH_TIMEOUT_MS) || 15e3;
+				const result = await Promise.race([cachedExaTool.execute?.({ query }, {}), new Promise((_resolve, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Web search timeout")), timeoutMs))]);
+				const results = Array.isArray(result) ? result : [];
+				return {
+					query,
+					results,
+					totalResults: results.length,
+					timeRange,
+					region,
+					source: "exa"
+				};
+			} catch {}
+		}
+		return {
+			query,
+			results: [],
+			totalResults: 0,
+			timeRange,
+			region,
+			source: "none"
+		};
+	}
+});
+
+//#endregion
+//#region src/tools/generic/tiptap-context.ts
+const WORKSPACE_ROOT = process.cwd();
+function resolveDocPath(relativePath) {
+	let current = WORKSPACE_ROOT;
+	while (true) {
+		const candidate = path.resolve(current, relativePath);
+		if (existsSync(candidate)) return candidate;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return path.resolve(WORKSPACE_ROOT, relativePath);
+}
+const TIPTAP_DOC_PATH = resolveDocPath("docs/llms/tiptap.txt");
+const DEFAULT_CHUNK_TOKEN_TARGET = 500;
+const MAX_KEYWORDS = 12;
+const MAX_RESULTS = 4;
+const STOP_WORDS = new Set([
+	"the",
+	"and",
+	"for",
+	"with",
+	"that",
+	"this",
+	"from",
+	"your",
+	"into",
+	"when",
+	"tiptap",
+	"editor",
+	"docs",
+	"learn",
+	"guide",
+	"using",
+	"about",
+	"more",
+	"how",
+	"api",
+	"overview",
+	"getting",
+	"started"
+]);
+const SYNONYM_MAP = {
+	react: [
+		"next",
+		"nextjs",
+		"jsx"
+	],
+	next: ["nextjs", "react"],
+	collaboration: [
+		"yjs",
+		"multiplayer",
+		"awareness"
+	],
+	ai: [
+		"assistant",
+		"generation",
+		"content"
+	],
+	export: [
+		"conversion",
+		"markdown",
+		"html",
+		"json",
+		"docx"
+	],
+	import: [
+		"conversion",
+		"docx",
+		"odt"
+	],
+	formatting: [
+		"style",
+		"styling",
+		"theme",
+		"css"
+	],
+	extension: [
+		"node",
+		"mark",
+		"custom extension"
+	],
+	command: [
+		"keyboard",
+		"shortcut",
+		"action"
+	],
+	schema: [
+		"nodes",
+		"marks",
+		"structure"
+	]
+};
+const CODE_EXAMPLES = [
+	{
+		id: "react-basic-editor",
+		title: "Initialize TipTap in React",
+		description: "Create a basic TipTap editor using StarterKit and controlled content.",
+		language: "tsx",
+		keywords: [
+			"react",
+			"starterkit",
+			"basic"
+		],
+		code: `import { useEditor, EditorContent } from '@tiptap/react';
+import StarterKit from '@tiptap/starter-kit';
+
+export function BasicEditor() {
+  const editor = useEditor({
+    extensions: [StarterKit],
+    content: '<p>Hello TipTap!</p>',
+  });
+
+  if (!editor) return null;
+
+  return <EditorContent editor={editor} />;
+}`
+	},
+	{
+		id: "nextjs-ssr-setup",
+		title: "Use TipTap inside Next.js App Router",
+		description: "Wrap the TipTap editor in a Client Component and load configuration from the server.",
+		language: "tsx",
+		keywords: [
+			"next",
+			"react",
+			"app-router"
+		],
+		code: `'use client';
+
+import { Suspense } from 'react';
+import dynamic from 'next/dynamic';
+
+const RichEditor = dynamic(() => import('./RichEditor').then(m => m.RichEditor), {
+  ssr: false,
+  loading: () => <p>Loading editor\u2026</p>,
+});
+
+export default function TiptapCanvas() {
+  return (
+    <section className="space-y-6">
+      <h1 className="text-xl font-semibold">Canvas Document</h1>
+      <Suspense fallback={<p>Preparing TipTap\u2026</p>}>
+        <RichEditor enableAI enableToolbar />
+      </Suspense>
+    </section>
+  );
+}
+`
+	},
+	{
+		id: "collaboration-setup",
+		title: "Enable Collaboration Extensions",
+		description: "Configure the Collaboration and CollaborationCursor extensions with a shared Yjs document.",
+		language: "ts",
+		keywords: [
+			"collaboration",
+			"yjs",
+			"multiplayer"
+		],
+		code: `import Collaboration from '@tiptap/extension-collaboration';
+import CollaborationCursor from '@tiptap/extension-collaboration-cursor';
+import { Doc } from 'yjs';
+
+const ydoc = new Doc();
+
+const editor = new Editor({
+  extensions: [
+    StarterKit,
+    Collaboration.configure({ document: ydoc }),
+    CollaborationCursor.configure({
+      provider: providerInstance,
+      user: { name: userName, color: userColor },
+    }),
+  ],
+});
+`
+	},
+	{
+		id: "content-export",
+		title: "Convert TipTap JSON to Markdown",
+		description: "Serialize the editor state to Markdown for downstream systems.",
+		language: "ts",
+		keywords: [
+			"export",
+			"markdown",
+			"json"
+		],
+		code: `import { generateJSON } from '@tiptap/html';
+import StarterKit from '@tiptap/starter-kit';
+
+export function toMarkdown(html: string) {
+  const json = generateJSON(html, [StarterKit]);
+  return json.content?.map(block => block.text).join('\\n') ?? '';
+}
+`
+	}
+];
+const CATEGORY_EXAMPLE_MAP = {
+	Overview: ["react-basic-editor"],
+	Docs: ["react-basic-editor", "nextjs-ssr-setup"],
+	"Editor Docs": ["react-basic-editor", "nextjs-ssr-setup"],
+	"Editor Extensions Docs": ["collaboration-setup"],
+	"Content AI Docs": ["react-basic-editor"],
+	"Import / Export Docs": ["content-export"],
+	"Commands Docs": ["react-basic-editor"]
+};
+let cachedIndexPromise = null;
+function normalizeHeading(rawHeading) {
+	return rawHeading.replace(/^#+\s*/, "").trim();
+}
+function slugify(value) {
+	return value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function tokenize(text) {
+	return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter(Boolean);
+}
+function countTokens(text) {
+	return tokenize(text).length;
+}
+function extractKeywords(text, maxKeywords = MAX_KEYWORDS) {
+	const frequencies = /* @__PURE__ */ new Map();
+	for (const token of tokenize(text)) {
+		if (STOP_WORDS.has(token)) continue;
+		const synonyms = SYNONYM_MAP[token] ?? [];
+		frequencies.set(token, (frequencies.get(token) ?? 0) + 1);
+		for (const synonym of synonyms) frequencies.set(synonym, (frequencies.get(synonym) ?? 0) + .5);
+	}
+	return Array.from(frequencies.entries()).sort((a, b) => b[1] - a[1]).slice(0, maxKeywords).map(([token]) => token);
+}
+function createSummary(content) {
+	const bulletHighlights = content.split("\n").map((line) => line.trim()).filter(Boolean).filter((line) => /^[-*]/.test(line)).map((line) => line.replace(/^[-*]\s*/, "")).slice(0, 3);
+	if (bulletHighlights.length > 0) return bulletHighlights.join(" ");
+	return content.split(/(?<=[.!?])\s+/).map((sentence) => sentence.trim()).filter(Boolean).slice(0, 2).join(" ");
+}
+function parseTiptapSections(doc) {
+	const sections = [];
+	const lines = doc.split("\n");
+	let currentCategory = "Overview";
+	let currentTitle = "Overview";
+	let buffer = [];
+	function flush() {
+		if (buffer.length === 0) return;
+		const content = buffer.join("\n").trim();
+		if (!content) {
+			buffer = [];
+			return;
+		}
+		sections.push({
+			category: currentCategory,
+			title: currentTitle,
+			content: [content]
+		});
+		buffer = [];
+	}
+	for (const rawLine of lines) {
+		const line = rawLine.trimEnd();
+		if (/^#\s/.test(line)) {
+			flush();
+			currentCategory = "Overview";
+			currentTitle = normalizeHeading(line);
+			continue;
+		}
+		if (/^##\s/.test(line)) {
+			flush();
+			currentCategory = normalizeHeading(line);
+			currentTitle = currentCategory;
+			continue;
+		}
+		if (/^###\s/.test(line)) {
+			flush();
+			currentTitle = normalizeHeading(line);
+			continue;
+		}
+		buffer.push(line);
+	}
+	flush();
+	return sections;
+}
+function chunkSection(section, chunkTokenTarget = DEFAULT_CHUNK_TOKEN_TARGET) {
+	const chunks = [];
+	const paragraphs = section.content.join("\n").split(/\n{2,}/).map((paragraph) => paragraph.trim()).filter(Boolean);
+	let currentChunk = [];
+	let currentTokens = 0;
+	let chunkIndex = 0;
+	const pushChunk = () => {
+		if (currentChunk.length === 0) return;
+		const content = currentChunk.join("\n\n");
+		const tokens = countTokens(content);
+		const summary = createSummary(content);
+		const keywords = extractKeywords(content);
+		chunks.push({
+			id: `${slugify(section.category)}-${slugify(section.title)}-${chunkIndex}`,
+			category: section.category,
+			title: section.title,
+			content,
+			summary,
+			keywords,
+			tokens
+		});
+		chunkIndex += 1;
+		currentChunk = [];
+		currentTokens = 0;
+	};
+	for (const paragraph of paragraphs) {
+		const paragraphTokens = countTokens(paragraph);
+		if (currentTokens + paragraphTokens > chunkTokenTarget && currentChunk.length > 0) pushChunk();
+		currentChunk.push(paragraph);
+		currentTokens += paragraphTokens;
+	}
+	pushChunk();
+	return chunks;
+}
+async function buildTiptapDocIndex() {
+	const chunks = parseTiptapSections(await promises.readFile(TIPTAP_DOC_PATH, "utf8")).flatMap((section) => chunkSection(section));
+	const categories = {};
+	for (const chunk of chunks) {
+		const categoryEntry = categories[chunk.category] ?? {
+			chunkCount: 0,
+			keywords: []
+		};
+		categoryEntry.chunkCount += 1;
+		categoryEntry.keywords = Array.from(new Set([...categoryEntry.keywords, ...chunk.keywords])).slice(0, MAX_KEYWORDS);
+		categories[chunk.category] = categoryEntry;
+	}
+	return {
+		chunks,
+		categories
+	};
+}
+async function getTiptapDocIndex() {
+	if (!cachedIndexPromise) cachedIndexPromise = (async () => {
+		try {
+			return await buildTiptapDocIndex();
+		} catch (error) {
+			cachedIndexPromise = null;
+			throw error;
+		}
+	})();
+	return cachedIndexPromise;
+}
+function expandQueryTokens(tokens) {
+	const expanded = new Set(tokens);
+	for (const token of tokens) {
+		const synonyms = SYNONYM_MAP[token];
+		if (synonyms) for (const synonym of synonyms) expanded.add(synonym);
+	}
+	return expanded;
+}
+function scoreChunk(query, chunk) {
+	const expandedTokens = expandQueryTokens(tokenize(query).filter((token) => !STOP_WORDS.has(token)));
+	const chunkTokens = new Set(chunk.keywords);
+	let overlapScore = 0;
+	for (const token of expandedTokens) {
+		if (chunkTokens.has(token)) overlapScore += 2;
+		if (chunk.content.toLowerCase().includes(token)) overlapScore += 1;
+		if (chunk.title.toLowerCase().includes(token)) overlapScore += 1.5;
+		if (chunk.category.toLowerCase().includes(token)) overlapScore += 1.5;
+	}
+	const lengthPenalty = Math.max(1, chunk.tokens / DEFAULT_CHUNK_TOKEN_TARGET);
+	return overlapScore / lengthPenalty;
+}
+function rankChunks(query, chunks) {
+	return chunks.map((chunk) => ({
+		...chunk,
+		score: scoreChunk(query, chunk)
+	})).filter((match) => match.score > 0).sort((a, b) => b.score - a.score);
+}
+function createAnswer(query, matches) {
+	if (matches.length === 0) return `No TipTap documentation matches were found for "${query}". Try broadening the query or referencing supported features like React integration, collaboration, or conversions.`;
+	return matches.map((match) => {
+		return `\u2022 ${match.title} (${match.category}): ${match.summary}`;
+	}).join("\n");
+}
+function selectCodeExamples(includeExamples, query, matches) {
+	if (!includeExamples) return [];
+	const matchedCategories = new Set(matches.map((match) => match.category));
+	const queryTokens = new Set(tokenize(query));
+	const suggestedExampleIds = /* @__PURE__ */ new Set();
+	for (const category of matchedCategories) {
+		const exampleIds = CATEGORY_EXAMPLE_MAP[category];
+		if (exampleIds) exampleIds.forEach((id) => suggestedExampleIds.add(id));
+	}
+	for (const example of CODE_EXAMPLES) if (example.keywords.some((keyword) => queryTokens.has(keyword))) suggestedExampleIds.add(example.id);
+	return CODE_EXAMPLES.filter((example) => suggestedExampleIds.has(example.id)).slice(0, 3);
+}
+/**
+* TipTap documentation context tool.
+*
+* Answers questions about TipTap v3 capabilities by searching curated
+* documentation chunks with semantic keyword matching.
+*
+* @example
+* ```ts
+* import { tiptapContextTool } from '@od-oneapp/ai-platform/tools';
+*
+* const result = await streamText({
+*   model,
+*   tools: { tiptapContext: tiptapContextTool },
+*   messages,
+* });
+* ```
+*/
+const tiptapContextTool = tool({
+	description: "Answer questions about TipTap v3 capabilities by searching curated documentation chunks with semantic keyword matching.",
+	inputSchema: z$1.object({
+		query: z$1.string().min(1, "query is required"),
+		context: z$1.string().optional(),
+		includeExamples: z$1.boolean().optional().default(true),
+		limit: z$1.number().int().min(1).max(MAX_RESULTS).optional().default(3)
+	}),
+	execute: async ({ query, context, includeExamples = true, limit = 3 }) => {
+		const index = await getTiptapDocIndex();
+		const searchQuery = [query, context].filter(Boolean).join("\n");
+		const ranked = rankChunks(searchQuery, index.chunks);
+		const topMatches = ranked.slice(0, limit);
+		return {
+			answer: createAnswer(searchQuery, topMatches),
+			query,
+			matchedCount: ranked.length,
+			relevantSections: topMatches.map((match) => ({
+				id: match.id,
+				category: match.category,
+				title: match.title,
+				summary: match.summary,
+				keywords: match.keywords,
+				score: Number(match.score.toFixed(3)),
+				content: match.content
+			})),
+			codeExamples: selectCodeExamples(includeExamples, searchQuery, topMatches),
+			metadata: {
+				categories: topMatches.map((match) => match.category),
+				indexSize: index.chunks.length
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/tools/advanced/llm-tool.ts
+/**
+* @fileoverview LLM-powered tool utilities.
+* @module @od-oneapp/ai-platform/tools/advanced
+*/
+const validationInputSchema = z.object({ content: z.string().describe("Content to validate") });
+const validationOutputSchema = z.object({
+	isValid: z.boolean(),
+	score: z.number().min(0).max(100),
+	violations: z.array(z.object({
+		criterion: z.string(),
+		issue: z.string(),
+		severity: z.enum([
+			"low",
+			"medium",
+			"high"
+		])
+	})),
+	suggestions: z.array(z.string())
+});
+/**
+* Creates a tool powered by an LLM with structured output.
+*
+* @param config - LLM tool configuration
+* @returns AI SDK tool
+*
+* @example
+* ```ts
+* const summarizeTool = createLLMTool({
+*   name: 'summarize',
+*   description: 'Summarize text',
+*   parameters: z.object({ text: z.string() }),
+*   outputSchema: z.object({ summary: z.string(), keyPoints: z.array(z.string()) }),
+*   systemPrompt: 'You are a summarization assistant.',
+*   userPromptTemplate: 'Summarize: {{text}}',
+*   model: openai('gpt-4o-mini'),
+* });
+* ```
+*/
+function createLLMTool(config) {
+	const { description, parameters, outputSchema, systemPrompt, userPromptTemplate, model, maxTokens, temperature } = config;
+	return tool({
+		description,
+		inputSchema: parameters,
+		execute: async (input) => {
+			return (await generateObject({
+				model,
+				system: systemPrompt,
+				prompt: interpolatePrompt(userPromptTemplate, input),
+				schema: outputSchema,
+				...maxTokens && { maxOutputTokens: maxTokens },
+				...temperature !== void 0 && { temperature }
+			})).object;
+		}
+	});
+}
+/**
+* Creates an LLM-powered validation tool.
+*
+* @param config - Validation tool configuration
+* @returns SDKTool that validates input against criteria
+*
+* @example
+* ```ts
+* const validateTool = createValidationTool({
+*   name: 'validateContent',
+*   description: 'Validate content against guidelines',
+*   criteria: ['No harmful content', 'Proper formatting', 'Factually accurate'],
+*   model: openai('gpt-4o-mini'),
+* });
+* ```
+*/
+function createValidationTool(config) {
+	return tool({
+		description: config.description,
+		inputSchema: validationInputSchema,
+		execute: async (input) => {
+			const { content } = input;
+			return (await generateObject({
+				model: config.model,
+				system: `You are a content validator. Validate content against these criteria:
+${config.criteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}
+
+Respond with JSON matching this schema:
+- isValid: boolean
+- score: 0-100
+- violations: array of {criterion, issue, severity: low|medium|high}
+- suggestions: array of improvement suggestions`,
+				prompt: `Validate this content:\n\n${content}`,
+				schema: validationOutputSchema,
+				...config.maxTokens && { maxOutputTokens: config.maxTokens }
+			})).object;
+		}
+	});
+}
+/**
+* Creates an LLM-powered transformation tool.
+*
+* @param config - Transformation tool configuration
+* @returns SDKTool that transforms input text
+*
+* @example
+* ```ts
+* const rewriteTool = createTransformTool({
+*   name: 'rewrite',
+*   description: 'Rewrite text in a different style',
+*   styles: ['formal', 'casual', 'technical'],
+*   model: openai('gpt-4o-mini'),
+* });
+* ```
+*/
+function createTransformTool(config) {
+	const transformInputSchema = z.object({
+		text: z.string().describe("Text to transform"),
+		style: z.enum(config.styles).describe("Target style"),
+		preserveLength: z.boolean().optional().describe("Keep similar length")
+	});
+	return tool({
+		description: config.description,
+		inputSchema: transformInputSchema,
+		execute: async (input) => {
+			const { text, style, preserveLength } = input;
+			const { text: result } = await generateText({
+				model: config.model,
+				system: `You are a text transformation assistant. Transform text to the requested style.${preserveLength ? " Keep the output approximately the same length as the input." : ""}`,
+				prompt: `Transform this text to ${style} style:\n\n${text}`
+			});
+			return {
+				original: text,
+				transformed: result,
+				style
+			};
+		}
+	});
+}
+/**
+* Interpolates template strings with values.
+*/
+function interpolatePrompt(template, values) {
+	return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+		const value = values[key];
+		return value !== void 0 ? String(value) : `{{${key}}}`;
+	});
+}
+
+//#endregion
+//#region src/tools/advanced/hitl.ts
+/**
+* Creates a tool that requires human approval before execution.
+*
+* @param config - HITL tool configuration
+* @returns Tool with approval gate
+*
+* @example
+* ```ts
+* const deleteFileTool = createHITLTool({
+*   name: 'deleteFile',
+*   description: 'Delete a file from the system',
+*   parameters: z.object({ path: z.string() }),
+*   execute: async ({ path }) => deleteFile(path),
+*   requestApproval: async ({ path }) => {
+*     return await showApprovalModal({
+*       title: 'Delete File?',
+*       message: `Are you sure you want to delete ${path}?`,
+*     });
+*   },
+*   riskLevel: 'high',
+* });
+* ```
+*/
+function createHITLTool(config) {
+	return tool({
+		description: `${config.description} (Requires approval${config.riskLevel ? ` - ${config.riskLevel} risk` : ""})`,
+		inputSchema: config.parameters,
+		execute: async (params) => {
+			const typedParams = params;
+			const decision = await config.requestApproval(typedParams);
+			if (!decision.approved) {
+				if (config.onDenied) await config.onDenied(typedParams, decision.reason);
+				return {
+					success: false,
+					error: "Action denied by user",
+					reason: decision.reason
+				};
+			}
+			const finalParams = decision.modifiedParams ? {
+				...params,
+				...decision.modifiedParams
+			} : params;
+			return {
+				success: true,
+				result: await config.execute(finalParams)
+			};
+		}
+	});
+}
+/**
+* Creates an approval policy checker.
+*
+* @param policies - Array of approval policies
+* @returns Function to check if params satisfy any policy
+*
+* @example
+* ```ts
+* const checkPolicy = createPolicyChecker([
+*   {
+*     name: 'safe-paths',
+*     toolPatterns: ['deleteFile', 'moveFile'],
+*     conditions: [
+*       { paramPath: 'path', operator: 'contains', value: '/tmp/' },
+*     ],
+*     maxRiskLevel: 'medium',
+*   },
+* ]);
+*
+* const canAutoApprove = checkPolicy('deleteFile', { path: '/tmp/test.txt' }, 'low');
+* ```
+*/
+function createPolicyChecker(policies) {
+	return function checkPolicy(toolName, params, riskLevel) {
+		const riskOrder = {
+			low: 1,
+			medium: 2,
+			high: 3,
+			critical: 4
+		};
+		const currentRisk = riskOrder[riskLevel];
+		for (const policy of policies) {
+			if (!policy.toolPatterns.some((pattern) => {
+				if (pattern === "*") return true;
+				if (pattern.endsWith("*")) return toolName.startsWith(pattern.slice(0, -1));
+				return toolName === pattern;
+			})) continue;
+			if (currentRisk > riskOrder[policy.maxRiskLevel]) continue;
+			if (policy.conditions.every((condition) => {
+				return evaluateCondition(getNestedValue(params, condition.paramPath), condition.operator, condition.value);
+			})) return {
+				approved: true,
+				policy: policy.name
+			};
+		}
+		return { approved: false };
+	};
+}
+/**
+* Gets a nested value from an object using dot notation.
+*/
+function getNestedValue(obj, path) {
+	return path.split(".").reduce((curr, key) => {
+		if (curr && typeof curr === "object" && key in curr) return curr[key];
+	}, obj);
+}
+/**
+* Evaluates a condition against a value.
+*/
+function evaluateCondition(value, operator, target) {
+	switch (operator) {
+		case "equals": return value === target;
+		case "contains": return typeof value === "string" && typeof target === "string" && value.includes(target);
+		case "matches": return typeof value === "string" && typeof target === "string" && new RegExp(target).test(value);
+		case "lessThan": return typeof value === "number" && typeof target === "number" && value < target;
+		case "greaterThan": return typeof value === "number" && typeof target === "number" && value > target;
+		default: return false;
+	}
+}
+/**
+* Creates a batch approval request for multiple tool calls.
+*
+* @param requests - Array of tool call requests
+* @param batchApproval - Function to approve batch
+* @returns Filtered array of approved requests
+*/
+async function batchApproval(requests, batchApprovalFn) {
+	const result = await batchApprovalFn(requests);
+	if (!result.approved) return [];
+	return result.approvedIndices.map((i) => requests[i]).filter((item) => item !== void 0);
+}
+
+//#endregion
+//#region src/tools/advanced/caching.ts
+/**
+* In-memory cache for tool results.
+*/
+var ToolCache = class {
+	cache = /* @__PURE__ */ new Map();
+	maxSize;
+	defaultTTL;
+	constructor(options = {}) {
+		this.maxSize = options.maxSize ?? 1e3;
+		this.defaultTTL = options.defaultTTL ?? 6e4;
+	}
+	/**
+	* Gets a value from cache.
+	*/
+	get(key) {
+		const entry = this.cache.get(key);
+		if (!entry) return void 0;
+		if (Date.now() > entry.expiresAt) {
+			this.cache.delete(key);
+			return;
+		}
+		entry.hits++;
+		return entry.value;
+	}
+	/**
+	* Sets a value in cache.
+	*/
+	set(key, value, ttl) {
+		if (this.cache.size >= this.maxSize) this.evictLeastUsed();
+		this.cache.set(key, {
+			value,
+			expiresAt: Date.now() + (ttl ?? this.defaultTTL),
+			hits: 0
+		});
+	}
+	/**
+	* Removes expired entries.
+	*/
+	prune() {
+		const now = Date.now();
+		let pruned = 0;
+		for (const [key, entry] of this.cache.entries()) if (now > entry.expiresAt) {
+			this.cache.delete(key);
+			pruned++;
+		}
+		return pruned;
+	}
+	/**
+	* Clears the entire cache.
+	*/
+	clear() {
+		this.cache.clear();
+	}
+	/**
+	* Gets cache statistics.
+	*/
+	stats() {
+		let totalHits = 0;
+		for (const entry of this.cache.values()) totalHits += entry.hits;
+		return {
+			size: this.cache.size,
+			maxSize: this.maxSize,
+			totalHits
+		};
+	}
+	evictLeastUsed() {
+		let minHits = Infinity;
+		let minKey;
+		for (const [key, entry] of this.cache.entries()) if (entry.hits < minHits) {
+			minHits = entry.hits;
+			minKey = key;
+		}
+		if (minKey) this.cache.delete(minKey);
+	}
+};
+/**
+* Wraps a tool handler with caching.
+*
+* @param handler - Original handler
+* @param options - Cache options
+* @returns Cached handler
+*
+* @example
+* ```ts
+* const cache = new ToolCache<SearchResult>({ ttl: 300000 });
+*
+* const cachedSearch = withCaching(
+*   async ({ query }) => searchDocs(query),
+*   { cache, keyGenerator: ({ query }) => `search:${query}` }
+* );
+* ```
+*/
+function withCaching(handler, options = {}) {
+	const cache = options.cache ?? new ToolCache();
+	const keyGen = options.keyGenerator ?? defaultKeyGenerator;
+	return async (input, context) => {
+		if (options.skipCache?.(input, context)) return handler(input, context);
+		const key = keyGen(input, context);
+		const cached = cache.get(key);
+		if (cached !== void 0) return cached;
+		try {
+			const result = await handler(input, context);
+			cache.set(key, result, options.ttl);
+			return result;
+		} catch (error) {
+			if (options.cacheErrors) {
+				const errorResult = { error: String(error) };
+				cache.set(key, errorResult, options.ttl);
+				return errorResult;
+			}
+			throw error;
+		}
+	};
+}
+/**
+* Default key generator using JSON.stringify.
+*/
+function defaultKeyGenerator(input, context) {
+	return JSON.stringify({
+		input,
+		userId: context.userId
+	});
+}
+/**
+* Creates a cache key builder with prefixing.
+*
+* @param prefix - Cache key prefix
+* @returns Key generator function
+*
+* @example
+* ```ts
+* const keyGen = createKeyBuilder('search');
+* keyGen({ query: 'test' }, ctx); // => 'search:{"query":"test"}'
+* ```
+*/
+function createKeyBuilder(prefix) {
+	return function(input, context) {
+		return `${prefix}:${JSON.stringify({
+			input,
+			userId: context.userId
+		})}`;
+	};
+}
+/**
+* Creates a selective key generator that only uses specified fields.
+*
+* @param prefix - Cache key prefix
+* @param fields - Fields to include in key
+* @returns Key generator function
+*
+* @example
+* ```ts
+* const keyGen = createSelectiveKeyBuilder('search', ['query', 'limit']);
+* keyGen({ query: 'test', limit: 10, page: 1 }, ctx); // => 'search:test:10'
+* ```
+*/
+function createSelectiveKeyBuilder(prefix, fields) {
+	return function(input, context) {
+		return `${prefix}:${fields.map((f) => String(input[f] ?? "")).join(":")}`;
+	};
+}
+/**
+* Creates a stale-while-revalidate cache wrapper.
+*
+* @param handler - Original handler
+* @param options - SWR options
+* @returns Handler with SWR caching
+*
+* @example
+* ```ts
+* const swrSearch = withSWRCaching(searchHandler, {
+*   staleTTL: 60000,    // 1 minute stale
+*   maxTTL: 300000,     // 5 minute max
+* });
+* ```
+*/
+function withSWRCaching(handler, options) {
+	const cache = new ToolCache();
+	const keyGen = options.keyGenerator ?? defaultKeyGenerator;
+	return async (input, context) => {
+		const key = keyGen(input, context);
+		const cached = cache.get(key);
+		const now = Date.now();
+		if (cached && now - cached.fetchedAt < options.staleTTL) return cached.value;
+		if (cached && now - cached.fetchedAt < options.maxTTL) {
+			(async () => {
+				try {
+					const fresh = await handler(input, context);
+					cache.set(key, {
+						value: fresh,
+						fetchedAt: Date.now()
+					}, options.maxTTL);
+				} catch {}
+			})();
+			return cached.value;
+		}
+		const result = await handler(input, context);
+		cache.set(key, {
+			value: result,
+			fetchedAt: now
+		}, options.maxTTL);
+		return result;
+	};
+}
+
+//#endregion
+//#region src/tools/advanced/generator.ts
+/**
+* Creates a tool that streams results via async generator.
+*
+* Note: The tool collects all chunks and returns the final result.
+* For true streaming, use with streamText's onToolCall.
+*
+* @param config - Generator tool configuration
+* @returns AI SDK tool
+*
+* @example
+* ```ts
+* const processFileTool = createGeneratorTool({
+*   name: 'processFile',
+*   description: 'Process a large file in chunks',
+*   parameters: z.object({ path: z.string() }),
+*   generator: async function* ({ path }) {
+*     const chunks = await readFileChunks(path);
+*     for (const chunk of chunks) {
+*       yield { processed: processChunk(chunk) };
+*     }
+*     return { totalChunks: chunks.length };
+*   },
+* });
+* ```
+*/
+function createGeneratorTool(config) {
+	return tool({
+		description: config.description,
+		inputSchema: config.parameters,
+		execute: async (input) => {
+			const typedInput = input;
+			const chunks = [];
+			let index = 0;
+			let finalResult;
+			const gen = config.generator(typedInput);
+			for (;;) {
+				const { value, done } = await gen.next();
+				if (done) {
+					finalResult = value;
+					break;
+				}
+				const chunk = value;
+				chunks.push(chunk);
+				if (config.transformChunk) config.transformChunk(chunk, index);
+				index++;
+			}
+			if (config.transformFinal && finalResult !== void 0) return config.transformFinal(finalResult, chunks);
+			return {
+				chunks,
+				final: finalResult
+			};
+		}
+	});
+}
+/**
+* Creates a paginated tool that fetches results in pages.
+*
+* @param config - Pagination tool configuration
+* @returns AI SDK tool
+*
+* @example
+* ```ts
+* const listUsersTool = createPaginatedTool({
+*   name: 'listUsers',
+*   description: 'List users with pagination',
+*   parameters: z.object({ filter: z.string().optional() }),
+*   pageSize: 100,
+*   maxPages: 10,
+*   fetchPage: async ({ filter }, page, pageSize) => {
+*     return fetchUsers({ filter, page, pageSize });
+*   },
+* });
+* ```
+*/
+function createPaginatedTool(config) {
+	const { pageSize, maxPages = 10 } = config;
+	return tool({
+		description: config.description,
+		inputSchema: config.parameters,
+		execute: async (input) => {
+			const typedInput = input;
+			const allItems = [];
+			let page = 0;
+			let hasMore = true;
+			while (hasMore && page < maxPages) {
+				const { items, hasMore: pageHasMore } = await config.fetchPage(typedInput, page, pageSize);
+				allItems.push(...items);
+				hasMore = pageHasMore;
+				page++;
+			}
+			return {
+				items: allItems,
+				totalPages: page,
+				truncated: hasMore
+			};
+		}
+	});
+}
+/**
+* Creates a tool that retries on failure with exponential backoff.
+*
+* @param config - Retry tool configuration
+* @returns AI SDK tool
+*
+* @example
+* ```ts
+* const fetchDataTool = createRetryTool({
+*   name: 'fetchData',
+*   description: 'Fetch data with retry',
+*   parameters: z.object({ url: z.string() }),
+*   maxRetries: 3,
+*   baseDelay: 1000,
+*   execute: async ({ url }) => fetch(url).then(r => r.json()),
+* });
+* ```
+*/
+function createRetryTool(config) {
+	const { maxRetries, baseDelay = 1e3, maxDelay = 3e4, shouldRetry = () => true } = config;
+	return tool({
+		description: config.description,
+		inputSchema: config.parameters,
+		execute: async (input) => {
+			const typedInput = input;
+			let lastError;
+			for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+				return await config.execute(typedInput);
+			} catch (e) {
+				lastError = e instanceof Error ? e : new Error(String(e));
+				if (attempt < maxRetries && shouldRetry(lastError, attempt)) await sleep(Math.min(baseDelay * Math.pow(2, attempt), maxDelay));
+			}
+			throw lastError;
+		}
+	});
+}
+/**
+* Helper to create a polling tool that waits for a condition.
+*
+* @param config - Polling tool configuration
+* @returns AI SDK tool
+*
+* @example
+* ```ts
+* const waitForJobTool = createPollingTool({
+*   name: 'waitForJob',
+*   description: 'Wait for a job to complete',
+*   parameters: z.object({ jobId: z.string() }),
+*   poll: async ({ jobId }) => getJobStatus(jobId),
+*   isComplete: (status) => status.state === 'complete',
+*   interval: 2000,
+*   timeout: 60000,
+* });
+* ```
+*/
+function createPollingTool(config) {
+	const { interval = 1e3, timeout = 3e4 } = config;
+	return tool({
+		description: config.description,
+		inputSchema: config.parameters,
+		execute: async (input) => {
+			const typedInput = input;
+			const startTime = Date.now();
+			while (Date.now() - startTime < timeout) {
+				const status = await config.poll(typedInput);
+				if (config.isComplete(status)) return {
+					complete: true,
+					status
+				};
+				await sleep(interval);
+			}
+			return {
+				complete: false,
+				timedOut: true
+			};
+		}
+	});
+}
+/**
+* Sleep helper.
+*/
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+//#region src/tools/artifacts/artifact-tools.ts
+/**
+* @fileoverview Artifact-specific tool factories.
+* @module @od-oneapp/ai-platform/tools/artifacts
+*/
+/**
+* Artifact types supported by the system.
+*/
+const ArtifactType = z.enum([
+	"document",
+	"code",
+	"presentation",
+	"spreadsheet",
+	"canvas",
+	"image",
+	"diagram"
+]);
+/**
+* Base artifact metadata.
+*/
+const ArtifactMetadataSchema = z.object({
+	id: z.string(),
+	type: ArtifactType,
+	title: z.string(),
+	createdAt: z.string().datetime(),
+	updatedAt: z.string().datetime(),
+	version: z.number()
+});
+/**
+* Creates a tool for creating artifacts.
+*
+* @param config - Creation tool configuration
+* @returns AI SDK tool
+*
+* @example
+* ```ts
+* const createDocTool = createArtifactCreationTool({
+*   artifactType: 'document',
+*   description: 'Create a new document',
+*   handler: async ({ title, content }) => {
+*     const doc = await createDocument({ title, content });
+*     return { success: true, artifact: doc.metadata, data: doc };
+*   },
+* });
+* ```
+*/
+function createArtifactCreationTool(config) {
+	const contentSchema = config.contentSchema ?? z.unknown();
+	return tool({
+		description: config.description,
+		inputSchema: z.object({
+			title: z.string().describe("Artifact title"),
+			content: contentSchema.describe("Artifact content")
+		}),
+		execute: async (input) => {
+			return config.handler(input);
+		}
+	});
+}
+/**
+* Creates a tool for updating artifacts.
+*
+* @param config - Update tool configuration
+* @returns AI SDK tool
+*/
+function createArtifactUpdateTool(config) {
+	const updateSchema = config.updateSchema ?? z.unknown();
+	return tool({
+		description: config.description,
+		inputSchema: z.object({
+			id: z.string().describe("Artifact ID"),
+			update: updateSchema.describe("Update payload")
+		}),
+		execute: async (input) => {
+			return config.handler(input);
+		}
+	});
+}
+/**
+* Creates a tool for reading artifacts.
+*
+* @param config - Read tool configuration
+* @returns AI SDK tool
+*/
+function createArtifactReadTool(config) {
+	return tool({
+		description: config.description,
+		inputSchema: z.object({ id: z.string().describe("Artifact ID") }),
+		execute: async (input) => {
+			return config.handler(input);
+		}
+	});
+}
+/**
+* Creates a tool for deleting artifacts.
+*
+* @param config - Delete tool configuration
+* @returns AI SDK tool
+*/
+function createArtifactDeleteTool(config) {
+	return tool({
+		description: config.description,
+		inputSchema: z.object({ id: z.string().describe("Artifact ID") }),
+		execute: async (input) => {
+			return config.handler(input);
+		}
+	});
+}
+/**
+* Creates a complete CRUD tool set for an artifact type.
+*
+* @param config - CRUD configuration
+* @returns Record of CRUD tools
+*
+* @example
+* ```ts
+* const docTools = createArtifactCRUDTools({
+*   artifactType: 'document',
+*   handlers: {
+*     create: async ({ title, content }) => createDoc(title, content),
+*     read: async ({ id }) => readDoc(id),
+*     update: async ({ id, update }) => updateDoc(id, update),
+*     delete: async ({ id }) => deleteDoc(id),
+*   },
+* });
+* ```
+*/
+function createArtifactCRUDTools(config) {
+	const { artifactType, handlers } = config;
+	const typeLabel = artifactType.charAt(0).toUpperCase() + artifactType.slice(1);
+	return {
+		[`create${typeLabel}`]: createArtifactCreationTool({
+			artifactType,
+			description: `Create a new ${artifactType}`,
+			contentSchema: config.contentSchema,
+			handler: handlers.create
+		}),
+		[`read${typeLabel}`]: createArtifactReadTool({
+			artifactType,
+			description: `Read a ${artifactType} by ID`,
+			handler: handlers.read
+		}),
+		[`update${typeLabel}`]: createArtifactUpdateTool({
+			artifactType,
+			description: `Update a ${artifactType}`,
+			updateSchema: config.updateSchema,
+			handler: handlers.update
+		}),
+		[`delete${typeLabel}`]: createArtifactDeleteTool({
+			artifactType,
+			description: `Delete a ${artifactType}`,
+			handler: handlers.delete
+		})
+	};
+}
+/**
+* Creates tools for artifact versioning.
+*/
+function createVersioningTools(config) {
+	const { artifactType, handlers } = config;
+	const typeLabel = artifactType.charAt(0).toUpperCase() + artifactType.slice(1);
+	return {
+		[`list${typeLabel}Versions`]: tool({
+			description: `List all versions of a ${artifactType}`,
+			inputSchema: z.object({ id: z.string().describe("Artifact ID") }),
+			execute: async (input) => {
+				const { id } = input;
+				return handlers.listVersions(id);
+			}
+		}),
+		[`get${typeLabel}Version`]: tool({
+			description: `Get a specific version of a ${artifactType}`,
+			inputSchema: z.object({
+				id: z.string().describe("Artifact ID"),
+				version: z.number().describe("Version number")
+			}),
+			execute: async (input) => {
+				const { id, version } = input;
+				return handlers.getVersion(id, version);
+			}
+		}),
+		[`revert${typeLabel}`]: tool({
+			description: `Revert a ${artifactType} to a previous version`,
+			inputSchema: z.object({
+				id: z.string().describe("Artifact ID"),
+				version: z.number().describe("Version to revert to")
+			}),
+			execute: async (input) => {
+				const { id, version } = input;
+				return handlers.revertToVersion(id, version);
+			}
+		})
+	};
+}
+
+//#endregion
+//#region src/tools/index.ts
+var tools_exports = /* @__PURE__ */ __exportAll({
+	AISDKCompatibleMCPError: () => AISDKCompatibleMCPError,
+	ANTI_PATTERN_SYSTEM_PROMPT: () => ANTI_PATTERN_SYSTEM_PROMPT,
+	AgentDispatchOutputSchema: () => AgentDispatchOutputSchema,
+	AntiPatternOutputSchema: () => AntiPatternOutputSchema,
+	ArtifactMetadataSchema: () => ArtifactMetadataSchema,
+	ArtifactType: () => ArtifactType,
+	AsyncPatternsOutputSchema: () => AsyncPatternsOutputSchema,
+	BRAINSTORM_SYSTEM_PROMPT: () => BRAINSTORM_SYSTEM_PROMPT,
+	BrainstormOutputSchema: () => BrainstormOutputSchema,
+	BranchFinishOutputSchema: () => BranchFinishOutputSchema,
+	CODE_REVIEW_SYSTEM_PROMPT: () => CODE_REVIEW_SYSTEM_PROMPT,
+	COMMIT_ANALYSIS_SYSTEM_PROMPT: () => COMMIT_ANALYSIS_SYSTEM_PROMPT,
+	CONDITION_BASED_WAITING_SYSTEM_PROMPT: () => CONDITION_BASED_WAITING_SYSTEM_PROMPT,
+	CodeReviewOutputSchema: () => CodeReviewOutputSchema,
+	CodeReviewResponseOutputSchema: () => CodeReviewResponseOutputSchema,
+	CommitAnalysisOutputSchema: () => CommitAnalysisOutputSchema,
+	DEFAULT_CACHE_CONFIG: () => DEFAULT_CACHE_CONFIG,
+	DEFAULT_HEALTH_CHECK_CONFIG: () => DEFAULT_HEALTH_CHECK_CONFIG,
+	DEFAULT_POOL_CONFIG: () => DEFAULT_POOL_CONFIG,
+	DEFAULT_RETRY_CONFIG: () => DEFAULT_RETRY_CONFIG,
+	DEFAULT_STREAM_LIFECYCLE_CONFIG: () => DEFAULT_STREAM_LIFECYCLE_CONFIG,
+	DEFENSE_IN_DEPTH_SYSTEM_PROMPT: () => DEFENSE_IN_DEPTH_SYSTEM_PROMPT,
+	DESIGN_REVIEW_SYSTEM_PROMPT: () => DESIGN_REVIEW_SYSTEM_PROMPT,
+	DISPATCHING_AGENTS_SYSTEM_PROMPT: () => DISPATCHING_AGENTS_SYSTEM_PROMPT,
+	DefenseInDepthOutputSchema: () => DefenseInDepthOutputSchema,
+	DesignReviewOutputSchema: () => DesignReviewOutputSchema,
+	EXECUTING_PLANS_SYSTEM_PROMPT: () => EXECUTING_PLANS_SYSTEM_PROMPT,
+	FINISHING_BRANCH_SYSTEM_PROMPT: () => FINISHING_BRANCH_SYSTEM_PROMPT,
+	GIT_WORKTREE_SYSTEM_PROMPT: () => GIT_WORKTREE_SYSTEM_PROMPT,
+	JsonSchemaToolRegistry: () => JsonSchemaToolRegistry,
+	MCPConnectionError: () => MCPConnectionError,
+	MCPConnectionManager: () => MCPConnectionManager,
+	MCPConnectionPool: () => MCPConnectionPool,
+	MCPErrorHandlerFactory: () => MCPErrorHandlerFactory,
+	MCPErrorUtils: () => MCPErrorUtils,
+	MCPHealthMonitor: () => MCPHealthMonitor,
+	MCPHealthStatus: () => MCPHealthStatus,
+	MCPRequestManager: () => MCPRequestManager,
+	MCPRetryableError: () => MCPRetryableError,
+	MCPStreamLifecycleManager: () => MCPStreamLifecycleManager,
+	MCPToolCache: () => MCPToolCache,
+	MCPTransportError: () => MCPTransportError,
+	MCPTransportSelector: () => MCPTransportSelector,
+	PLANNER_SYSTEM_PROMPT: () => PLANNER_SYSTEM_PROMPT,
+	PlanExecutionOutputSchema: () => PlanExecutionOutputSchema,
+	PlanOutputSchema: () => PlanOutputSchema,
+	RECEIVING_CODE_REVIEW_SYSTEM_PROMPT: () => RECEIVING_CODE_REVIEW_SYSTEM_PROMPT,
+	ROOT_CAUSE_TRACING_SYSTEM_PROMPT: () => ROOT_CAUSE_TRACING_SYSTEM_PROMPT,
+	RootCauseTracingOutputSchema: () => RootCauseTracingOutputSchema,
+	SHARING_SKILLS_SYSTEM_PROMPT: () => SHARING_SKILLS_SYSTEM_PROMPT,
+	SUBAGENT_DRIVEN_DEV_SYSTEM_PROMPT: () => SUBAGENT_DRIVEN_DEV_SYSTEM_PROMPT,
+	SYSTEMATIC_DEBUGGING_SYSTEM_PROMPT: () => SYSTEMATIC_DEBUGGING_SYSTEM_PROMPT,
+	SkillShareOutputSchema: () => SkillShareOutputSchema,
+	SkillTestOutputSchema: () => SkillTestOutputSchema,
+	SkillWriteOutputSchema: () => SkillWriteOutputSchema,
+	StreamLifecyclePhase: () => StreamLifecyclePhase,
+	SubagentDevOutputSchema: () => SubagentDevOutputSchema,
+	SuperpowersIntroOutputSchema: () => SuperpowersIntroOutputSchema,
+	SystematicDebuggingOutputSchema: () => SystematicDebuggingOutputSchema,
+	TDDOutputSchema: () => TDDOutputSchema,
+	TDD_SYSTEM_PROMPT: () => TDD_SYSTEM_PROMPT,
+	TESTING_SKILLS_SYSTEM_PROMPT: () => TESTING_SKILLS_SYSTEM_PROMPT,
+	ToolAbortError: () => ToolAbortError,
+	ToolCache: () => ToolCache,
+	USING_SUPERPOWERS_SYSTEM_PROMPT: () => USING_SUPERPOWERS_SYSTEM_PROMPT,
+	WRITING_SKILLS_SYSTEM_PROMPT: () => WRITING_SKILLS_SYSTEM_PROMPT,
+	WorktreeOutputSchema: () => WorktreeOutputSchema,
+	allSuperpowerTools: () => allSuperpowerTools,
+	analyzeAsyncPatterns: () => analyzeAsyncPatterns,
+	analyzeCommit: () => analyzeCommit,
+	analyzeDefenseInDepth: () => analyzeDefenseInDepth,
+	batchApproval: () => batchApproval,
+	codeReviewTools: () => codeReviewTools,
+	combineAbortSignals: () => combineAbortSignals,
+	composeTools: () => composeTools,
+	consultArchitect: () => consultArchitect,
+	createArtifactCRUDTools: () => createArtifactCRUDTools,
+	createArtifactCreationTool: () => createArtifactCreationTool,
+	createArtifactDeleteTool: () => createArtifactDeleteTool,
+	createArtifactReadTool: () => createArtifactReadTool,
+	createArtifactUpdateTool: () => createArtifactUpdateTool,
+	createBashTool: () => createBashTool,
+	createComputerTool: () => createComputerTool,
+	createConditionalTool: () => createConditionalTool,
+	createEdgeMCPTools: () => createEdgeMCPTools,
+	createExaSearchTool: () => createExaSearchTool,
+	createGeneratorTool: () => createGeneratorTool,
+	createHITLTool: () => createHITLTool,
+	createJsonSchemaTool: () => createJsonSchemaTool,
+	createKeyBuilder: () => createKeyBuilder,
+	createLLMTool: () => createLLMTool,
+	createMCPStreamLifecycleManager: () => createMCPStreamLifecycleManager,
+	createMCPToolsForRequest: () => createMCPToolsForRequest,
+	createMCPToolsForStreamText: () => createMCPToolsForStreamText,
+	createMCPToolsFromConfigs: () => createMCPToolsFromConfigs,
+	createMCPToolsWithDefaults: () => createMCPToolsWithDefaults,
+	createMCPToolsWithStreamLifecycle: () => createMCPToolsWithStreamLifecycle,
+	createPaginatedTool: () => createPaginatedTool,
+	createPolicyChecker: () => createPolicyChecker,
+	createPollingTool: () => createPollingTool,
+	createPooledMCPTools: () => createPooledMCPTools,
+	createRetryTool: () => createRetryTool,
+	createSelectiveKeyBuilder: () => createSelectiveKeyBuilder,
+	createSimpleTool: () => createSimpleTool,
+	createSmartMCPTools: () => createSmartMCPTools,
+	createTimeoutAbort: () => createTimeoutAbort,
+	createToolFactory: () => createToolFactory,
+	createToolFromZodSchema: () => createToolFromZodSchema,
+	createToolWithContext: () => createToolWithContext,
+	createTools: () => createTools,
+	createTransformTool: () => createTransformTool,
+	createTransportFromConfig: () => createTransportFromConfig,
+	createValidationTool: () => createValidationTool,
+	createVersioningTools: () => createVersioningTools,
+	createWebSearchTool: () => createWebSearchTool,
+	debuggingTools: () => debuggingTools,
+	detectAntiPatterns: () => detectAntiPatterns,
+	discoverEdgeMCPServers: () => discoverEdgeMCPServers,
+	discoverMCPServersFromEnvironment: () => discoverMCPServersFromEnvironment,
+	dispatchAgents: () => dispatchAgents,
+	edgeMCPTransports: () => edgeMCPTransports,
+	executePlan: () => executePlan,
+	executeToolSafely: () => executeToolSafely,
+	executeWithFallback: () => executeWithFallback,
+	finishBranch: () => finishBranch,
+	getEdgeCompatibleConfigs: () => getEdgeCompatibleConfigs,
+	getGlobalConnectionManager: () => getGlobalConnectionManager,
+	getMCPServers: () => getMCPServers,
+	gitTools: () => gitTools,
+	globalMCPConnectionPool: () => globalMCPConnectionPool,
+	globalMCPHealthMonitor: () => globalMCPHealthMonitor,
+	globalMCPToolCache: () => globalMCPToolCache,
+	globalTransportSelector: () => globalTransportSelector,
+	initSuperpowers: () => initSuperpowers,
+	introduceSuperpowers: () => introduceSuperpowers,
+	isAbortError: () => isAbortError,
+	isEdgeRuntime: () => isEdgeRuntime,
+	manageWorktree: () => manageWorktree,
+	mcpTransports: () => mcpTransports,
+	metaTools: () => metaTools,
+	planningTools: () => planningTools,
+	processCodeReview: () => processCodeReview,
+	qualityTools: () => qualityTools,
+	refineRequirements: () => refineRequirements,
+	reviewCode: () => reviewCode,
+	reviewDesign: () => reviewDesign,
+	runSubagentDev: () => runSubagentDev,
+	runTDDCycle: () => runTDDCycle,
+	selectOptimalTransport: () => selectOptimalTransport,
+	selectTransportForUseCase: () => selectTransportForUseCase,
+	shareSkill: () => shareSkill,
+	systemPrompts: () => systemPrompts,
+	systematicDebug: () => systematicDebug,
+	testMCPConnectivity: () => testMCPConnectivity,
+	testSkill: () => testSkill,
+	tiptapContextTool: () => tiptapContextTool,
+	traceRootCause: () => traceRootCause,
+	validateMCPEnvironment: () => validateMCPEnvironment,
+	webSearchTool: () => webSearchTool,
+	webSearchTools: () => webSearchTools,
+	withAbortHandling: () => withAbortHandling,
+	withCaching: () => withCaching,
+	withRetryAndTimeout: () => withRetryAndTimeout,
+	withSWRCaching: () => withSWRCaching,
+	withValidation: () => withValidation,
+	workflowTools: () => workflowTools,
+	wrapToolHandler: () => wrapToolHandler,
+	writeSkill: () => writeSkill
+});
+
+//#endregion
+export { AISDKCompatibleMCPError, ANTI_PATTERN_SYSTEM_PROMPT, AgentDispatchOutputSchema, AntiPatternOutputSchema, ArtifactMetadataSchema, ArtifactType, AsyncPatternsOutputSchema, BRAINSTORM_SYSTEM_PROMPT, BrainstormOutputSchema, BranchFinishOutputSchema, CODE_REVIEW_SYSTEM_PROMPT, COMMIT_ANALYSIS_SYSTEM_PROMPT, CONDITION_BASED_WAITING_SYSTEM_PROMPT, CodeReviewOutputSchema, CodeReviewResponseOutputSchema, CommitAnalysisOutputSchema, DEFAULT_CACHE_CONFIG, DEFAULT_HEALTH_CHECK_CONFIG, DEFAULT_POOL_CONFIG, DEFAULT_RETRY_CONFIG, DEFAULT_STREAM_LIFECYCLE_CONFIG, DEFENSE_IN_DEPTH_SYSTEM_PROMPT, DESIGN_REVIEW_SYSTEM_PROMPT, DISPATCHING_AGENTS_SYSTEM_PROMPT, DefenseInDepthOutputSchema, DesignReviewOutputSchema, EXECUTING_PLANS_SYSTEM_PROMPT, FINISHING_BRANCH_SYSTEM_PROMPT, GIT_WORKTREE_SYSTEM_PROMPT, JsonSchemaToolRegistry, MCPConnectionError, MCPConnectionManager, MCPConnectionPool, MCPErrorHandlerFactory, MCPErrorUtils, MCPHealthMonitor, MCPHealthStatus, MCPRequestManager, MCPRetryableError, MCPStreamLifecycleManager, MCPToolCache, MCPTransportError, MCPTransportSelector, PLANNER_SYSTEM_PROMPT, PlanExecutionOutputSchema, PlanOutputSchema, RECEIVING_CODE_REVIEW_SYSTEM_PROMPT, ROOT_CAUSE_TRACING_SYSTEM_PROMPT, RootCauseTracingOutputSchema, SHARING_SKILLS_SYSTEM_PROMPT, SUBAGENT_DRIVEN_DEV_SYSTEM_PROMPT, SYSTEMATIC_DEBUGGING_SYSTEM_PROMPT, SkillShareOutputSchema, SkillTestOutputSchema, SkillWriteOutputSchema, StreamLifecyclePhase, SubagentDevOutputSchema, SuperpowersIntroOutputSchema, SystematicDebuggingOutputSchema, TDDOutputSchema, TDD_SYSTEM_PROMPT, TESTING_SKILLS_SYSTEM_PROMPT, ToolAbortError, ToolCache, USING_SUPERPOWERS_SYSTEM_PROMPT, WRITING_SKILLS_SYSTEM_PROMPT, WorktreeOutputSchema, allSuperpowerTools, analyzeAsyncPatterns, analyzeCommit, analyzeDefenseInDepth, batchApproval, codeReviewTools, combineAbortSignals, composeTools, consultArchitect, createArtifactCRUDTools, createArtifactCreationTool, createArtifactDeleteTool, createArtifactReadTool, createArtifactUpdateTool, createBashTool, createComputerTool, createConditionalTool, createEdgeMCPTools, createExaSearchTool, createGeneratorTool, createHITLTool, createJsonSchemaTool, createKeyBuilder, createLLMTool, createMCPStreamLifecycleManager, createMCPToolsForRequest, createMCPToolsForStreamText, createMCPToolsFromConfigs, createMCPToolsWithDefaults, createMCPToolsWithStreamLifecycle, createPaginatedTool, createPolicyChecker, createPollingTool, createPooledMCPTools, createRetryTool, createSelectiveKeyBuilder, createSimpleTool, createSmartMCPTools, createTimeoutAbort, createToolFactory, createToolFromZodSchema, createToolWithContext, createTools, createTransformTool, createTransportFromConfig, createValidationTool, createVersioningTools, createWebSearchTool, debuggingTools, detectAntiPatterns, discoverEdgeMCPServers, discoverMCPServersFromEnvironment, dispatchAgents, edgeMCPTransports, executePlan, executeToolSafely, executeWithFallback, finishBranch, getEdgeCompatibleConfigs, getGlobalConnectionManager, getMCPServers, gitTools, globalMCPConnectionPool, globalMCPHealthMonitor, globalMCPToolCache, globalTransportSelector, initSuperpowers, introduceSuperpowers, isAbortError, isEdgeRuntime, manageWorktree, mcpTransports, metaTools, planningTools, processCodeReview, qualityTools, refineRequirements, reviewCode, reviewDesign, runSubagentDev, runTDDCycle, selectOptimalTransport, selectTransportForUseCase, shareSkill, systemPrompts, systematicDebug, tools_exports as t, testMCPConnectivity, testSkill, tiptapContextTool, traceRootCause, validateMCPEnvironment, webSearchTool, webSearchTools, withAbortHandling, withCaching, withRetryAndTimeout, withSWRCaching, withValidation, workflowTools, wrapToolHandler, writeSkill };
+//# sourceMappingURL=tools.mjs.map