@dbx-tools/appkit-mastra 0.3.44 → 0.4.1

package/lib/src/agents.js

@@ -0,0 +1,554 @@
+/**
+ * Agent registration for the Mastra AppKit plugin.
+ *
+ * Mirrors the shape of the AppKit `agents` plugin (`config.agents` map
+ * of {@link MastraAgentDefinition}, dual-form `tools` accepting a plain
+ * record or a `(plugins) => tools` callback). Resolves each definition
+ * into a Mastra `Agent` instance during plugin setup; user-supplied
+ * tool callbacks are invoked exactly once with a typed
+ * {@link MastraPlugins} map built from registered sibling plugins.
+ *
+ * When no agents are registered the plugin falls back to a single
+ * built-in analyst so the bare `mastra()` call still mounts a working
+ * streamable agent for demos.
+ *
+ * @module
+ */
+import { ConfigurationError } from "@databricks/appkit";
+import { fallback } from "@dbx-tools/model";
+import { object, string } from "@dbx-tools/shared-core";
+import { Agent } from "@mastra/core/agent";
+import { createTool } from "@mastra/core/tools";
+import { buildRenderDataTool } from "./chart.js";
+import { buildGenieToolkitProvider, resolveGenieSpaces } from "./genie.js";
+import { buildModel } from "./model.js";
+import { ResultProcessor, stripStaleChartsProcessor } from "./processors.js";
+import { buildSummarizeTool } from "./summarize.js";
+import { createWorkspace } from "./workspaces.js";
+/** Re-export of Mastra's native `createTool` for full-feature access. */
+export { createTool } from "@mastra/core/tools";
+/**
+ * AppKit-shaped tool factory. Lets users mix-and-match tools across
+ * AppKit's `agents` plugin and `mastra` with a single import:
+ *
+ * ```ts
+ * import { tool } from "@dbx-tools/appkit-mastra";
+ * import { z } from "zod";
+ *
+ * get_weather: tool({
+ *   description: "Weather",
+ *   schema: z.object({ city: z.string() }),
+ *   execute: async ({ city }) => `Sunny in ${city}`,
+ * }),
+ * ```
+ *
+ * Maps onto Mastra's `createTool`:
+ *
+ * - `description` -> `description` (required)
+ * - `schema` -> `inputSchema` (optional)
+ * - `execute(input)` -> `execute(input, ctx)` - Mastra already calls
+ *   the first arg with the parsed inputs, so the body shape is
+ *   identical. The Mastra `context` arg is forwarded as the second
+ *   parameter when the caller declares it.
+ * - `id`: optional. Defaults to a stable identifier derived from
+ *   `description` (slugified, with a short hash suffix for
+ *   uniqueness). Pass an explicit `id` when you need a stable string
+ *   for tracing or MCP exposure.
+ *
+ * Reach for {@link createTool} when you need Mastra-only fields
+ * (`outputSchema`, `suspendSchema`, `requireApproval`, `mcp`, etc.).
+ */
+export function tool(opts) {
+    const id = opts.id ?? deriveToolId(opts.description);
+    return createTool({
+        id,
+        description: opts.description,
+        ...(opts.schema ? { inputSchema: opts.schema } : {}),
+        execute: opts.execute,
+    });
+}
+/**
+ * Build a deterministic Mastra tool id from a description.
+ * Delegates to {@link string.toUniqueSlug}: slug + always-on
+ * 6-char FNV-1a base-32 suffix so two tools with the same leading
+ * words don't collide in traces. Stable across runs.
+ */
+function deriveToolId(description) {
+    return string.toUniqueSlug(description, { fallbackPrefix: "tool" });
+}
+/**
+ * Identity helper that brands a definition as a Mastra agent. Mirrors
+ * AppKit's `createAgent(def)` so the registration shape matches:
+ *
+ * ```ts
+ * const support = createAgent({
+ *   instructions: "...",
+ *   model: "databricks-claude-sonnet-4-6",
+ *   tools(plugins) { return { ... }; },
+ * });
+ * ```
+ *
+ * Returns the definition unchanged - the wrapper exists only to anchor
+ * type inference and to match the AppKit API surface.
+ */
+export function createAgent(def) {
+    const workspace = def.workspace ?? createWorkspace();
+    return { ...def, workspace };
+}
+/** Fallback agent id used when `config.agents` is omitted entirely. */
+export const FALLBACK_AGENT_ID = "default";
+/**
+ * Default per-turn step ceiling applied to every registered agent
+ * when {@link MastraPluginConfig.agentMaxSteps} is unset. Sized to
+ * fit a decomposed Genie turn (grounding + several `ask_genie`
+ * calls + `prepare_chart` per dataset + the final-text reply) with
+ * headroom for the model to chain a couple of follow-ups before
+ * answering - well above Mastra's own `agent.generate` default of
+ * 5, which would cut multi-step orchestration off mid-loop.
+ */
+export const DEFAULT_AGENT_MAX_STEPS = 25;
+const FALLBACK_AGENT_INSTRUCTIONS = `You are a data analyst. The user will ask questions about
+business metrics and may share personal preferences you should remember across turns.
+
+Rules:
+
+1. Quote numbers exactly. Never invent data.
+2. When the user states a preference or durable fact about themselves
+   ("I'm in EU so use EUR", "always show me the SQL"), acknowledge that
+   you will remember it.
+3. If you don't have enough information to answer, ask a clarifying
+   question instead of guessing.`;
+/**
+ * Style guardrails appended to every agent's `instructions` to curb
+ * common LLM-isms (em dashes, emojis, sycophantic openers, excessive
+ * hedging, throwaway closers). Appended rather than prepended so the
+ * agent's role/context comes first; the model's recency bias then
+ * helps the style rules dominate the response surface.
+ *
+ * Override globally via {@link MastraPluginConfig.styleInstructions}
+ * (pass `false` to disable entirely, or a string to replace).
+ */
+export const DEFAULT_STYLE_INSTRUCTIONS = [
+    "Output style:",
+    "",
+    "Use markdown formatting, including headings, lists, and code blocks.",
+    "Avoid lists and headers for short replies.",
+    "Plain prose.",
+    "Use hyphens (-) only. Never use em dashes or en dashes.",
+    "Never use emojis.",
+    "Skip openers like 'Great question', 'Absolutely', and 'I'd be happy to help'.",
+    "Skip closers like 'Let me know if you have any questions'.",
+    "Skip self-disclaimers like 'I should mention' and 'It's important to note'.",
+    "Answer directly.",
+    "Do not include a preamble before the actual answer.",
+    "Use lists and headers only when they clarify a multi-part answer.",
+].join("\n");
+/**
+ * Resolve the style block to append to every agent's instructions.
+ * Returns `null` when the caller opted out (`styleInstructions: false`).
+ */
+function resolveStyleInstructions(config) {
+    if (config.styleInstructions === false)
+        return null;
+    if (typeof config.styleInstructions === "string") {
+        return config.styleInstructions;
+    }
+    return DEFAULT_STYLE_INSTRUCTIONS;
+}
+/**
+ * Join an agent's bespoke instructions with the resolved style block.
+ * Returns the bespoke text unchanged when the style block is disabled.
+ */
+function composeInstructions(agentInstructions, style) {
+    if (!style)
+        return agentInstructions;
+    return `${agentInstructions.trimEnd()}\n\n${style}`;
+}
+/**
+ * Generated description for an agent whose definition omits one. Kept
+ * generic (the agent's own name is the only reliable signal at build
+ * time) so it reads sensibly as the `ask_<id>` MCP tool's description
+ * and in agent metadata.
+ */
+function defaultAgentDescription(name) {
+    return `Conversational AI agent "${name}".`;
+}
+/**
+ * Resolve every entry in `config.agents` into a Mastra `Agent`
+ * instance. When `config.agents` is omitted the plugin registers a
+ * single built-in `default` analyst so the bare `mastra()` call still
+ * yields a working agent.
+ *
+ * Per-agent tool callbacks are invoked once with a typed
+ * {@link MastraPlugins} index built from registered sibling plugins
+ * (currently `genie`; extend `MastraPlugins` to surface more).
+ *
+ * @throws when `config.defaultAgent` is set to an id that isn't in the
+ *   resolved registry; this is a wiring bug, not a runtime condition.
+ */
+export async function buildAgents(opts) {
+    const { config, context, memoryBuilder, log } = opts;
+    const definitions = resolveDefinitions(config);
+    const ids = Object.keys(definitions);
+    const defaultAgentId = config.defaultAgent ?? ids[0] ?? FALLBACK_AGENT_ID;
+    const plugins = buildPluginsMap(config, context);
+    // System-default ambient tools every agent gets out of the box:
+    // `render_data` for inline visualizations and `summarize` for
+    // offloading text condensing to the fast / small chat tier. The
+    // user can shadow either by including a same-named tool in their own
+    // `config.tools` or per-agent `tools`. Order in {@link resolveTools}
+    // is `system -> user-ambient -> per-agent`, last write wins.
+    const systemTools = {
+        render_data: buildRenderDataTool(config),
+        summarize: buildSummarizeTool(config),
+    };
+    const ambientTools = {
+        ...systemTools,
+        ...(config.tools ?? {}),
+    };
+    const style = resolveStyleInstructions(config);
+    // Default-on protection against the model copying turn-scoped
+    // chartIds from prior assistant tool results into the new
+    // turn's `[chart:<id>]` markers. Opt out per-plugin via
+    // `config.stripStaleCharts: false`.
+    const outputProcessors = [new ResultProcessor()];
+    const inputProcessors = [
+        ...(config.stripStaleCharts === false ? [] : [stripStaleChartsProcessor]),
+    ];
+    const agents = {};
+    const defaultModels = {};
+    const approvalGatedByAgent = [];
+    for (const [id, def] of Object.entries(definitions)) {
+        const tools = await resolveTools(def.tools, plugins, ambientTools);
+        const workspace = resolveAgentWorkspace(def.workspace);
+        const gated = approvalGatedToolIds(tools);
+        if (gated.length > 0)
+            approvalGatedByAgent.push({ agentId: id, toolIds: gated });
+        const memory = memoryBuilder?.forAgent(id, def);
+        agents[id] = new Agent({
+            id,
+            name: def.name ?? id,
+            // Always carry a non-empty description: it's surfaced to MCP
+            // clients (which reject a description-less agent) and in agent
+            // metadata. Fall back to a generated one when the definition
+            // omits it.
+            description: def.description?.trim() || defaultAgentDescription(def.name ?? id),
+            instructions: composeInstructions(def.instructions, style),
+            model: resolveModel(config, def.model),
+            defaultOptions: {
+                maxSteps: config.agentMaxSteps ?? DEFAULT_AGENT_MAX_STEPS,
+            },
+            tools,
+            ...(memory ? { memory } : {}),
+            ...(workspace ? { workspace } : {}),
+            inputProcessors,
+            outputProcessors,
+        });
+        // Surface the effective default model per agent so operators can
+        // see at a glance which endpoint each agent points at without
+        // having to fire a request and inspect a trace. The value is the
+        // *static* default; per-request overrides (header / query /
+        // body) and the workspace-catalogue fuzzy match still apply at
+        // call time.
+        const defaultModel = describeAgentDefaultModel(config, def);
+        defaultModels[id] = defaultModel;
+        log.info("agent registered", {
+            id,
+            name: def.name ?? id,
+            defaultModel,
+            tools: Object.keys(tools),
+        });
+    }
+    if (!agents[defaultAgentId]) {
+        throw ConfigurationError.resourceNotFound(`mastra defaultAgent "${defaultAgentId}"`, `Registered agents: ${ids.join(", ") || "none"}.`);
+    }
+    assertApprovalGatedToolsHaveStorage(approvalGatedByAgent, memoryBuilder);
+    log.info("agents ready", { ids, defaultAgentId });
+    return { agents, defaultAgentId, defaultModels, ambientTools };
+}
+/**
+ * Tool ids on `tools` that are approval-gated (`requireApproval: true`).
+ * Keys are used as a fallback when a tool omits an explicit `id`.
+ */
+export function approvalGatedToolIds(tools) {
+    if (!tools || typeof tools !== "object")
+        return [];
+    return [
+        ...object
+            .sequence(Object.entries(tools))
+            .filter(([, tool]) => isApprovalGatedTool(tool))
+            .map(([key, tool]) => resolveToolId(tool, key)),
+    ];
+}
+/** True when a Mastra / AI SDK tool pauses for human approval before execute. */
+function isApprovalGatedTool(tool) {
+    if (!tool || typeof tool !== "object")
+        return false;
+    return tool.requireApproval === true;
+}
+function resolveToolId(tool, fallbackKey) {
+    if (tool && typeof tool === "object" && typeof tool.id === "string") {
+        return tool.id;
+    }
+    return fallbackKey;
+}
+/**
+ * Approval-gated tools suspend the agent loop until a human approves.
+ * Mastra persists those suspended runs in Mastra-instance-level storage
+ * (`memoryBuilder.instanceStorage()`), not per-agent memory - so boot
+ * must fail fast when such a tool is registered without storage.
+ */
+function assertApprovalGatedToolsHaveStorage(gated, memoryBuilder) {
+    if (gated.length === 0)
+        return;
+    if (memoryBuilder?.instanceStorage())
+        return;
+    const detail = gated
+        .map(({ agentId, toolIds }) => `${agentId}: ${toolIds.join(", ")}`)
+        .join("; ");
+    throw new ConfigurationError("mastra: approval-gated tools require plugin storage (PostgresStore) to persist suspended runs. " +
+        `Affected agents/tools: ${detail}. ` +
+        "Register lakebase() before mastra() so storage auto-enables, or pass storage: true explicitly.");
+}
+/**
+ * Best-effort description of the *static* default model an agent will
+ * resolve to at call time. Walks the same precedence ladder as
+ * {@link resolveModel} / {@link buildModel}:
+ *
+ *   1. Per-agent `def.model` (string sugar -> the literal id;
+ *      function / `DynamicArgument` -> `"<dynamic>"` because the
+ *      resolver decides at call time).
+ *   2. Plugin-level `config.defaultModel` (same rules).
+ *   3. `DATABRICKS_SERVING_ENDPOINT_NAME` env var.
+ *   4. First entry of `config.defaultModelFallbacks ?? fallback.FALLBACK_MODEL_IDS`.
+ *
+ * Used for the startup `agent registered` log so operators can see
+ * which endpoint each agent points at by default. Per-request
+ * overrides (`X-Mastra-Model` etc.) and the workspace-catalogue
+ * fuzzy match are still applied at runtime.
+ */
+function describeAgentDefaultModel(config, def) {
+    const effective = def.model ?? config.defaultModel;
+    if (typeof effective === "string")
+        return effective;
+    if (effective !== undefined)
+        return "<dynamic>";
+    return (process.env.DATABRICKS_SERVING_ENDPOINT_NAME ??
+        config.defaultModelFallbacks?.[0] ??
+        fallback.FALLBACK_MODEL_IDS[0]);
+}
+/**
+ * Normalize `config.agents` into a `Record<id, definition>`. Accepts
+ * any of the three shapes documented on
+ * {@link MastraPluginConfig.agents}:
+ *
+ * - Record - returned as-is when non-empty.
+ * - Single definition (detected via the required `instructions`
+ *   field) - keyed by `slugify(def.name)` or `FALLBACK_AGENT_ID`.
+ * - Array - keyed by `slugify(def.name)` or `agent_${i}`; duplicate
+ *   slugs fail loudly so users know to set explicit names.
+ *
+ * Omitted or empty inputs fall back to a single built-in analyst so
+ * the bare `mastra()` call still mounts a working chat route.
+ */
+function resolveDefinitions(config) {
+    const input = config.agents;
+    if (!input)
+        return fallbackDefinitions();
+    if (Array.isArray(input)) {
+        if (input.length === 0)
+            return fallbackDefinitions();
+        const out = {};
+        input.forEach((def, i) => {
+            const key = deriveAgentKey(def, i);
+            if (out[key]) {
+                throw new ConfigurationError(`mastra: duplicate agent id "${key}" derived from name "${def.name ?? ""}"; ` +
+                    `set unique \`name\`s on each definition`);
+            }
+            out[key] = def;
+        });
+        return out;
+    }
+    // Single-definition shorthand: an agent always has `instructions: string`,
+    // a record-of-agents never has that field directly.
+    if (typeof input.instructions === "string") {
+        const def = input;
+        const key = deriveAgentKey(def);
+        return { [key]: def };
+    }
+    const record = input;
+    if (Object.keys(record).length === 0)
+        return fallbackDefinitions();
+    return record;
+}
+/** Derive a registry id from a definition's `name`, with a fallback. */
+function deriveAgentKey(def, index) {
+    if (def.name) {
+        const slug = string.toIdentifier(def.name);
+        if (slug)
+            return slug;
+    }
+    return index === undefined ? FALLBACK_AGENT_ID : `agent_${index}`;
+}
+/** Built-in fallback registry used when `agents` is omitted / empty. */
+function fallbackDefinitions() {
+    return {
+        [FALLBACK_AGENT_ID]: {
+            name: "Default Agent",
+            instructions: FALLBACK_AGENT_INSTRUCTIONS,
+        },
+    };
+}
+/**
+ * Pick the effective model spec for an agent. Fallback ladder, in
+ * order:
+ *
+ *   1. Per-agent `def.model` (string sugar or `DynamicArgument`).
+ *   2. Plugin-level `config.defaultModel` (string sugar or
+ *      `DynamicArgument`) - mirrors AppKit's `agents({ defaultModel })`.
+ *   3. The auto-resolver that mints user-scoped tokens against
+ *      `/serving-endpoints` via {@link buildModel}.
+ *
+ * String values are treated as `modelId` sugar and threaded through
+ * `buildModel`'s override hook so the runtime fuzzy matcher and the
+ * per-request `X-Mastra-Model` override layer on top of the static
+ * choice. Non-string `DynamicArgument`s are passed through verbatim;
+ * callers that need full control over `providerId` / `headers` /
+ * `modelId` bypass the resolver pipeline entirely.
+ */
+function resolveModel(config, override) {
+    const effective = override ?? config.defaultModel;
+    if (effective === undefined) {
+        return ({ requestContext }) => buildModel(config, requestContext);
+    }
+    if (typeof effective === "string") {
+        const modelId = effective;
+        return ({ requestContext }) => buildModel(config, requestContext, { modelId });
+    }
+    return effective;
+}
+/**
+ * Resolve a definition's `tools` field to a flat `MastraTools` record,
+ * merging in plugin-level ambient tools (per-agent tools win on key
+ * collision). Callback errors propagate verbatim so the original stack
+ * survives - the caller already knows which agent was registering.
+ */
+async function resolveTools(defTools, plugins, ambientTools) {
+    if (!defTools)
+        return { ...ambientTools };
+    const resolved = typeof defTools === "function" ? await defTools(plugins) : defTools;
+    return { ...ambientTools, ...resolved };
+}
+function resolveAgentWorkspace(workspace) {
+    if (!workspace)
+        return undefined;
+    return typeof workspace === "function" ? workspace() : workspace;
+}
+/**
+ * Build the {@link MastraPlugins} runtime proxy handed to
+ * `tools(plugins)` callbacks.
+ *
+ * Implemented as a `Proxy` over the AppKit plugin context so
+ * `plugins.<name>` resolves at first access. Any sibling plugin that
+ * implements AppKit's standard `ToolProvider` interface
+ * (`toolkit(opts?)` + `executeAgentTool(name, args, signal?)`) is
+ * auto-adapted into Mastra tools. Unknown names return `undefined`,
+ * matching AppKit's `Plugins` semantics so `plugins.foo?.toolkit()`
+ * remains safe in environments where `foo` isn't registered.
+ *
+ * `genie` is special-cased to swap the generic AppKit toolkit (which
+ * runs `executeAgentTool` and only emits a single final `tool-result`
+ * chunk per call) for the streaming-aware tools built by
+ * {@link buildGenieToolkitProvider}. The streaming variant forwards each
+ * Genie wire event (status, SQL, row counts, errors) out through the
+ * Mastra `ctx.writer`, so the UI gets `tool-output` chunks in real
+ * time instead of staring at a spinner for the full Genie round-trip.
+ */
+function buildPluginsMap(config, context) {
+    const cache = new Map();
+    return new Proxy({}, {
+        get(_target, propName) {
+            if (typeof propName !== "string")
+                return undefined;
+            if (cache.has(propName))
+                return cache.get(propName) ?? undefined;
+            const provider = resolveProvider(config, context, propName);
+            cache.set(propName, provider);
+            return provider ?? undefined;
+        },
+    });
+}
+/**
+ * Pick the right {@link MastraPluginToolkitProvider} for a sibling
+ * plugin lookup. Returns the Genie agent-backed adapter when
+ * the caller asks for `genie` AND at least one space is reachable
+ * via {@link resolveGenieSpaces} (the explicit
+ * `config.genieSpaces`, the registered AppKit `genie()` plugin's
+ * `spaces` config, or the `DATABRICKS_GENIE_SPACE_ID` env var).
+ * Falls back to the generic AppKit `ToolProvider` adapter for
+ * every other plugin name. `config` is threaded through so the
+ * Genie agent inherits the same model resolver / fallback
+ * ladder the calling agents use.
+ *
+ * The Genie tools talk to Genie directly through `@dbx-tools/genie`
+ * (`genieEventChat`) and the workspace `statementExecution.getStatement`
+ * API; AppKit's stock `genie` plugin contributes only its resource
+ * manifest and `spaces` config, so an `app.yaml` resource binding and a
+ * `genie({ spaces })` record have the same meaning here as they do there.
+ */
+function resolveProvider(config, context, propName) {
+    if (propName === "genie") {
+        const spaces = resolveGenieSpaces(config, context);
+        if (Object.keys(spaces).length === 0)
+            return null;
+        return buildGenieToolkitProvider({
+            spaces,
+            config,
+        });
+    }
+    const plugin = context?.getPlugins().get(propName);
+    return adaptPluginToolkit(plugin);
+}
+/**
+ * Adapt an AppKit `ToolProvider` plugin instance into a
+ * {@link MastraPluginToolkitProvider}. Returns `null` for any plugin
+ * that doesn't implement both `toolkit` and `executeAgentTool` (e.g.
+ * `server`, `lakebase` when used only as a Postgres pool, etc.).
+ */
+function adaptPluginToolkit(plugin) {
+    if (!plugin || typeof plugin !== "object")
+        return null;
+    const p = plugin;
+    if (typeof p.toolkit !== "function" || typeof p.executeAgentTool !== "function") {
+        return null;
+    }
+    return {
+        toolkit(opts) {
+            const entries = p.toolkit(opts);
+            const tools = {};
+            for (const [key, entry] of Object.entries(entries)) {
+                tools[key] = toolkitEntryToMastraTool(entry, p);
+            }
+            return tools;
+        },
+    };
+}
+/**
+ * Wrap a single {@link AppKitToolkitEntry} as a Mastra tool whose
+ * `execute` dispatches back through `plugin.executeAgentTool(...)` so
+ * AppKit's OBO auth (`asUser`) and telemetry spans stay intact. JSON
+ * Schema parameters pass through unchanged - Mastra's `PublicSchema`
+ * accepts `JSONSchema7` directly via `@mastra/schema-compat`.
+ */
+function toolkitEntryToMastraTool(entry, plugin) {
+    return createTool({
+        id: `${entry.pluginName}__${entry.localName}`,
+        description: entry.def.description,
+        ...(entry.def.parameters ? { inputSchema: entry.def.parameters } : {}),
+        execute: async (input, context) => {
+            const signal = context?.abortSignal;
+            return plugin.executeAgentTool(entry.localName, input, signal);
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agents.js","sourceRoot":"","sources":["../../src/agents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAExD,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAO,MAAM,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAE7D,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE3C,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAIhD,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAE9C,OAAO,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAExE,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAmB/C,yEAAyE;AACzE,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,IAAI,CAAC,IAAuB;IAC1C,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,IAAI,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACrD,OAAO,UAAU,CAAC;QAChB,EAAE;QACF,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,MAAe,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7D,OAAO,EAAE,IAAI,CAAC,OAAgB;KAC/B,CAAC,CAAC;AACL,CAAC;AAiCD;;;;;GAKG;AACH,SAAS,YAAY,CAAC,WAAmB;IACvC,OAAO,MAAM,CAAC,YAAY,CAAC,WAAW,EAAE,EAAE,cAAc,EAAE,MAAM,EAAE,CAAC,CAAC;AACtE,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,WAAW,CAAkC,GAAM;IACjE,MAAM,SAAS,GAAG,GAAG,CAAC,SAAS,IAAI,eAAe,EAAE,CAAC;IACrD,OAAO,EAAE,GAAG,GAAG,EAAE,SAAS,EAAE,CAAC;AAC/B,CAAC;AAgMD,uEAAuE;AACvE,MAAM,CAAC,MAAM,iBAAiB,GAAG,SAAS,CAAC;AAE3C;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,EAAE,CAAC;AAE1C,MAAM,2BAA2B,GAAG;;;;;;;;;;iCAUH,CAAC;AAElC;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,eAAe;IACf,EAAE;IACF,sEAAsE;IACtE,4CAA4C;IAC5C,cAAc;IACd,yDAAyD;IACzD,mBAAmB;IACnB,+EAA+E;IAC/E,4DAA4D;IAC5D,6EAA6E;IAC7E,kBAAkB;IAClB,qDAAqD;IACrD,mEAAmE;CACpE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb;;;GAGG;AACH,SAAS,wBAAwB,CAAC,MAA0B;IAC1D,IAAI,MAAM,CAAC,iBAAiB,KAAK,KAAK;QAAE,OAAO,IAAI,CAAC;IACpD,IAAI,OAAO,MAAM,CAAC,iBAAiB,KAAK,QAAQ,EAAE,CAAC;QACjD,OAAO,MAAM,CAAC,iBAAiB,CAAC;IAClC,CAAC;IAED,OAAO,0BAA0B,CAAC;AACpC,CAAC;AAED;;;GAGG;AACH,SAAS,mBAAmB,CAAC,iBAAyB,EAAE,KAAoB;IAC1E,IAAI,CAAC,KAAK;QAAE,OAAO,iBAAiB,CAAC;IACrC,OAAO,GAAG,iBAAiB,CAAC,OAAO,EAAE,OAAO,KAAK,EAAE,CAAC;AACtD,CAAC;AAED;;;;;GAKG;AACH,SAAS,uBAAuB,CAAC,IAAY;IAC3C,OAAO,4BAA4B,IAAI,IAAI,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,IAKjC;IACC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IACrD,MAAM,WAAW,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;IAC/C,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACrC,MAAM,cAAc,GAAG,MAAM,CAAC,YAAY,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,iBAAiB,CAAC;IAE1E,MAAM,OAAO,GAAG,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjD,gEAAgE;IAChE,8DAA8D;IAC9D,gEAAgE;IAChE,qEAAqE;IACrE,qEAAqE;IACrE,6DAA6D;IAC7D,MAAM,WAAW,GAAgB;QAC/B,WAAW,EAAE,mBAAmB,CAAC,MAAM,CAAC;QACxC,SAAS,EAAE,kBAAkB,CAAC,MAAM,CAAC;KACtC,CAAC;IACF,MAAM,YAAY,GAAG;QACnB,GAAG,WAAW;QACd,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC;KACxB,CAAC;IACF,MAAM,KAAK,GAAG,wBAAwB,CAAC,MAAM,CAAC,CAAC;IAC/C,8DAA8D;IAC9D,0DAA0D;IAC1D,wDAAwD;IACxD,oCAAoC;IACpC,MAAM,gBAAgB,GAAG,CAAC,IAAI,eAAe,EAAE,CAAC,CAAC;IACjD,MAAM,eAAe,GAAG;QACtB,GAAG,CAAC,MAAM,CAAC,gBAAgB,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,yBAAyB,CAAC,CAAC;KAC1E,CAAC;IACF,MAAM,MAAM,GAA0B,EAAE,CAAC;IACzC,MAAM,aAAa,GAA2B,EAAE,CAAC;IACjD,MAAM,oBAAoB,GAAkD,EAAE,CAAC;IAE/E,KAAK,MAAM,CAAC,EAAE,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;QACpD,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;QACnE,MAAM,SAAS,GAAG,qBAAqB,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACvD,MAAM,KAAK,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;YAAE,oBAAoB,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;QACjF,MAAM,MAAM,GAAG,aAAa,EAAE,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;QAChD,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,KAAK,CAAC;YACrB,EAAE;YACF,IAAI,EAAE,GAAG,CAAC,IAAI,IAAI,EAAE;YACpB,6DAA6D;YAC7D,+DAA+D;YAC/D,6DAA6D;YAC7D,YAAY;YACZ,WAAW,EAAE,GAAG,CAAC,WAAW,EAAE,IAAI,EAAE,IAAI,uBAAuB,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC;YAC/E,YAAY,EAAE,mBAAmB,CAAC,GAAG,CAAC,YAAY,EAAE,KAAK,CAAC;YAC1D,KAAK,EAAE,YAAY,CAAC,MAAM,EAAE,GAAG,CAAC,KAAK,CAAC;YACtC,cAAc,EAAE;gBACd,QAAQ,EAAE,MAAM,CAAC,aAAa,IAAI,uBAAuB;aAC1D;YACD,KAAK;YACL,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YAC7B,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACnC,eAAe;YACf,gBAAgB;SACjB,CAAC,CAAC;QACH,iEAAiE;QACjE,8DAA8D;QAC9D,iEAAiE;QACjE,4DAA4D;QAC5D,+DAA+D;QAC/D,aAAa;QACb,MAAM,YAAY,GAAG,yBAAyB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC5D,aAAa,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC;QACjC,GAAG,CAAC,IAAI,CAAC,kBAAkB,EAAE;YAC3B,EAAE;YACF,IAAI,EAAE,GAAG,CAAC,IAAI,IAAI,EAAE;YACpB,YAAY;YACZ,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;SAC1B,CAAC,CAAC;IACL,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,EAAE,CAAC;QAC5B,MAAM,kBAAkB,CAAC,gBAAgB,CACvC,wBAAwB,cAAc,GAAG,EACzC,sBAAsB,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,MAAM,GAAG,CAClD,CAAC;IACJ,CAAC;IAED,mCAAmC,CAAC,oBAAoB,EAAE,aAAa,CAAC,CAAC;IAEzE,GAAG,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,GAAG,EAAE,cAAc,EAAE,CAAC,CAAC;IAClD,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,aAAa,EAAE,YAAY,EAAE,CAAC;AACjE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAkB;IACrD,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,EAAE,CAAC;IACnD,OAAO;QACL,GAAG,MAAM;aACN,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;aAC/B,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;aAC/C,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;KAClD,CAAC;AACJ,CAAC;AAED,iFAAiF;AACjF,SAAS,mBAAmB,CAAC,IAAa;IACxC,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IACpD,OAAQ,IAAsC,CAAC,eAAe,KAAK,IAAI,CAAC;AAC1E,CAAC;AAED,SAAS,aAAa,CAAC,IAAa,EAAE,WAAmB;IACvD,IAAI,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,OAAQ,IAAwB,CAAC,EAAE,KAAK,QAAQ,EAAE,CAAC;QACzF,OAAQ,IAAuB,CAAC,EAAE,CAAC;IACrC,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;;GAKG;AACH,SAAS,mCAAmC,CAC1C,KAAoD,EACpD,aAAwC;IAExC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IAC/B,IAAI,aAAa,EAAE,eAAe,EAAE;QAAE,OAAO;IAE7C,MAAM,MAAM,GAAG,KAAK;SACjB,GAAG,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,GAAG,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;SAClE,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,MAAM,IAAI,kBAAkB,CAC1B,iGAAiG;QAC/F,0BAA0B,MAAM,IAAI;QACpC,gGAAgG,CACnG,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,SAAS,yBAAyB,CAAC,MAA0B,EAAE,GAA0B;IACvF,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,IAAI,MAAM,CAAC,YAAY,CAAC;IACnD,IAAI,OAAO,SAAS,KAAK,QAAQ;QAAE,OAAO,SAAS,CAAC;IACpD,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,WAAW,CAAC;IAChD,OAAO,CACL,OAAO,CAAC,GAAG,CAAC,gCAAgC;QAC5C,MAAM,CAAC,qBAAqB,EAAE,CAAC,CAAC,CAAC;QACjC,QAAQ,CAAC,kBAAkB,CAAC,CAAC,CAAE,CAChC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAS,kBAAkB,CAAC,MAA0B;IACpD,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;IAC5B,IAAI,CAAC,KAAK;QAAE,OAAO,mBAAmB,EAAE,CAAC;IAEzC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,mBAAmB,EAAE,CAAC;QACrD,MAAM,GAAG,GAA0C,EAAE,CAAC;QACtD,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE;YACvB,MAAM,GAAG,GAAG,cAAc,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;YACnC,IAAI,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBACb,MAAM,IAAI,kBAAkB,CAC1B,+BAA+B,GAAG,wBAAwB,GAAG,CAAC,IAAI,IAAI,EAAE,KAAK;oBAC3E,yCAAyC,CAC5C,CAAC;YACJ,CAAC;YACD,GAAG,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;QACjB,CAAC,CAAC,CAAC;QACH,OAAO,GAAG,CAAC;IACb,CAAC;IAED,2EAA2E;IAC3E,oDAAoD;IACpD,IAAI,OAAQ,KAA+B,CAAC,YAAY,KAAK,QAAQ,EAAE,CAAC;QACtE,MAAM,GAAG,GAAG,KAA8B,CAAC;QAC3C,MAAM,GAAG,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;QAChC,OAAO,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC;IACxB,CAAC;IAED,MAAM,MAAM,GAAG,KAA8C,CAAC;IAC9D,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,mBAAmB,EAAE,CAAC;IACnE,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,wEAAwE;AACxE,SAAS,cAAc,CAAC,GAA0B,EAAE,KAAc;IAChE,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC;QACb,MAAM,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAI,IAAI;YAAE,OAAO,IAAI,CAAC;IACxB,CAAC;IACD,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,SAAS,KAAK,EAAE,CAAC;AACpE,CAAC;AAED,wEAAwE;AACxE,SAAS,mBAAmB;IAC1B,OAAO;QACL,CAAC,iBAAiB,CAAC,EAAE;YACnB,IAAI,EAAE,eAAe;YACrB,YAAY,EAAE,2BAA2B;SAC1C;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,SAAS,YAAY,CACnB,MAA0B,EAC1B,QAAwC;IAExC,MAAM,SAAS,GAAG,QAAQ,IAAI,MAAM,CAAC,YAAY,CAAC;IAClD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,OAAO,CAAC,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACpE,CAAC;IACD,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;QAClC,MAAM,OAAO,GAAG,SAAS,CAAC;QAC1B,OAAO,CAAC,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC,UAAU,CAAC,MAAM,EAAE,cAAc,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IACjF,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;GAKG;AACH,KAAK,UAAU,YAAY,CACzB,QAAwC,EACxC,OAAsB,EACtB,YAAyB;IAEzB,IAAI,CAAC,QAAQ;QAAE,OAAO,EAAE,GAAG,YAAY,EAAE,CAAC;IAC1C,MAAM,QAAQ,GAAG,OAAO,QAAQ,KAAK,UAAU,CAAC,CAAC,CAAC,MAAM,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IACrF,OAAO,EAAE,GAAG,YAAY,EAAE,GAAG,QAAQ,EAAE,CAAC;AAC1C,CAAC;AAED,SAAS,qBAAqB,CAC5B,SAA6C;IAE7C,IAAI,CAAC,SAAS;QAAE,OAAO,SAAS,CAAC;IACjC,OAAO,OAAO,SAAS,KAAK,UAAU,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;AACnE,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAS,eAAe,CACtB,MAA0B,EAC1B,OAA6C;IAE7C,MAAM,KAAK,GAAG,IAAI,GAAG,EAA8C,CAAC;IACpE,OAAO,IAAI,KAAK,CAAC,EAAmB,EAAE;QACpC,GAAG,CAAC,OAAO,EAAE,QAAQ;YACnB,IAAI,OAAO,QAAQ,KAAK,QAAQ;gBAAE,OAAO,SAAS,CAAC;YACnD,IAAI,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC;gBAAE,OAAO,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,SAAS,CAAC;YACjE,MAAM,QAAQ,GAAG,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;YAC5D,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAC9B,OAAO,QAAQ,IAAI,SAAS,CAAC;QAC/B,CAAC;KACF,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAS,eAAe,CACtB,MAA0B,EAC1B,OAA6C,EAC7C,QAAgB;IAEhB,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;QACzB,MAAM,MAAM,GAAG,kBAAkB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACnD,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAClD,OAAO,yBAAyB,CAAC;YAC/B,MAAM;YACN,MAAM;SACP,CAAgC,CAAC;IACpC,CAAC;IACD,MAAM,MAAM,GAAG,OAAO,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACnD,OAAO,kBAAkB,CAAC,MAAM,CAAC,CAAC;AACpC,CAAC;AAuBD;;;;;GAKG;AACH,SAAS,kBAAkB,CAAC,MAAe;IACzC,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IACvD,MAAM,CAAC,GAAG,MAA+B,CAAC;IAC1C,IAAI,OAAO,CAAC,CAAC,OAAO,KAAK,UAAU,IAAI,OAAO,CAAC,CAAC,gBAAgB,KAAK,UAAU,EAAE,CAAC;QAChF,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO;QACL,OAAO,CAAC,IAAqB;YAC3B,MAAM,OAAO,GAAG,CAAC,CAAC,OAAQ,CAAC,IAAI,CAAC,CAAC;YACjC,MAAM,KAAK,GAAgB,EAAE,CAAC;YAC9B,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;gBACnD,KAAK,CAAC,GAAG,CAAC,GAAG,wBAAwB,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAClD,CAAC;YACD,OAAO,KAAK,CAAC;QACf,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,SAAS,wBAAwB,CAAC,KAAyB,EAAE,MAA6B;IACxF,OAAO,UAAU,CAAC;QAChB,EAAE,EAAE,GAAG,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,SAAS,EAAE;QAC7C,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,WAAW;QAClC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,CAAC,GAAG,CAAC,UAAmB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/E,OAAO,EAAE,KAAK,EAAE,KAAc,EAAE,OAAgB,EAAE,EAAE;YAClD,MAAM,MAAM,GAAI,OAAqD,EAAE,WAAW,CAAC;YACnF,OAAO,MAAM,CAAC,gBAAiB,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;QAClE,CAAC;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["/**\n * Agent registration for the Mastra AppKit plugin.\n *\n * Mirrors the shape of the AppKit `agents` plugin (`config.agents` map\n * of {@link MastraAgentDefinition}, dual-form `tools` accepting a plain\n * record or a `(plugins) => tools` callback). Resolves each definition\n * into a Mastra `Agent` instance during plugin setup; user-supplied\n * tool callbacks are invoked exactly once with a typed\n * {@link MastraPlugins} map built from registered sibling plugins.\n *\n * When no agents are registered the plugin falls back to a single\n * built-in analyst so the bare `mastra()` call still mounts a working\n * streamable agent for demos.\n *\n * @module\n */\n\nimport { ConfigurationError } from \"@databricks/appkit\";\nimport { plugin } from \"@dbx-tools/appkit\";\nimport { fallback } from \"@dbx-tools/model\";\nimport { log, object, string } from \"@dbx-tools/shared-core\";\nimport type { AgentConfig, ToolsInput } from \"@mastra/core/agent\";\nimport { Agent } from \"@mastra/core/agent\";\nimport type { Tool } from \"@mastra/core/tools\";\nimport { createTool } from \"@mastra/core/tools\";\nimport type { Workspace } from \"@mastra/core/workspace\";\nimport type { PgVectorConfig, PostgresStoreConfig } from \"@mastra/pg\";\n\nimport { buildRenderDataTool } from \"./chart\";\nimport type { MastraPluginConfig } from \"./config\";\nimport { buildGenieToolkitProvider, resolveGenieSpaces } from \"./genie\";\nimport type { MemoryBuilder } from \"./memory\";\nimport { buildModel } from \"./model\";\nimport { ResultProcessor, stripStaleChartsProcessor } from \"./processors\";\nimport { buildSummarizeTool } from \"./summarize\";\nimport { createWorkspace } from \"./workspaces\";\n\n/**\n * Tool record accepted by every Mastra `Agent.tools` field and by the\n * `tools(plugins)` callback on {@link MastraAgentDefinition}.\n *\n * Alias of Mastra's `ToolsInput`, so it already accepts:\n *\n * - Mastra tools built with {@link createTool} (or `new Tool(...)`)\n * - Mastra tools built with the AppKit-shaped {@link tool} wrapper\n *   below\n * - Vercel AI SDK tools (`tool({ ... })` from `ai`)\n * - Provider-defined tools (e.g. `openai.tools.webSearch(...)`)\n *\n * Existing tool libraries drop in as-is - nothing in this package\n * forces a rebuild.\n */\nexport type MastraTools = ToolsInput;\n\n/** Re-export of Mastra's native `createTool` for full-feature access. */\nexport { createTool } from \"@mastra/core/tools\";\n\n/**\n * AppKit-shaped tool factory. Lets users mix-and-match tools across\n * AppKit's `agents` plugin and `mastra` with a single import:\n *\n * ```ts\n * import { tool } from \"@dbx-tools/appkit-mastra\";\n * import { z } from \"zod\";\n *\n * get_weather: tool({\n *   description: \"Weather\",\n *   schema: z.object({ city: z.string() }),\n *   execute: async ({ city }) => `Sunny in ${city}`,\n * }),\n * ```\n *\n * Maps onto Mastra's `createTool`:\n *\n * - `description` -> `description` (required)\n * - `schema` -> `inputSchema` (optional)\n * - `execute(input)` -> `execute(input, ctx)` - Mastra already calls\n *   the first arg with the parsed inputs, so the body shape is\n *   identical. The Mastra `context` arg is forwarded as the second\n *   parameter when the caller declares it.\n * - `id`: optional. Defaults to a stable identifier derived from\n *   `description` (slugified, with a short hash suffix for\n *   uniqueness). Pass an explicit `id` when you need a stable string\n *   for tracing or MCP exposure.\n *\n * Reach for {@link createTool} when you need Mastra-only fields\n * (`outputSchema`, `suspendSchema`, `requireApproval`, `mcp`, etc.).\n */\nexport function tool(opts: AppKitToolOptions): Tool {\n  const id = opts.id ?? deriveToolId(opts.description);\n  return createTool({\n    id,\n    description: opts.description,\n    ...(opts.schema ? { inputSchema: opts.schema as never } : {}),\n    execute: opts.execute as never,\n  });\n}\n\n/**\n * Input shape for the AppKit-style {@link tool} factory. A trimmed\n * subset of Mastra's `createTool` options that mirrors the\n * `@databricks/appkit/beta` `tool({ description, schema, execute })`\n * signature.\n *\n * Generics are intentionally absent - inference flows through the\n * caller's `schema` (typically a Zod object), and the `execute` body\n * destructures naturally from that. Reach for {@link createTool} when\n * you need the fully-typed input/output schemas wired explicitly.\n */\nexport interface AppKitToolOptions {\n  /** Optional stable identifier; auto-derived from `description` when omitted. */\n  id?: string;\n  /** Human-readable description shown to the model. Required. */\n  description: string;\n  /**\n   * Optional input schema (any Standard Schema instance, e.g. Zod).\n   * Maps to Mastra's `inputSchema`; passed through to the model\n   * verbatim.\n   */\n  schema?: unknown;\n  /**\n   * Execute body. First arg is the parsed input (typed off `schema`\n   * when supplied), second arg is the full Mastra execution context\n   * (request context, abort signal, mastra instance) if you need it.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  execute: (input: any, context?: unknown) => unknown;\n}\n\n/**\n * Build a deterministic Mastra tool id from a description.\n * Delegates to {@link string.toUniqueSlug}: slug + always-on\n * 6-char FNV-1a base-32 suffix so two tools with the same leading\n * words don't collide in traces. Stable across runs.\n */\nfunction deriveToolId(description: string): string {\n  return string.toUniqueSlug(description, { fallbackPrefix: \"tool\" });\n}\n\n/**\n * Identity helper that brands a definition as a Mastra agent. Mirrors\n * AppKit's `createAgent(def)` so the registration shape matches:\n *\n * ```ts\n * const support = createAgent({\n *   instructions: \"...\",\n *   model: \"databricks-claude-sonnet-4-6\",\n *   tools(plugins) { return { ... }; },\n * });\n * ```\n *\n * Returns the definition unchanged - the wrapper exists only to anchor\n * type inference and to match the AppKit API surface.\n */\nexport function createAgent<T extends MastraAgentDefinition>(def: T): T {\n  const workspace = def.workspace ?? createWorkspace();\n  return { ...def, workspace };\n}\n\n/**\n * Filter / rename options accepted by every plugin's `.toolkit()`\n * method. Mirrors AppKit's `ToolkitOptions` verbatim so options pass\n * through unchanged - the underlying AppKit plugin does the filtering\n * and we just adapt the resulting entries into Mastra tools.\n */\nexport interface ToolkitOptions {\n  /**\n   * Key prefix prepended to every tool name. AppKit's default is\n   * `${pluginName}.` when omitted; pass an explicit `\"\"` to drop it.\n   */\n  prefix?: string;\n  /** Allowlist of local tool names. */\n  only?: string[];\n  /** Denylist of local tool names. */\n  except?: string[];\n  /** Remap specific local names to different keys. */\n  rename?: Record<string, string>;\n}\n\n/**\n * Toolkit provider shape every entry in the {@link MastraPlugins} map\n * exposes. Identical to AppKit's `PluginToolkitProvider` - any AppKit\n * plugin that implements the standard `ToolProvider` interface\n * (`getAgentTools` + `executeAgentTool` + `toolkit`) is reachable\n * through this surface automatically.\n */\nexport interface MastraPluginToolkitProvider {\n  /**\n   * Returns a Mastra-shaped tools record adapted from the plugin's\n   * agent tools. Each tool dispatches back through the plugin's\n   * `executeAgentTool` so OBO auth and telemetry spans stay intact.\n   */\n  toolkit(opts?: ToolkitOptions): MastraTools;\n}\n\n/**\n * Plugin map handed to the function form of\n * {@link MastraAgentDefinition.tools}. Mirrors AppKit's `Plugins`\n * type exactly: a string-keyed record where every value exposes\n * `.toolkit(opts)`.\n *\n * Implemented as a runtime Proxy that auto-discovers any registered\n * AppKit plugin implementing the standard `ToolProvider` interface\n * (`analytics`, `files`, `lakebase`, `genie`, plus any third-party\n * plugin that does the same). Unknown names resolve to `undefined`\n * at runtime, so guard with `?.` and `?? {}` when spreading from a\n * plugin that may not be registered in every environment.\n *\n * @example\n * ```ts\n * createAgent({\n *   instructions: \"...\",\n *   tools(plugins) {\n *     return {\n *       ...plugins.analytics.toolkit(),\n *       ...plugins.files.toolkit({ only: [\"uploads.read\"] }),\n *       get_weather: tool({\n *         description: \"Weather\",\n *         schema: z.object({ city: z.string() }),\n *         execute: async ({ city }) => `Sunny in ${city}`,\n *       }),\n *     };\n *   },\n * });\n * ```\n */\nexport type MastraPlugins = Record<string, MastraPluginToolkitProvider>;\n\n/** Function form of {@link MastraAgentDefinition.tools}. */\nexport type MastraToolsFn = (plugins: MastraPlugins) => MastraTools | Promise<MastraTools>;\n\n/** Function form of {@link MastraAgentDefinition.workspace}. */\nexport type MastraAgentWorkspaceResolver = () => Workspace | undefined;\n\n/**\n * A code-defined Mastra agent. Mirrors the shape AppKit's `agents`\n * plugin uses for `AgentDefinition`. The registry key under\n * `config.agents` is the `agentId` the client streams against; `name`\n * is purely informational (defaults to the key).\n */\nexport interface MastraAgentDefinition {\n  /** Display name used as `Agent.name`. Defaults to the registry key. */\n  name?: string;\n  /** Optional long-form description; surfaced as `Agent.description`. */\n  description?: string;\n  /** System prompt body. */\n  instructions: string;\n  /**\n   * Per-agent model override.\n   *\n   * - `undefined` (default): falls back to the workspace\n   *   `/serving-endpoints` resolver that {@link buildModel} configures\n   *   from the per-request `WorkspaceClient`.\n   * - `string`: shorthand for \"use the default resolver but swap the\n   *   `modelId`\" (e.g. `\"databricks-meta-llama-3-3-70b-instruct\"`).\n   * - Any other Mastra `DynamicArgument<MastraModelConfig>`: passed\n   *   straight through to `Agent.model`. Use this when you need full\n   *   control over auth or providerId.\n   */\n  model?: AgentConfig[\"model\"] | string;\n  /**\n   * Per-agent tool record. Either a plain map or a callback that\n   * receives the typed {@link MastraPlugins} sibling-plugin index and\n   * returns a map. The callback runs exactly once at agent setup; the\n   * result is cached for the agent's lifetime.\n   */\n  tools?: MastraTools | MastraToolsFn;\n  /**\n   * Per-agent semantic recall (PgVector) override. Cascades from\n   * `config.memory`; the agent value wins when set.\n   *\n   * - `undefined` (default): inherit `config.memory`. When that's\n   *   enabled, the agent **shares the plugin-level singleton `PgVector`\n   *   instance** (cross-agent semantic recall across the same index).\n   * - `false`: disable semantic recall for this agent only.\n   * - `true`: enable using the shared singleton (same as default when\n   *   plugin memory is enabled; useful to opt in when plugin disabled).\n   * - {@link MastraMemoryConfig} object: dedicated `PgVector` for this\n   *   agent (private recall index). Bypasses the shared singleton.\n   */\n  memory?: boolean | MastraMemoryConfigOverride;\n  /**\n   * Per-agent thread/message storage (`PostgresStore`) override.\n   * Cascades from `config.storage`; the agent value wins when set.\n   *\n   * - `undefined` (default): inherit `config.storage`. When that's\n   *   enabled, the agent gets its **own per-agent `PostgresStore`**\n   *   keyed by {@link agentStorageSchemaName} so threads and\n   *   messages stay isolated between agents in the same database.\n   * - `false`: disable storage for this agent only (purely in-memory).\n   * - `true`: enable with the per-agent default schema.\n   * - {@link MastraStorageConfigOverride} object: dedicated\n   *   `PostgresStore` config (custom schema, connection, etc.).\n   */\n  storage?: boolean | MastraStorageConfigOverride;\n  /**\n   * Mastra {@link Workspace} for this agent (filesystem, sandbox, or other\n   * providers). Assistant skills from Databricks workspace paths are wired\n   * via {@link createWorkspace}.\n   */\n  workspace?: Workspace | MastraAgentWorkspaceResolver;\n}\n\n/**\n * Distributive `Omit` so unions in `PostgresStoreConfig` /\n * `PgVectorConfig` keep their discriminants after the override types\n * strip `id`. The built-in `Omit` collapses unions to one shape with\n * common fields only, which loses the connection-style discriminants.\n */\ntype DistributiveOmit<T, K extends keyof never> = T extends unknown ? Omit<T, K> : never;\n\n/**\n * `PostgresStoreConfig` minus `id` - per-agent overrides accept any\n * Mastra-supported storage shape. `id` is filled in automatically\n * from the agent registry key so traces stay stable.\n */\nexport type MastraStorageConfigOverride = DistributiveOmit<PostgresStoreConfig, \"id\"> & {\n  id?: string;\n};\n\n/**\n * `PgVectorConfig` minus `id` - per-agent overrides accept any\n * Mastra-supported vector shape. `id` is filled in automatically\n * from the agent registry key.\n */\nexport type MastraMemoryConfigOverride = DistributiveOmit<PgVectorConfig, \"id\"> & {\n  id?: string;\n};\n\n/** Output of {@link buildAgents}: resolved agents plus the default id. */\nexport interface BuiltAgents {\n  agents: Record<string, Agent>;\n  defaultAgentId: string;\n  /**\n   * Static default serving-endpoint id per agent id, as resolved by\n   * {@link describeAgentDefaultModel}. `\"<dynamic>\"` when the model is a\n   * function decided at call time. Consumed by the plugin's\n   * `GET /default-model` route handler so the client's model picker can label\n   * its default option with the real endpoint's humanized name.\n   */\n  defaultModels: Record<string, string>;\n  /**\n   * Ambient tools shared across every agent (the built-in system tools\n   * spread with `config.tools`). Surfaced so the optional MCP server\n   * can re-expose them when {@link MastraMcpConfig.tools} is enabled.\n   */\n  ambientTools: MastraTools;\n}\n\n/** Fallback agent id used when `config.agents` is omitted entirely. */\nexport const FALLBACK_AGENT_ID = \"default\";\n\n/**\n * Default per-turn step ceiling applied to every registered agent\n * when {@link MastraPluginConfig.agentMaxSteps} is unset. Sized to\n * fit a decomposed Genie turn (grounding + several `ask_genie`\n * calls + `prepare_chart` per dataset + the final-text reply) with\n * headroom for the model to chain a couple of follow-ups before\n * answering - well above Mastra's own `agent.generate` default of\n * 5, which would cut multi-step orchestration off mid-loop.\n */\nexport const DEFAULT_AGENT_MAX_STEPS = 25;\n\nconst FALLBACK_AGENT_INSTRUCTIONS = `You are a data analyst. The user will ask questions about\nbusiness metrics and may share personal preferences you should remember across turns.\n\nRules:\n\n1. Quote numbers exactly. Never invent data.\n2. When the user states a preference or durable fact about themselves\n   (\"I'm in EU so use EUR\", \"always show me the SQL\"), acknowledge that\n   you will remember it.\n3. If you don't have enough information to answer, ask a clarifying\n   question instead of guessing.`;\n\n/**\n * Style guardrails appended to every agent's `instructions` to curb\n * common LLM-isms (em dashes, emojis, sycophantic openers, excessive\n * hedging, throwaway closers). Appended rather than prepended so the\n * agent's role/context comes first; the model's recency bias then\n * helps the style rules dominate the response surface.\n *\n * Override globally via {@link MastraPluginConfig.styleInstructions}\n * (pass `false` to disable entirely, or a string to replace).\n */\nexport const DEFAULT_STYLE_INSTRUCTIONS = [\n  \"Output style:\",\n  \"\",\n  \"Use markdown formatting, including headings, lists, and code blocks.\",\n  \"Avoid lists and headers for short replies.\",\n  \"Plain prose.\",\n  \"Use hyphens (-) only. Never use em dashes or en dashes.\",\n  \"Never use emojis.\",\n  \"Skip openers like 'Great question', 'Absolutely', and 'I'd be happy to help'.\",\n  \"Skip closers like 'Let me know if you have any questions'.\",\n  \"Skip self-disclaimers like 'I should mention' and 'It's important to note'.\",\n  \"Answer directly.\",\n  \"Do not include a preamble before the actual answer.\",\n  \"Use lists and headers only when they clarify a multi-part answer.\",\n].join(\"\\n\");\n\n/**\n * Resolve the style block to append to every agent's instructions.\n * Returns `null` when the caller opted out (`styleInstructions: false`).\n */\nfunction resolveStyleInstructions(config: MastraPluginConfig): string | null {\n  if (config.styleInstructions === false) return null;\n  if (typeof config.styleInstructions === \"string\") {\n    return config.styleInstructions;\n  }\n\n  return DEFAULT_STYLE_INSTRUCTIONS;\n}\n\n/**\n * Join an agent's bespoke instructions with the resolved style block.\n * Returns the bespoke text unchanged when the style block is disabled.\n */\nfunction composeInstructions(agentInstructions: string, style: string | null): string {\n  if (!style) return agentInstructions;\n  return `${agentInstructions.trimEnd()}\\n\\n${style}`;\n}\n\n/**\n * Generated description for an agent whose definition omits one. Kept\n * generic (the agent's own name is the only reliable signal at build\n * time) so it reads sensibly as the `ask_<id>` MCP tool's description\n * and in agent metadata.\n */\nfunction defaultAgentDescription(name: string): string {\n  return `Conversational AI agent \"${name}\".`;\n}\n\n/**\n * Resolve every entry in `config.agents` into a Mastra `Agent`\n * instance. When `config.agents` is omitted the plugin registers a\n * single built-in `default` analyst so the bare `mastra()` call still\n * yields a working agent.\n *\n * Per-agent tool callbacks are invoked once with a typed\n * {@link MastraPlugins} index built from registered sibling plugins\n * (currently `genie`; extend `MastraPlugins` to surface more).\n *\n * @throws when `config.defaultAgent` is set to an id that isn't in the\n *   resolved registry; this is a wiring bug, not a runtime condition.\n */\nexport async function buildAgents(opts: {\n  config: MastraPluginConfig;\n  context: plugin.PluginContextLike | undefined;\n  memoryBuilder?: MemoryBuilder;\n  log: log.Logger;\n}): Promise<BuiltAgents> {\n  const { config, context, memoryBuilder, log } = opts;\n  const definitions = resolveDefinitions(config);\n  const ids = Object.keys(definitions);\n  const defaultAgentId = config.defaultAgent ?? ids[0] ?? FALLBACK_AGENT_ID;\n\n  const plugins = buildPluginsMap(config, context);\n  // System-default ambient tools every agent gets out of the box:\n  // `render_data` for inline visualizations and `summarize` for\n  // offloading text condensing to the fast / small chat tier. The\n  // user can shadow either by including a same-named tool in their own\n  // `config.tools` or per-agent `tools`. Order in {@link resolveTools}\n  // is `system -> user-ambient -> per-agent`, last write wins.\n  const systemTools: MastraTools = {\n    render_data: buildRenderDataTool(config),\n    summarize: buildSummarizeTool(config),\n  };\n  const ambientTools = {\n    ...systemTools,\n    ...(config.tools ?? {}),\n  };\n  const style = resolveStyleInstructions(config);\n  // Default-on protection against the model copying turn-scoped\n  // chartIds from prior assistant tool results into the new\n  // turn's `[chart:<id>]` markers. Opt out per-plugin via\n  // `config.stripStaleCharts: false`.\n  const outputProcessors = [new ResultProcessor()];\n  const inputProcessors = [\n    ...(config.stripStaleCharts === false ? [] : [stripStaleChartsProcessor]),\n  ];\n  const agents: Record<string, Agent> = {};\n  const defaultModels: Record<string, string> = {};\n  const approvalGatedByAgent: Array<{ agentId: string; toolIds: string[] }> = [];\n\n  for (const [id, def] of Object.entries(definitions)) {\n    const tools = await resolveTools(def.tools, plugins, ambientTools);\n    const workspace = resolveAgentWorkspace(def.workspace);\n    const gated = approvalGatedToolIds(tools);\n    if (gated.length > 0) approvalGatedByAgent.push({ agentId: id, toolIds: gated });\n    const memory = memoryBuilder?.forAgent(id, def);\n    agents[id] = new Agent({\n      id,\n      name: def.name ?? id,\n      // Always carry a non-empty description: it's surfaced to MCP\n      // clients (which reject a description-less agent) and in agent\n      // metadata. Fall back to a generated one when the definition\n      // omits it.\n      description: def.description?.trim() || defaultAgentDescription(def.name ?? id),\n      instructions: composeInstructions(def.instructions, style),\n      model: resolveModel(config, def.model),\n      defaultOptions: {\n        maxSteps: config.agentMaxSteps ?? DEFAULT_AGENT_MAX_STEPS,\n      },\n      tools,\n      ...(memory ? { memory } : {}),\n      ...(workspace ? { workspace } : {}),\n      inputProcessors,\n      outputProcessors,\n    });\n    // Surface the effective default model per agent so operators can\n    // see at a glance which endpoint each agent points at without\n    // having to fire a request and inspect a trace. The value is the\n    // *static* default; per-request overrides (header / query /\n    // body) and the workspace-catalogue fuzzy match still apply at\n    // call time.\n    const defaultModel = describeAgentDefaultModel(config, def);\n    defaultModels[id] = defaultModel;\n    log.info(\"agent registered\", {\n      id,\n      name: def.name ?? id,\n      defaultModel,\n      tools: Object.keys(tools),\n    });\n  }\n\n  if (!agents[defaultAgentId]) {\n    throw ConfigurationError.resourceNotFound(\n      `mastra defaultAgent \"${defaultAgentId}\"`,\n      `Registered agents: ${ids.join(\", \") || \"none\"}.`,\n    );\n  }\n\n  assertApprovalGatedToolsHaveStorage(approvalGatedByAgent, memoryBuilder);\n\n  log.info(\"agents ready\", { ids, defaultAgentId });\n  return { agents, defaultAgentId, defaultModels, ambientTools };\n}\n\n/**\n * Tool ids on `tools` that are approval-gated (`requireApproval: true`).\n * Keys are used as a fallback when a tool omits an explicit `id`.\n */\nexport function approvalGatedToolIds(tools: MastraTools): string[] {\n  if (!tools || typeof tools !== \"object\") return [];\n  return [\n    ...object\n      .sequence(Object.entries(tools))\n      .filter(([, tool]) => isApprovalGatedTool(tool))\n      .map(([key, tool]) => resolveToolId(tool, key)),\n  ];\n}\n\n/** True when a Mastra / AI SDK tool pauses for human approval before execute. */\nfunction isApprovalGatedTool(tool: unknown): boolean {\n  if (!tool || typeof tool !== \"object\") return false;\n  return (tool as { requireApproval?: boolean }).requireApproval === true;\n}\n\nfunction resolveToolId(tool: unknown, fallbackKey: string): string {\n  if (tool && typeof tool === \"object\" && typeof (tool as { id?: string }).id === \"string\") {\n    return (tool as { id: string }).id;\n  }\n  return fallbackKey;\n}\n\n/**\n * Approval-gated tools suspend the agent loop until a human approves.\n * Mastra persists those suspended runs in Mastra-instance-level storage\n * (`memoryBuilder.instanceStorage()`), not per-agent memory - so boot\n * must fail fast when such a tool is registered without storage.\n */\nfunction assertApprovalGatedToolsHaveStorage(\n  gated: Array<{ agentId: string; toolIds: string[] }>,\n  memoryBuilder: MemoryBuilder | undefined,\n): void {\n  if (gated.length === 0) return;\n  if (memoryBuilder?.instanceStorage()) return;\n\n  const detail = gated\n    .map(({ agentId, toolIds }) => `${agentId}: ${toolIds.join(\", \")}`)\n    .join(\"; \");\n  throw new ConfigurationError(\n    \"mastra: approval-gated tools require plugin storage (PostgresStore) to persist suspended runs. \" +\n      `Affected agents/tools: ${detail}. ` +\n      \"Register lakebase() before mastra() so storage auto-enables, or pass storage: true explicitly.\",\n  );\n}\n\n/**\n * Best-effort description of the *static* default model an agent will\n * resolve to at call time. Walks the same precedence ladder as\n * {@link resolveModel} / {@link buildModel}:\n *\n *   1. Per-agent `def.model` (string sugar -> the literal id;\n *      function / `DynamicArgument` -> `\"<dynamic>\"` because the\n *      resolver decides at call time).\n *   2. Plugin-level `config.defaultModel` (same rules).\n *   3. `DATABRICKS_SERVING_ENDPOINT_NAME` env var.\n *   4. First entry of `config.defaultModelFallbacks ?? fallback.FALLBACK_MODEL_IDS`.\n *\n * Used for the startup `agent registered` log so operators can see\n * which endpoint each agent points at by default. Per-request\n * overrides (`X-Mastra-Model` etc.) and the workspace-catalogue\n * fuzzy match are still applied at runtime.\n */\nfunction describeAgentDefaultModel(config: MastraPluginConfig, def: MastraAgentDefinition): string {\n  const effective = def.model ?? config.defaultModel;\n  if (typeof effective === \"string\") return effective;\n  if (effective !== undefined) return \"<dynamic>\";\n  return (\n    process.env.DATABRICKS_SERVING_ENDPOINT_NAME ??\n    config.defaultModelFallbacks?.[0] ??\n    fallback.FALLBACK_MODEL_IDS[0]!\n  );\n}\n\n/**\n * Normalize `config.agents` into a `Record<id, definition>`. Accepts\n * any of the three shapes documented on\n * {@link MastraPluginConfig.agents}:\n *\n * - Record - returned as-is when non-empty.\n * - Single definition (detected via the required `instructions`\n *   field) - keyed by `slugify(def.name)` or `FALLBACK_AGENT_ID`.\n * - Array - keyed by `slugify(def.name)` or `agent_${i}`; duplicate\n *   slugs fail loudly so users know to set explicit names.\n *\n * Omitted or empty inputs fall back to a single built-in analyst so\n * the bare `mastra()` call still mounts a working chat route.\n */\nfunction resolveDefinitions(config: MastraPluginConfig): Record<string, MastraAgentDefinition> {\n  const input = config.agents;\n  if (!input) return fallbackDefinitions();\n\n  if (Array.isArray(input)) {\n    if (input.length === 0) return fallbackDefinitions();\n    const out: Record<string, MastraAgentDefinition> = {};\n    input.forEach((def, i) => {\n      const key = deriveAgentKey(def, i);\n      if (out[key]) {\n        throw new ConfigurationError(\n          `mastra: duplicate agent id \"${key}\" derived from name \"${def.name ?? \"\"}\"; ` +\n            `set unique \\`name\\`s on each definition`,\n        );\n      }\n      out[key] = def;\n    });\n    return out;\n  }\n\n  // Single-definition shorthand: an agent always has `instructions: string`,\n  // a record-of-agents never has that field directly.\n  if (typeof (input as MastraAgentDefinition).instructions === \"string\") {\n    const def = input as MastraAgentDefinition;\n    const key = deriveAgentKey(def);\n    return { [key]: def };\n  }\n\n  const record = input as Record<string, MastraAgentDefinition>;\n  if (Object.keys(record).length === 0) return fallbackDefinitions();\n  return record;\n}\n\n/** Derive a registry id from a definition's `name`, with a fallback. */\nfunction deriveAgentKey(def: MastraAgentDefinition, index?: number): string {\n  if (def.name) {\n    const slug = string.toIdentifier(def.name);\n    if (slug) return slug;\n  }\n  return index === undefined ? FALLBACK_AGENT_ID : `agent_${index}`;\n}\n\n/** Built-in fallback registry used when `agents` is omitted / empty. */\nfunction fallbackDefinitions(): Record<string, MastraAgentDefinition> {\n  return {\n    [FALLBACK_AGENT_ID]: {\n      name: \"Default Agent\",\n      instructions: FALLBACK_AGENT_INSTRUCTIONS,\n    },\n  };\n}\n\n/**\n * Pick the effective model spec for an agent. Fallback ladder, in\n * order:\n *\n *   1. Per-agent `def.model` (string sugar or `DynamicArgument`).\n *   2. Plugin-level `config.defaultModel` (string sugar or\n *      `DynamicArgument`) - mirrors AppKit's `agents({ defaultModel })`.\n *   3. The auto-resolver that mints user-scoped tokens against\n *      `/serving-endpoints` via {@link buildModel}.\n *\n * String values are treated as `modelId` sugar and threaded through\n * `buildModel`'s override hook so the runtime fuzzy matcher and the\n * per-request `X-Mastra-Model` override layer on top of the static\n * choice. Non-string `DynamicArgument`s are passed through verbatim;\n * callers that need full control over `providerId` / `headers` /\n * `modelId` bypass the resolver pipeline entirely.\n */\nfunction resolveModel(\n  config: MastraPluginConfig,\n  override: MastraAgentDefinition[\"model\"],\n): AgentConfig[\"model\"] {\n  const effective = override ?? config.defaultModel;\n  if (effective === undefined) {\n    return ({ requestContext }) => buildModel(config, requestContext);\n  }\n  if (typeof effective === \"string\") {\n    const modelId = effective;\n    return ({ requestContext }) => buildModel(config, requestContext, { modelId });\n  }\n  return effective;\n}\n\n/**\n * Resolve a definition's `tools` field to a flat `MastraTools` record,\n * merging in plugin-level ambient tools (per-agent tools win on key\n * collision). Callback errors propagate verbatim so the original stack\n * survives - the caller already knows which agent was registering.\n */\nasync function resolveTools(\n  defTools: MastraAgentDefinition[\"tools\"],\n  plugins: MastraPlugins,\n  ambientTools: MastraTools,\n): Promise<MastraTools> {\n  if (!defTools) return { ...ambientTools };\n  const resolved = typeof defTools === \"function\" ? await defTools(plugins) : defTools;\n  return { ...ambientTools, ...resolved };\n}\n\nfunction resolveAgentWorkspace(\n  workspace: MastraAgentDefinition[\"workspace\"],\n): Workspace | undefined {\n  if (!workspace) return undefined;\n  return typeof workspace === \"function\" ? workspace() : workspace;\n}\n\n/**\n * Build the {@link MastraPlugins} runtime proxy handed to\n * `tools(plugins)` callbacks.\n *\n * Implemented as a `Proxy` over the AppKit plugin context so\n * `plugins.<name>` resolves at first access. Any sibling plugin that\n * implements AppKit's standard `ToolProvider` interface\n * (`toolkit(opts?)` + `executeAgentTool(name, args, signal?)`) is\n * auto-adapted into Mastra tools. Unknown names return `undefined`,\n * matching AppKit's `Plugins` semantics so `plugins.foo?.toolkit()`\n * remains safe in environments where `foo` isn't registered.\n *\n * `genie` is special-cased to swap the generic AppKit toolkit (which\n * runs `executeAgentTool` and only emits a single final `tool-result`\n * chunk per call) for the streaming-aware tools built by\n * {@link buildGenieToolkitProvider}. The streaming variant forwards each\n * Genie wire event (status, SQL, row counts, errors) out through the\n * Mastra `ctx.writer`, so the UI gets `tool-output` chunks in real\n * time instead of staring at a spinner for the full Genie round-trip.\n */\nfunction buildPluginsMap(\n  config: MastraPluginConfig,\n  context: plugin.PluginContextLike | undefined,\n): MastraPlugins {\n  const cache = new Map<string, MastraPluginToolkitProvider | null>();\n  return new Proxy({} as MastraPlugins, {\n    get(_target, propName) {\n      if (typeof propName !== \"string\") return undefined;\n      if (cache.has(propName)) return cache.get(propName) ?? undefined;\n      const provider = resolveProvider(config, context, propName);\n      cache.set(propName, provider);\n      return provider ?? undefined;\n    },\n  });\n}\n\n/**\n * Pick the right {@link MastraPluginToolkitProvider} for a sibling\n * plugin lookup. Returns the Genie agent-backed adapter when\n * the caller asks for `genie` AND at least one space is reachable\n * via {@link resolveGenieSpaces} (the explicit\n * `config.genieSpaces`, the registered AppKit `genie()` plugin's\n * `spaces` config, or the `DATABRICKS_GENIE_SPACE_ID` env var).\n * Falls back to the generic AppKit `ToolProvider` adapter for\n * every other plugin name. `config` is threaded through so the\n * Genie agent inherits the same model resolver / fallback\n * ladder the calling agents use.\n *\n * The Genie tools talk to Genie directly through `@dbx-tools/genie`\n * (`genieEventChat`) and the workspace `statementExecution.getStatement`\n * API; AppKit's stock `genie` plugin contributes only its resource\n * manifest and `spaces` config, so an `app.yaml` resource binding and a\n * `genie({ spaces })` record have the same meaning here as they do there.\n */\nfunction resolveProvider(\n  config: MastraPluginConfig,\n  context: plugin.PluginContextLike | undefined,\n  propName: string,\n): MastraPluginToolkitProvider | null {\n  if (propName === \"genie\") {\n    const spaces = resolveGenieSpaces(config, context);\n    if (Object.keys(spaces).length === 0) return null;\n    return buildGenieToolkitProvider({\n      spaces,\n      config,\n    }) as MastraPluginToolkitProvider;\n  }\n  const plugin = context?.getPlugins().get(propName);\n  return adaptPluginToolkit(plugin);\n}\n\n/**\n * AppKit `ToolProvider` shape we duck-type against any registered\n * plugin. Defined structurally to avoid coupling to AppKit's internal\n * type module layout.\n */\ninterface AppKitToolkitProvider {\n  toolkit?: (opts?: ToolkitOptions) => Record<string, AppKitToolkitEntry>;\n  executeAgentTool?: (name: string, args: unknown, signal?: AbortSignal) => Promise<unknown>;\n}\n\n/** Single entry returned by an AppKit plugin's `.toolkit(opts)` call. */\ninterface AppKitToolkitEntry {\n  pluginName: string;\n  localName: string;\n  def: {\n    name: string;\n    description: string;\n    parameters: unknown;\n  };\n}\n\n/**\n * Adapt an AppKit `ToolProvider` plugin instance into a\n * {@link MastraPluginToolkitProvider}. Returns `null` for any plugin\n * that doesn't implement both `toolkit` and `executeAgentTool` (e.g.\n * `server`, `lakebase` when used only as a Postgres pool, etc.).\n */\nfunction adaptPluginToolkit(plugin: unknown): MastraPluginToolkitProvider | null {\n  if (!plugin || typeof plugin !== \"object\") return null;\n  const p = plugin as AppKitToolkitProvider;\n  if (typeof p.toolkit !== \"function\" || typeof p.executeAgentTool !== \"function\") {\n    return null;\n  }\n  return {\n    toolkit(opts?: ToolkitOptions): MastraTools {\n      const entries = p.toolkit!(opts);\n      const tools: MastraTools = {};\n      for (const [key, entry] of Object.entries(entries)) {\n        tools[key] = toolkitEntryToMastraTool(entry, p);\n      }\n      return tools;\n    },\n  };\n}\n\n/**\n * Wrap a single {@link AppKitToolkitEntry} as a Mastra tool whose\n * `execute` dispatches back through `plugin.executeAgentTool(...)` so\n * AppKit's OBO auth (`asUser`) and telemetry spans stay intact. JSON\n * Schema parameters pass through unchanged - Mastra's `PublicSchema`\n * accepts `JSONSchema7` directly via `@mastra/schema-compat`.\n */\nfunction toolkitEntryToMastraTool(entry: AppKitToolkitEntry, plugin: AppKitToolkitProvider): Tool {\n  return createTool({\n    id: `${entry.pluginName}__${entry.localName}`,\n    description: entry.def.description,\n    ...(entry.def.parameters ? { inputSchema: entry.def.parameters as never } : {}),\n    execute: async (input: unknown, context: unknown) => {\n      const signal = (context as { abortSignal?: AbortSignal } | undefined)?.abortSignal;\n      return plugin.executeAgentTool!(entry.localName, input, signal);\n    },\n  });\n}\n"]}