@databricks/appkit 0.31.0 → 0.32.0

package/dist/core/agent/run-agent.d.ts

@@ -0,0 +1,34 @@
+import { AgentEvent, Message } from "../../shared/src/agent.js";
+import "../../shared/src/index.js";
+import { AgentDefinition } from "./types.js";
+
+//#region src/core/agent/run-agent.d.ts
+interface RunAgentInput {
+  /** Seed messages for the run. Either a single user string or a full message list. */
+  messages: string | Message[];
+  /** Abort signal for cancellation. */
+  signal?: AbortSignal;
+}
+interface RunAgentResult {
+  /** Aggregated text output from all `message_delta` events. */
+  text: string;
+  /** Every event the adapter yielded, in order. Useful for inspection/tests. */
+  events: AgentEvent[];
+}
+/**
+ * Standalone agent execution without `createApp`. Resolves the adapter, binds
+ * inline tools, and drives the adapter's `run()` loop to completion.
+ *
+ * Limitations vs. running through the agents() plugin:
+ * - No OBO: there is no HTTP request, so plugin tools run as the service
+ *   principal (when they work at all).
+ * - Plugin tools (`ToolkitEntry`) are not supported — they require a live
+ *   `PluginContext` that only exists when registered in a `createApp`
+ *   instance. This function throws a clear error if encountered.
+ * - Sub-agents (`agents: { ... }` on the def) are executed as nested
+ *   `runAgent` calls with no shared thread state.
+ */
+declare function runAgent(def: AgentDefinition, input: RunAgentInput): Promise<RunAgentResult>;
+//#endregion
+export { RunAgentInput, RunAgentResult, runAgent };
+//# sourceMappingURL=run-agent.d.ts.map

package/dist/core/agent/run-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-agent.d.ts","names":[],"sources":["../../../src/core/agent/run-agent.ts"],"mappings":";;;;;UAiBiB,aAAA;;EAEf,QAAA,WAAmB,OAAA;EAFJ;EAIf,MAAA,GAAS,WAAA;AAAA;AAAA,UAGM,cAAA;EALf;EAOA,IAAA;EALA;EAOA,MAAA,EAAQ,UAAA;AAAA;;AAJV;;;;;;;;;AAoBA;;;iBAAsB,QAAA,CACpB,GAAA,EAAK,eAAA,EACL,KAAA,EAAO,aAAA,GACN,OAAA,CAAQ,cAAA"}

package/dist/core/agent/run-agent.js

@@ -0,0 +1,146 @@
+import { consumeAdapterStream } from "./consume-adapter-stream.js";
+import { functionToolToDefinition, isFunctionTool } from "./tools/function-tool.js";
+import { isHostedTool } from "./tools/hosted-tools.js";
+import { isToolkitEntry } from "./types.js";
+import { randomUUID } from "node:crypto";
+
+//#region src/core/agent/run-agent.ts
+/**
+* Standalone agent execution without `createApp`. Resolves the adapter, binds
+* inline tools, and drives the adapter's `run()` loop to completion.
+*
+* Limitations vs. running through the agents() plugin:
+* - No OBO: there is no HTTP request, so plugin tools run as the service
+*   principal (when they work at all).
+* - Plugin tools (`ToolkitEntry`) are not supported — they require a live
+*   `PluginContext` that only exists when registered in a `createApp`
+*   instance. This function throws a clear error if encountered.
+* - Sub-agents (`agents: { ... }` on the def) are executed as nested
+*   `runAgent` calls with no shared thread state.
+*/
+async function runAgent(def, input) {
+	const adapter = await resolveAdapter(def);
+	const messages = normalizeMessages(input.messages, def.instructions);
+	const toolIndex = buildStandaloneToolIndex(def);
+	const tools = Array.from(toolIndex.values()).map((e) => e.def);
+	const signal = input.signal;
+	const executeTool = async (name, args) => {
+		const entry = toolIndex.get(name);
+		if (!entry) throw new Error(`Unknown tool: ${name}`);
+		if (entry.kind === "function") return entry.tool.execute(args);
+		if (entry.kind === "subagent") {
+			const subInput = {
+				messages: typeof args === "object" && args !== null && typeof args.input === "string" ? args.input : JSON.stringify(args),
+				signal
+			};
+			return (await runAgent(entry.agentDef, subInput)).text;
+		}
+		throw new Error(`runAgent: tool "${name}" is a ${entry.kind} tool. Plugin toolkits and MCP tools are only usable via createApp({ plugins: [..., agents(...)] }).`);
+	};
+	const events = [];
+	return {
+		text: await consumeAdapterStream(adapter.run({
+			messages,
+			tools,
+			threadId: randomUUID(),
+			signal
+		}, {
+			executeTool,
+			signal
+		}), {
+			signal,
+			onEvent: (event) => {
+				events.push(event);
+			}
+		}),
+		events
+	};
+}
+async function resolveAdapter(def) {
+	const { model } = def;
+	if (!model) {
+		const { DatabricksAdapter } = await import("../../agents/databricks.js");
+		return DatabricksAdapter.fromModelServing();
+	}
+	if (typeof model === "string") {
+		const { DatabricksAdapter } = await import("../../agents/databricks.js");
+		return DatabricksAdapter.fromModelServing(model);
+	}
+	return await model;
+}
+function normalizeMessages(input, instructions) {
+	const systemMessage = {
+		id: "system",
+		role: "system",
+		content: instructions,
+		createdAt: /* @__PURE__ */ new Date()
+	};
+	if (typeof input === "string") return [systemMessage, {
+		id: randomUUID(),
+		role: "user",
+		content: input,
+		createdAt: /* @__PURE__ */ new Date()
+	}];
+	return [systemMessage, ...input];
+}
+function buildStandaloneToolIndex(def) {
+	const index = /* @__PURE__ */ new Map();
+	for (const [key, tool] of Object.entries(def.tools ?? {})) index.set(key, classifyTool(key, tool));
+	for (const [childKey, child] of Object.entries(def.agents ?? {})) {
+		const toolName = `agent-${childKey}`;
+		index.set(toolName, {
+			kind: "subagent",
+			agentDef: {
+				...child,
+				name: child.name ?? childKey
+			},
+			def: {
+				name: toolName,
+				description: child.instructions.slice(0, 120) || `Delegate to the ${childKey} sub-agent`,
+				parameters: {
+					type: "object",
+					properties: { input: {
+						type: "string",
+						description: "Message to send to the sub-agent."
+					} },
+					required: ["input"]
+				}
+			}
+		});
+	}
+	return index;
+}
+function classifyTool(key, tool) {
+	if (isToolkitEntry(tool)) return {
+		kind: "toolkit",
+		def: {
+			...tool.def,
+			name: key
+		},
+		entry: tool
+	};
+	if (isFunctionTool(tool)) return {
+		kind: "function",
+		tool,
+		def: {
+			...functionToolToDefinition(tool),
+			name: key
+		}
+	};
+	if (isHostedTool(tool)) return {
+		kind: "hosted",
+		def: {
+			name: key,
+			description: `Hosted tool: ${tool.type}`,
+			parameters: {
+				type: "object",
+				properties: {}
+			}
+		}
+	};
+	throw new Error(`runAgent: unrecognized tool shape at key "${key}"`);
+}
+
+//#endregion
+export { runAgent };
+//# sourceMappingURL=run-agent.js.map

package/dist/core/agent/run-agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-agent.js","names":[],"sources":["../../../src/core/agent/run-agent.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport type {\n  AgentAdapter,\n  AgentEvent,\n  AgentToolDefinition,\n  Message,\n} from \"shared\";\nimport { consumeAdapterStream } from \"./consume-adapter-stream\";\nimport {\n  type FunctionTool,\n  functionToolToDefinition,\n  isFunctionTool,\n} from \"./tools/function-tool\";\nimport { isHostedTool } from \"./tools/hosted-tools\";\nimport type { AgentDefinition, AgentTool, ToolkitEntry } from \"./types\";\nimport { isToolkitEntry } from \"./types\";\n\nexport interface RunAgentInput {\n  /** Seed messages for the run. Either a single user string or a full message list. */\n  messages: string | Message[];\n  /** Abort signal for cancellation. */\n  signal?: AbortSignal;\n}\n\nexport interface RunAgentResult {\n  /** Aggregated text output from all `message_delta` events. */\n  text: string;\n  /** Every event the adapter yielded, in order. Useful for inspection/tests. */\n  events: AgentEvent[];\n}\n\n/**\n * Standalone agent execution without `createApp`. Resolves the adapter, binds\n * inline tools, and drives the adapter's `run()` loop to completion.\n *\n * Limitations vs. running through the agents() plugin:\n * - No OBO: there is no HTTP request, so plugin tools run as the service\n *   principal (when they work at all).\n * - Plugin tools (`ToolkitEntry`) are not supported — they require a live\n *   `PluginContext` that only exists when registered in a `createApp`\n *   instance. This function throws a clear error if encountered.\n * - Sub-agents (`agents: { ... }` on the def) are executed as nested\n *   `runAgent` calls with no shared thread state.\n */\nexport async function runAgent(\n  def: AgentDefinition,\n  input: RunAgentInput,\n): Promise<RunAgentResult> {\n  const adapter = await resolveAdapter(def);\n  const messages = normalizeMessages(input.messages, def.instructions);\n  const toolIndex = buildStandaloneToolIndex(def);\n  const tools = Array.from(toolIndex.values()).map((e) => e.def);\n\n  const signal = input.signal;\n\n  const executeTool = async (name: string, args: unknown): Promise<unknown> => {\n    const entry = toolIndex.get(name);\n    if (!entry) throw new Error(`Unknown tool: ${name}`);\n    if (entry.kind === \"function\") {\n      return entry.tool.execute(args as Record<string, unknown>);\n    }\n    if (entry.kind === \"subagent\") {\n      const subInput: RunAgentInput = {\n        messages:\n          typeof args === \"object\" &&\n          args !== null &&\n          typeof (args as { input?: unknown }).input === \"string\"\n            ? (args as { input: string }).input\n            : JSON.stringify(args),\n        signal,\n      };\n      const res = await runAgent(entry.agentDef, subInput);\n      return res.text;\n    }\n    throw new Error(\n      `runAgent: tool \"${name}\" is a ${entry.kind} tool. ` +\n        \"Plugin toolkits and MCP tools are only usable via createApp({ plugins: [..., agents(...)] }).\",\n    );\n  };\n\n  const events: AgentEvent[] = [];\n\n  const stream = adapter.run(\n    {\n      messages,\n      tools,\n      threadId: randomUUID(),\n      signal,\n    },\n    { executeTool, signal },\n  );\n\n  // Shared accumulation rule (deltas append, `message` replaces). The\n  // `events` array is filled via the `onEvent` side effect so callers that\n  // inspect the raw stream still get the full record.\n  const text = await consumeAdapterStream(stream, {\n    signal,\n    onEvent: (event) => {\n      events.push(event);\n    },\n  });\n\n  return { text, events };\n}\n\nasync function resolveAdapter(def: AgentDefinition): Promise<AgentAdapter> {\n  const { model } = def;\n  if (!model) {\n    const { DatabricksAdapter } = await import(\"../../agents/databricks\");\n    return DatabricksAdapter.fromModelServing();\n  }\n  if (typeof model === \"string\") {\n    const { DatabricksAdapter } = await import(\"../../agents/databricks\");\n    return DatabricksAdapter.fromModelServing(model);\n  }\n  return await model;\n}\n\nfunction normalizeMessages(\n  input: string | Message[],\n  instructions: string,\n): Message[] {\n  const systemMessage: Message = {\n    id: \"system\",\n    role: \"system\",\n    content: instructions,\n    createdAt: new Date(),\n  };\n  if (typeof input === \"string\") {\n    return [\n      systemMessage,\n      {\n        id: randomUUID(),\n        role: \"user\",\n        content: input,\n        createdAt: new Date(),\n      },\n    ];\n  }\n  return [systemMessage, ...input];\n}\n\ntype StandaloneEntry =\n  | {\n      kind: \"function\";\n      def: AgentToolDefinition;\n      tool: FunctionTool;\n    }\n  | {\n      kind: \"subagent\";\n      def: AgentToolDefinition;\n      agentDef: AgentDefinition;\n    }\n  | {\n      kind: \"toolkit\";\n      def: AgentToolDefinition;\n      entry: ToolkitEntry;\n    }\n  | {\n      kind: \"hosted\";\n      def: AgentToolDefinition;\n    };\n\nfunction buildStandaloneToolIndex(\n  def: AgentDefinition,\n): Map<string, StandaloneEntry> {\n  const index = new Map<string, StandaloneEntry>();\n\n  for (const [key, tool] of Object.entries(def.tools ?? {})) {\n    index.set(key, classifyTool(key, tool));\n  }\n\n  for (const [childKey, child] of Object.entries(def.agents ?? {})) {\n    const toolName = `agent-${childKey}`;\n    index.set(toolName, {\n      kind: \"subagent\",\n      agentDef: { ...child, name: child.name ?? childKey },\n      def: {\n        name: toolName,\n        description:\n          child.instructions.slice(0, 120) ||\n          `Delegate to the ${childKey} sub-agent`,\n        parameters: {\n          type: \"object\",\n          properties: {\n            input: {\n              type: \"string\",\n              description: \"Message to send to the sub-agent.\",\n            },\n          },\n          required: [\"input\"],\n        },\n      },\n    });\n  }\n\n  return index;\n}\n\nfunction classifyTool(key: string, tool: AgentTool): StandaloneEntry {\n  if (isToolkitEntry(tool)) {\n    return { kind: \"toolkit\", def: { ...tool.def, name: key }, entry: tool };\n  }\n  if (isFunctionTool(tool)) {\n    return {\n      kind: \"function\",\n      tool,\n      def: { ...functionToolToDefinition(tool), name: key },\n    };\n  }\n  if (isHostedTool(tool)) {\n    return {\n      kind: \"hosted\",\n      def: {\n        name: key,\n        description: `Hosted tool: ${tool.type}`,\n        parameters: { type: \"object\", properties: {} },\n      },\n    };\n  }\n  throw new Error(`runAgent: unrecognized tool shape at key \"${key}\"`);\n}\n"],"mappings":"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"}

package/dist/core/agent/system-prompt.js

@@ -0,0 +1,38 @@
+//#region src/core/agent/system-prompt.ts
+/**
+* Default base system prompt: product identity, active AppKit plugins, and
+* tool-agnostic behavior hints.
+*
+* Individual tool definitions and JSON Schemas are still sent through the
+* model's `tools` / function-calling channel — this string is not a second
+* copy of that list. `ctx.toolNames` is available for custom
+* `baseSystemPrompt` callbacks; the default text stays short and does not
+* enumerate tools to avoid drift and token bloat.
+*/
+function buildBaseSystemPrompt(ctx) {
+	const { pluginNames } = ctx;
+	const lines = ["You are an AI assistant running on Databricks AppKit."];
+	if (pluginNames.length > 0) {
+		lines.push("");
+		lines.push(`Active AppKit plugins: ${pluginNames.join(", ")}`);
+	}
+	lines.push("");
+	lines.push("Guidelines:");
+	lines.push("- Be concise: for large or noisy tool output, summarize what matters and how to go deeper instead of pasting everything.");
+	lines.push("- Use each tool as defined: pass required arguments and use the syntax, dialect, or path rules the target system expects (see each tool’s description and schema).");
+	lines.push("- If a tool call fails, explain the error in plain language and suggest a fix or next step.");
+	lines.push("- Respect tool metadata and app policy: read-only vs destructive tools, user/identity context, and any approval or safety flows the app provides.");
+	return lines.join("\n");
+}
+/**
+* Compose the full system prompt from the base prompt and an optional
+* per-agent user prompt.
+*/
+function composeSystemPrompt(basePrompt, agentPrompt) {
+	if (!agentPrompt) return basePrompt;
+	return `${basePrompt}\n\n${agentPrompt}`;
+}
+
+//#endregion
+export { buildBaseSystemPrompt, composeSystemPrompt };
+//# sourceMappingURL=system-prompt.js.map

package/dist/core/agent/system-prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-prompt.js","names":[],"sources":["../../../src/core/agent/system-prompt.ts"],"sourcesContent":["import type { PromptContext } from \"./types\";\n\n/**\n * Default base system prompt: product identity, active AppKit plugins, and\n * tool-agnostic behavior hints.\n *\n * Individual tool definitions and JSON Schemas are still sent through the\n * model's `tools` / function-calling channel — this string is not a second\n * copy of that list. `ctx.toolNames` is available for custom\n * `baseSystemPrompt` callbacks; the default text stays short and does not\n * enumerate tools to avoid drift and token bloat.\n */\nexport function buildBaseSystemPrompt(ctx: PromptContext): string {\n  const { pluginNames } = ctx;\n  const lines: string[] = [\n    \"You are an AI assistant running on Databricks AppKit.\",\n  ];\n\n  if (pluginNames.length > 0) {\n    lines.push(\"\");\n    lines.push(`Active AppKit plugins: ${pluginNames.join(\", \")}`);\n  }\n\n  lines.push(\"\");\n  lines.push(\"Guidelines:\");\n  lines.push(\n    \"- Be concise: for large or noisy tool output, summarize what matters and how to go deeper instead of pasting everything.\",\n  );\n  lines.push(\n    \"- Use each tool as defined: pass required arguments and use the syntax, dialect, or path rules the target system expects (see each tool’s description and schema).\",\n  );\n  lines.push(\n    \"- If a tool call fails, explain the error in plain language and suggest a fix or next step.\",\n  );\n  lines.push(\n    \"- Respect tool metadata and app policy: read-only vs destructive tools, user/identity context, and any approval or safety flows the app provides.\",\n  );\n\n  return lines.join(\"\\n\");\n}\n\n/**\n * Compose the full system prompt from the base prompt and an optional\n * per-agent user prompt.\n */\nexport function composeSystemPrompt(\n  basePrompt: string,\n  agentPrompt?: string,\n): string {\n  if (!agentPrompt) return basePrompt;\n  return `${basePrompt}\\n\\n${agentPrompt}`;\n}\n"],"mappings":";;;;;;;;;;;AAYA,SAAgB,sBAAsB,KAA4B;CAChE,MAAM,EAAE,gBAAgB;CACxB,MAAM,QAAkB,CACtB,wDACD;AAED,KAAI,YAAY,SAAS,GAAG;AAC1B,QAAM,KAAK,GAAG;AACd,QAAM,KAAK,0BAA0B,YAAY,KAAK,KAAK,GAAG;;AAGhE,OAAM,KAAK,GAAG;AACd,OAAM,KAAK,cAAc;AACzB,OAAM,KACJ,2HACD;AACD,OAAM,KACJ,qKACD;AACD,OAAM,KACJ,8FACD;AACD,OAAM,KACJ,oJACD;AAED,QAAO,MAAM,KAAK,KAAK;;;;;;AAOzB,SAAgB,oBACd,YACA,aACQ;AACR,KAAI,CAAC,YAAa,QAAO;AACzB,QAAO,GAAG,WAAW,MAAM"}

package/dist/core/agent/tools/define-tool.d.ts

@@ -0,0 +1,54 @@
+import { AgentToolDefinition, ToolAnnotations } from "../../../shared/src/agent.js";
+import "../../../shared/src/index.js";
+import { z } from "zod";
+
+//#region src/core/agent/tools/define-tool.d.ts
+/**
+ * Single-tool entry for a plugin's internal tool registry.
+ *
+ * Plugins collect these into a `Record<string, ToolEntry>` keyed by the tool's
+ * public name and dispatch via `executeFromRegistry`.
+ */
+interface ToolEntry<S extends z.ZodType = z.ZodType> {
+  description: string;
+  schema: S;
+  annotations?: ToolAnnotations;
+  /**
+   * Whether this tool is eligible for auto-inheritance into markdown or
+   * code-defined agents that enable `autoInheritTools`. Defaults to `false`
+   * (safe-by-default) — plugin authors must explicitly opt a tool in if they
+   * consider it safe enough to appear in every agent's tool record without an
+   * explicit `tools:` declaration. Destructive or privilege-sensitive tools
+   * should leave this unset so that they only reach agents that wire them
+   * explicitly (via `tools:`, `toolkits:`, or `fromPlugin({ only: [...] })`).
+   */
+  autoInheritable?: boolean;
+  handler: (args: z.infer<S>, signal?: AbortSignal) => unknown | Promise<unknown>;
+}
+type ToolRegistry = Record<string, ToolEntry>;
+/**
+ * Defines a single tool entry for a plugin's internal registry.
+ *
+ * The generic `S` flows from `schema` through to the `handler` callback so
+ * `args` is fully typed from the Zod schema. Names are assigned by the
+ * registry key, so they are not repeated inside the entry.
+ */
+declare function defineTool<S extends z.ZodType>(config: ToolEntry<S>): ToolEntry<S>;
+/**
+ * Validates tool-call arguments against the entry's schema and invokes its
+ * handler. On validation failure, returns an LLM-friendly error string
+ * (matching the behavior of `tool()`) rather than throwing, so the model
+ * can self-correct on its next turn.
+ */
+declare function executeFromRegistry(registry: ToolRegistry, name: string, args: unknown, signal?: AbortSignal): Promise<unknown>;
+/**
+ * Produces the `AgentToolDefinition[]` a ToolProvider exposes to the LLM,
+ * deriving `parameters` JSON Schema from each entry's Zod schema.
+ *
+ * Tool names come from registry keys (supports dotted names like
+ * `uploads.list` for dynamic plugins).
+ */
+declare function toolsFromRegistry(registry: ToolRegistry): AgentToolDefinition[];
+//#endregion
+export { ToolEntry, ToolRegistry, defineTool, executeFromRegistry, toolsFromRegistry };
+//# sourceMappingURL=define-tool.d.ts.map

package/dist/core/agent/tools/define-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-tool.d.ts","names":[],"sources":["../../../../src/core/agent/tools/define-tool.ts"],"mappings":";;;;;;;;AAWA;;;UAAiB,SAAA,WAAoB,CAAA,CAAE,OAAA,GAAU,CAAA,CAAE,OAAA;EACjD,WAAA;EACA,MAAA,EAAQ,CAAA;EACR,WAAA,GAAc,eAAA;EAYE;;;;;;;;;EAFhB,eAAA;EACA,OAAA,GACE,IAAA,EAAM,CAAA,CAAE,KAAA,CAAM,CAAA,GACd,MAAA,GAAS,WAAA,eACI,OAAA;AAAA;AAAA,KAGL,YAAA,GAAe,MAAA,SAAe,SAAA;;;;;;;;iBAS1B,UAAA,WAAqB,CAAA,CAAE,OAAA,CAAA,CACrC,MAAA,EAAQ,SAAA,CAAU,CAAA,IACjB,SAAA,CAAU,CAAA;;;;;;;iBAUS,mBAAA,CACpB,QAAA,EAAU,YAAA,EACV,IAAA,UACA,IAAA,WACA,MAAA,GAAS,WAAA,GACR,OAAA;;;;;AAjBH;;;iBAoCgB,iBAAA,CACd,QAAA,EAAU,YAAA,GACT,mBAAA"}

package/dist/core/agent/tools/define-tool.js

@@ -0,0 +1,50 @@
+import { toToolJSONSchema } from "./json-schema.js";
+import { formatZodError } from "./tool.js";
+
+//#region src/core/agent/tools/define-tool.ts
+/**
+* Defines a single tool entry for a plugin's internal registry.
+*
+* The generic `S` flows from `schema` through to the `handler` callback so
+* `args` is fully typed from the Zod schema. Names are assigned by the
+* registry key, so they are not repeated inside the entry.
+*/
+function defineTool(config) {
+	return config;
+}
+/**
+* Validates tool-call arguments against the entry's schema and invokes its
+* handler. On validation failure, returns an LLM-friendly error string
+* (matching the behavior of `tool()`) rather than throwing, so the model
+* can self-correct on its next turn.
+*/
+async function executeFromRegistry(registry, name, args, signal) {
+	const entry = registry[name];
+	if (!entry) throw new Error(`Unknown tool: ${name}`);
+	const parsed = entry.schema.safeParse(args);
+	if (!parsed.success) return formatZodError(parsed.error, name);
+	return entry.handler(parsed.data, signal);
+}
+/**
+* Produces the `AgentToolDefinition[]` a ToolProvider exposes to the LLM,
+* deriving `parameters` JSON Schema from each entry's Zod schema.
+*
+* Tool names come from registry keys (supports dotted names like
+* `uploads.list` for dynamic plugins).
+*/
+function toolsFromRegistry(registry) {
+	return Object.entries(registry).map(([name, entry]) => {
+		const parameters = toToolJSONSchema(entry.schema);
+		const def = {
+			name,
+			description: entry.description,
+			parameters
+		};
+		if (entry.annotations) def.annotations = entry.annotations;
+		return def;
+	});
+}
+
+//#endregion
+export { defineTool, executeFromRegistry, toolsFromRegistry };
+//# sourceMappingURL=define-tool.js.map

package/dist/core/agent/tools/define-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-tool.js","names":[],"sources":["../../../../src/core/agent/tools/define-tool.ts"],"sourcesContent":["import type { AgentToolDefinition, ToolAnnotations } from \"shared\";\nimport type { z } from \"zod\";\nimport { toToolJSONSchema } from \"./json-schema\";\nimport { formatZodError } from \"./tool\";\n\n/**\n * Single-tool entry for a plugin's internal tool registry.\n *\n * Plugins collect these into a `Record<string, ToolEntry>` keyed by the tool's\n * public name and dispatch via `executeFromRegistry`.\n */\nexport interface ToolEntry<S extends z.ZodType = z.ZodType> {\n  description: string;\n  schema: S;\n  annotations?: ToolAnnotations;\n  /**\n   * Whether this tool is eligible for auto-inheritance into markdown or\n   * code-defined agents that enable `autoInheritTools`. Defaults to `false`\n   * (safe-by-default) — plugin authors must explicitly opt a tool in if they\n   * consider it safe enough to appear in every agent's tool record without an\n   * explicit `tools:` declaration. Destructive or privilege-sensitive tools\n   * should leave this unset so that they only reach agents that wire them\n   * explicitly (via `tools:`, `toolkits:`, or `fromPlugin({ only: [...] })`).\n   */\n  autoInheritable?: boolean;\n  handler: (\n    args: z.infer<S>,\n    signal?: AbortSignal,\n  ) => unknown | Promise<unknown>;\n}\n\nexport type ToolRegistry = Record<string, ToolEntry>;\n\n/**\n * Defines a single tool entry for a plugin's internal registry.\n *\n * The generic `S` flows from `schema` through to the `handler` callback so\n * `args` is fully typed from the Zod schema. Names are assigned by the\n * registry key, so they are not repeated inside the entry.\n */\nexport function defineTool<S extends z.ZodType>(\n  config: ToolEntry<S>,\n): ToolEntry<S> {\n  return config;\n}\n\n/**\n * Validates tool-call arguments against the entry's schema and invokes its\n * handler. On validation failure, returns an LLM-friendly error string\n * (matching the behavior of `tool()`) rather than throwing, so the model\n * can self-correct on its next turn.\n */\nexport async function executeFromRegistry(\n  registry: ToolRegistry,\n  name: string,\n  args: unknown,\n  signal?: AbortSignal,\n): Promise<unknown> {\n  const entry = registry[name];\n  if (!entry) {\n    throw new Error(`Unknown tool: ${name}`);\n  }\n  const parsed = entry.schema.safeParse(args);\n  if (!parsed.success) {\n    return formatZodError(parsed.error, name);\n  }\n  return entry.handler(parsed.data, signal);\n}\n\n/**\n * Produces the `AgentToolDefinition[]` a ToolProvider exposes to the LLM,\n * deriving `parameters` JSON Schema from each entry's Zod schema.\n *\n * Tool names come from registry keys (supports dotted names like\n * `uploads.list` for dynamic plugins).\n */\nexport function toolsFromRegistry(\n  registry: ToolRegistry,\n): AgentToolDefinition[] {\n  return Object.entries(registry).map(([name, entry]) => {\n    const parameters = toToolJSONSchema(\n      entry.schema,\n    ) as unknown as AgentToolDefinition[\"parameters\"];\n    const def: AgentToolDefinition = {\n      name,\n      description: entry.description,\n      parameters,\n    };\n    if (entry.annotations) {\n      def.annotations = entry.annotations;\n    }\n    return def;\n  });\n}\n"],"mappings":";;;;;;;;;;;AAwCA,SAAgB,WACd,QACc;AACd,QAAO;;;;;;;;AAST,eAAsB,oBACpB,UACA,MACA,MACA,QACkB;CAClB,MAAM,QAAQ,SAAS;AACvB,KAAI,CAAC,MACH,OAAM,IAAI,MAAM,iBAAiB,OAAO;CAE1C,MAAM,SAAS,MAAM,OAAO,UAAU,KAAK;AAC3C,KAAI,CAAC,OAAO,QACV,QAAO,eAAe,OAAO,OAAO,KAAK;AAE3C,QAAO,MAAM,QAAQ,OAAO,MAAM,OAAO;;;;;;;;;AAU3C,SAAgB,kBACd,UACuB;AACvB,QAAO,OAAO,QAAQ,SAAS,CAAC,KAAK,CAAC,MAAM,WAAW;EACrD,MAAM,aAAa,iBACjB,MAAM,OACP;EACD,MAAM,MAA2B;GAC/B;GACA,aAAa,MAAM;GACnB;GACD;AACD,MAAI,MAAM,YACR,KAAI,cAAc,MAAM;AAE1B,SAAO;GACP"}

package/dist/core/agent/tools/function-tool.d.ts

@@ -0,0 +1,27 @@
+import { AgentToolDefinition, ToolAnnotations } from "../../../shared/src/agent.js";
+import "../../../shared/src/index.js";
+
+//#region src/core/agent/tools/function-tool.d.ts
+interface FunctionTool {
+  type: "function";
+  name: string;
+  description?: string | null;
+  parameters?: Record<string, unknown> | null;
+  strict?: boolean | null;
+  /**
+   * Behavioural hints that drive the agents plugin's approval gate and the
+   * client's approval-card styling. Prefer setting `effect` (one of
+   * `"read" | "write" | "update" | "destructive"`) — any mutating value
+   * forces HITL approval before `execute()` runs. Legacy `destructive: true`
+   * is still honoured. Must be preserved through {@link
+   * functionToolToDefinition} so the plugin sees them when building agent
+   * tool indexes.
+   */
+  annotations?: ToolAnnotations;
+  execute: (args: Record<string, unknown>) => Promise<string> | string;
+}
+declare function isFunctionTool(value: unknown): value is FunctionTool;
+declare function functionToolToDefinition(tool: FunctionTool): AgentToolDefinition;
+//#endregion
+export { FunctionTool, functionToolToDefinition, isFunctionTool };
+//# sourceMappingURL=function-tool.d.ts.map

package/dist/core/agent/tools/function-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-tool.d.ts","names":[],"sources":["../../../../src/core/agent/tools/function-tool.ts"],"mappings":";;;;UAEiB,YAAA;EACf,IAAA;EACA,IAAA;EACA,WAAA;EACA,UAAA,GAAa,MAAA;EACb,MAAA;EADa;;;;;;;;;EAWb,WAAA,GAAc,eAAA;EACd,OAAA,GAAU,IAAA,EAAM,MAAA,sBAA4B,OAAA;AAAA;AAAA,iBAG9B,cAAA,CAAe,KAAA,YAAiB,KAAA,IAAS,YAAA;AAAA,iBAUzC,wBAAA,CACd,IAAA,EAAM,YAAA,GACL,mBAAA"}

package/dist/core/agent/tools/function-tool.js

@@ -0,0 +1,21 @@
+//#region src/core/agent/tools/function-tool.ts
+function isFunctionTool(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const obj = value;
+	return obj.type === "function" && typeof obj.name === "string" && typeof obj.execute === "function";
+}
+function functionToolToDefinition(tool) {
+	return {
+		name: tool.name,
+		description: tool.description ?? tool.name,
+		parameters: tool.parameters ?? {
+			type: "object",
+			properties: {}
+		},
+		...tool.annotations ? { annotations: tool.annotations } : {}
+	};
+}
+
+//#endregion
+export { functionToolToDefinition, isFunctionTool };
+//# sourceMappingURL=function-tool.js.map

package/dist/core/agent/tools/function-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"function-tool.js","names":[],"sources":["../../../../src/core/agent/tools/function-tool.ts"],"sourcesContent":["import type { AgentToolDefinition, ToolAnnotations } from \"shared\";\n\nexport interface FunctionTool {\n  type: \"function\";\n  name: string;\n  description?: string | null;\n  parameters?: Record<string, unknown> | null;\n  strict?: boolean | null;\n  /**\n   * Behavioural hints that drive the agents plugin's approval gate and the\n   * client's approval-card styling. Prefer setting `effect` (one of\n   * `\"read\" | \"write\" | \"update\" | \"destructive\"`) — any mutating value\n   * forces HITL approval before `execute()` runs. Legacy `destructive: true`\n   * is still honoured. Must be preserved through {@link\n   * functionToolToDefinition} so the plugin sees them when building agent\n   * tool indexes.\n   */\n  annotations?: ToolAnnotations;\n  execute: (args: Record<string, unknown>) => Promise<string> | string;\n}\n\nexport function isFunctionTool(value: unknown): value is FunctionTool {\n  if (typeof value !== \"object\" || value === null) return false;\n  const obj = value as Record<string, unknown>;\n  return (\n    obj.type === \"function\" &&\n    typeof obj.name === \"string\" &&\n    typeof obj.execute === \"function\"\n  );\n}\n\nexport function functionToolToDefinition(\n  tool: FunctionTool,\n): AgentToolDefinition {\n  return {\n    name: tool.name,\n    description: tool.description ?? tool.name,\n    parameters: (tool.parameters as AgentToolDefinition[\"parameters\"]) ?? {\n      type: \"object\",\n      properties: {},\n    },\n    ...(tool.annotations ? { annotations: tool.annotations } : {}),\n  };\n}\n"],"mappings":";AAqBA,SAAgB,eAAe,OAAuC;AACpE,KAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;CACxD,MAAM,MAAM;AACZ,QACE,IAAI,SAAS,cACb,OAAO,IAAI,SAAS,YACpB,OAAO,IAAI,YAAY;;AAI3B,SAAgB,yBACd,MACqB;AACrB,QAAO;EACL,MAAM,KAAK;EACX,aAAa,KAAK,eAAe,KAAK;EACtC,YAAa,KAAK,cAAoD;GACpE,MAAM;GACN,YAAY,EAAE;GACf;EACD,GAAI,KAAK,cAAc,EAAE,aAAa,KAAK,aAAa,GAAG,EAAE;EAC9D"}

package/dist/core/agent/tools/hosted-tools.d.ts

@@ -0,0 +1,47 @@
+import { McpEndpointConfig } from "../../../connectors/mcp/types.js";
+import "../../../connectors/mcp/index.js";
+
+//#region src/core/agent/tools/hosted-tools.d.ts
+interface GenieTool {
+  type: "genie-space";
+  genie_space: {
+    id: string;
+  };
+}
+interface VectorSearchIndexTool {
+  type: "vector_search_index";
+  vector_search_index: {
+    name: string;
+  };
+}
+interface CustomMcpServerTool {
+  type: "custom_mcp_server";
+  custom_mcp_server: {
+    app_name: string;
+    app_url: string;
+  };
+}
+interface ExternalMcpServerTool {
+  type: "external_mcp_server";
+  external_mcp_server: {
+    connection_name: string;
+  };
+}
+type HostedTool = GenieTool | VectorSearchIndexTool | CustomMcpServerTool | ExternalMcpServerTool;
+declare function isHostedTool(value: unknown): value is HostedTool;
+declare function resolveHostedTools(tools: HostedTool[]): McpEndpointConfig[];
+/**
+ * Factory for declaring a custom MCP server tool.
+ *
+ * Replaces the verbose `{ type: "custom_mcp_server", custom_mcp_server: { app_name, app_url } }`
+ * wrapper with a concise positional call.
+ *
+ * Example:
+ * ```ts
+ * mcpServer("my-app", "https://my-app.databricksapps.com/mcp")
+ * ```
+ */
+declare function mcpServer(name: string, url: string): CustomMcpServerTool;
+//#endregion
+export { HostedTool, isHostedTool, mcpServer, resolveHostedTools };
+//# sourceMappingURL=hosted-tools.d.ts.map

package/dist/core/agent/tools/hosted-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-tools.d.ts","names":[],"sources":["../../../../src/core/agent/tools/hosted-tools.ts"],"mappings":";;;;UAEiB,SAAA;EACf,IAAA;EACA,WAAA;IAAe,EAAA;EAAA;AAAA;AAAA,UAGA,qBAAA;EACf,IAAA;EACA,mBAAA;IAAuB,IAAA;EAAA;AAAA;AAAA,UAGR,mBAAA;EACf,IAAA;EACA,iBAAA;IAAqB,QAAA;IAAkB,OAAA;EAAA;AAAA;AAAA,UAGxB,qBAAA;EACf,IAAA;EACA,mBAAA;IAAuB,eAAA;EAAA;AAAA;AAAA,KAGb,UAAA,GACR,SAAA,GACA,qBAAA,GACA,mBAAA,GACA,qBAAA;AAAA,iBASY,YAAA,CAAa,KAAA,YAAiB,KAAA,IAAS,UAAA;AAAA,iBA0CvC,kBAAA,CAAmB,KAAA,EAAO,UAAA,KAAe,iBAAA;;;;AA5DzD;;;;;;;;iBA2EgB,SAAA,CAAU,IAAA,UAAc,GAAA,WAAc,mBAAA"}

package/dist/core/agent/tools/hosted-tools.js

@@ -0,0 +1,67 @@
+//#region src/core/agent/tools/hosted-tools.ts
+const HOSTED_TOOL_TYPES = new Set([
+	"genie-space",
+	"vector_search_index",
+	"custom_mcp_server",
+	"external_mcp_server"
+]);
+function isHostedTool(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const obj = value;
+	return typeof obj.type === "string" && HOSTED_TOOL_TYPES.has(obj.type);
+}
+/**
+* Resolves HostedTool configs into MCP endpoint configurations
+* that the MCP client can connect to.
+*/
+function resolveHostedTool(tool) {
+	switch (tool.type) {
+		case "genie-space": return {
+			name: `genie-${tool.genie_space.id}`,
+			url: `/api/2.0/mcp/genie/${tool.genie_space.id}`
+		};
+		case "vector_search_index": {
+			const parts = tool.vector_search_index.name.split(".");
+			if (parts.length !== 3) throw new Error(`vector_search_index name must be 3-part dotted (catalog.schema.index), got: ${tool.vector_search_index.name}`);
+			return {
+				name: `vs-${parts.join("-")}`,
+				url: `/api/2.0/mcp/vector-search/${parts[0]}/${parts[1]}/${parts[2]}`
+			};
+		}
+		case "custom_mcp_server": return {
+			name: tool.custom_mcp_server.app_name,
+			url: tool.custom_mcp_server.app_url
+		};
+		case "external_mcp_server": return {
+			name: tool.external_mcp_server.connection_name,
+			url: `/api/2.0/mcp/external/${tool.external_mcp_server.connection_name}`
+		};
+	}
+}
+function resolveHostedTools(tools) {
+	return tools.map(resolveHostedTool);
+}
+/**
+* Factory for declaring a custom MCP server tool.
+*
+* Replaces the verbose `{ type: "custom_mcp_server", custom_mcp_server: { app_name, app_url } }`
+* wrapper with a concise positional call.
+*
+* Example:
+* ```ts
+* mcpServer("my-app", "https://my-app.databricksapps.com/mcp")
+* ```
+*/
+function mcpServer(name, url) {
+	return {
+		type: "custom_mcp_server",
+		custom_mcp_server: {
+			app_name: name,
+			app_url: url
+		}
+	};
+}
+
+//#endregion
+export { isHostedTool, mcpServer, resolveHostedTools };
+//# sourceMappingURL=hosted-tools.js.map

package/dist/core/agent/tools/hosted-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hosted-tools.js","names":[],"sources":["../../../../src/core/agent/tools/hosted-tools.ts"],"sourcesContent":["import type { McpEndpointConfig } from \"../../../connectors/mcp\";\n\nexport interface GenieTool {\n  type: \"genie-space\";\n  genie_space: { id: string };\n}\n\nexport interface VectorSearchIndexTool {\n  type: \"vector_search_index\";\n  vector_search_index: { name: string };\n}\n\nexport interface CustomMcpServerTool {\n  type: \"custom_mcp_server\";\n  custom_mcp_server: { app_name: string; app_url: string };\n}\n\nexport interface ExternalMcpServerTool {\n  type: \"external_mcp_server\";\n  external_mcp_server: { connection_name: string };\n}\n\nexport type HostedTool =\n  | GenieTool\n  | VectorSearchIndexTool\n  | CustomMcpServerTool\n  | ExternalMcpServerTool;\n\nconst HOSTED_TOOL_TYPES = new Set([\n  \"genie-space\",\n  \"vector_search_index\",\n  \"custom_mcp_server\",\n  \"external_mcp_server\",\n]);\n\nexport function isHostedTool(value: unknown): value is HostedTool {\n  if (typeof value !== \"object\" || value === null) return false;\n  const obj = value as Record<string, unknown>;\n  return typeof obj.type === \"string\" && HOSTED_TOOL_TYPES.has(obj.type);\n}\n\n/**\n * Resolves HostedTool configs into MCP endpoint configurations\n * that the MCP client can connect to.\n */\nfunction resolveHostedTool(tool: HostedTool): McpEndpointConfig {\n  switch (tool.type) {\n    case \"genie-space\":\n      return {\n        name: `genie-${tool.genie_space.id}`,\n        url: `/api/2.0/mcp/genie/${tool.genie_space.id}`,\n      };\n    case \"vector_search_index\": {\n      const parts = tool.vector_search_index.name.split(\".\");\n      if (parts.length !== 3) {\n        throw new Error(\n          `vector_search_index name must be 3-part dotted (catalog.schema.index), got: ${tool.vector_search_index.name}`,\n        );\n      }\n      return {\n        name: `vs-${parts.join(\"-\")}`,\n        url: `/api/2.0/mcp/vector-search/${parts[0]}/${parts[1]}/${parts[2]}`,\n      };\n    }\n    case \"custom_mcp_server\":\n      return {\n        name: tool.custom_mcp_server.app_name,\n        url: tool.custom_mcp_server.app_url,\n      };\n    case \"external_mcp_server\":\n      return {\n        name: tool.external_mcp_server.connection_name,\n        url: `/api/2.0/mcp/external/${tool.external_mcp_server.connection_name}`,\n      };\n  }\n}\n\nexport function resolveHostedTools(tools: HostedTool[]): McpEndpointConfig[] {\n  return tools.map(resolveHostedTool);\n}\n\n/**\n * Factory for declaring a custom MCP server tool.\n *\n * Replaces the verbose `{ type: \"custom_mcp_server\", custom_mcp_server: { app_name, app_url } }`\n * wrapper with a concise positional call.\n *\n * Example:\n * ```ts\n * mcpServer(\"my-app\", \"https://my-app.databricksapps.com/mcp\")\n * ```\n */\nexport function mcpServer(name: string, url: string): CustomMcpServerTool {\n  return {\n    type: \"custom_mcp_server\",\n    custom_mcp_server: { app_name: name, app_url: url },\n  };\n}\n"],"mappings":";AA4BA,MAAM,oBAAoB,IAAI,IAAI;CAChC;CACA;CACA;CACA;CACD,CAAC;AAEF,SAAgB,aAAa,OAAqC;AAChE,KAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;CACxD,MAAM,MAAM;AACZ,QAAO,OAAO,IAAI,SAAS,YAAY,kBAAkB,IAAI,IAAI,KAAK;;;;;;AAOxE,SAAS,kBAAkB,MAAqC;AAC9D,SAAQ,KAAK,MAAb;EACE,KAAK,cACH,QAAO;GACL,MAAM,SAAS,KAAK,YAAY;GAChC,KAAK,sBAAsB,KAAK,YAAY;GAC7C;EACH,KAAK,uBAAuB;GAC1B,MAAM,QAAQ,KAAK,oBAAoB,KAAK,MAAM,IAAI;AACtD,OAAI,MAAM,WAAW,EACnB,OAAM,IAAI,MACR,+EAA+E,KAAK,oBAAoB,OACzG;AAEH,UAAO;IACL,MAAM,MAAM,MAAM,KAAK,IAAI;IAC3B,KAAK,8BAA8B,MAAM,GAAG,GAAG,MAAM,GAAG,GAAG,MAAM;IAClE;;EAEH,KAAK,oBACH,QAAO;GACL,MAAM,KAAK,kBAAkB;GAC7B,KAAK,KAAK,kBAAkB;GAC7B;EACH,KAAK,sBACH,QAAO;GACL,MAAM,KAAK,oBAAoB;GAC/B,KAAK,yBAAyB,KAAK,oBAAoB;GACxD;;;AAIP,SAAgB,mBAAmB,OAA0C;AAC3E,QAAO,MAAM,IAAI,kBAAkB;;;;;;;;;;;;;AAcrC,SAAgB,UAAU,MAAc,KAAkC;AACxE,QAAO;EACL,MAAM;EACN,mBAAmB;GAAE,UAAU;GAAM,SAAS;GAAK;EACpD"}

package/dist/core/agent/tools/index.d.ts

@@ -0,0 +1,5 @@
+import { AppKitMcpClient } from "../../../connectors/mcp/client.js";
+import { FunctionTool, functionToolToDefinition, isFunctionTool } from "./function-tool.js";
+import { HostedTool, isHostedTool, mcpServer, resolveHostedTools } from "./hosted-tools.js";
+import { ToolEntry, ToolRegistry, defineTool, executeFromRegistry, toolsFromRegistry } from "./define-tool.js";
+import { ToolConfig, tool } from "./tool.js";

package/dist/core/agent/tools/index.js

@@ -0,0 +1,7 @@
+import { AppKitMcpClient } from "../../../connectors/mcp/client.js";
+import { tool } from "./tool.js";
+import { defineTool, executeFromRegistry, toolsFromRegistry } from "./define-tool.js";
+import { functionToolToDefinition, isFunctionTool } from "./function-tool.js";
+import { isHostedTool, mcpServer, resolveHostedTools } from "./hosted-tools.js";
+
+export {  };

package/dist/core/agent/tools/json-schema.js

@@ -0,0 +1,24 @@
+import { toJSONSchema } from "zod";
+
+//#region src/core/agent/tools/json-schema.ts
+/**
+* Converts a Zod schema to JSON Schema suitable for an LLM tool-call
+* `parameters` field.
+*
+* Wraps `zod`'s `toJSONSchema()` and strips the top-level `$schema` annotation
+* that Zod v4 emits by default (e.g. `"https://json-schema.org/draft/..."`).
+* The Databricks Mosaic serving endpoint forwards tool schemas to Google's
+* Gemini `function_declarations` format, which rejects any top-level key it
+* doesn't explicitly recognize — including `$schema` — with a 400
+* `Invalid JSON payload received. Unknown name "$schema"` error. Other LLM
+* providers either ignore the field or also trip on it, so stripping here is
+* safe across backends.
+*/
+function toToolJSONSchema(schema) {
+	const { $schema: _ignored, ...rest } = toJSONSchema(schema);
+	return rest;
+}
+
+//#endregion
+export { toToolJSONSchema };
+//# sourceMappingURL=json-schema.js.map

package/dist/core/agent/tools/json-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.js","names":[],"sources":["../../../../src/core/agent/tools/json-schema.ts"],"sourcesContent":["import { toJSONSchema, type z } from \"zod\";\n\n/**\n * Converts a Zod schema to JSON Schema suitable for an LLM tool-call\n * `parameters` field.\n *\n * Wraps `zod`'s `toJSONSchema()` and strips the top-level `$schema` annotation\n * that Zod v4 emits by default (e.g. `\"https://json-schema.org/draft/...\"`).\n * The Databricks Mosaic serving endpoint forwards tool schemas to Google's\n * Gemini `function_declarations` format, which rejects any top-level key it\n * doesn't explicitly recognize — including `$schema` — with a 400\n * `Invalid JSON payload received. Unknown name \"$schema\"` error. Other LLM\n * providers either ignore the field or also trip on it, so stripping here is\n * safe across backends.\n */\nexport function toToolJSONSchema(schema: z.ZodType): Record<string, unknown> {\n  const raw = toJSONSchema(schema) as Record<string, unknown>;\n  const { $schema: _ignored, ...rest } = raw;\n  return rest;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,SAAgB,iBAAiB,QAA4C;CAE3E,MAAM,EAAE,SAAS,UAAU,GAAG,SADlB,aAAa,OAAO;AAEhC,QAAO"}