@dbx-tools/appkit-mastra 0.3.44 → 0.4.0

package/lib/src/config.js

@@ -0,0 +1,190 @@
+/**
+ * Plugin configuration types and shared `RequestContext` keys.
+ *
+ * Owns the typed {@link MastraPluginConfig} (the plugin's slice of AppKit
+ * config) and {@link MASTRA_CONFIG_SCHEMA}, the JSON Schema the manifest
+ * publishes for it so scaffolding tools and agents can read the option set.
+ *
+ * Precedence per field is explicit plugin config, then the environment
+ * variable named on the field, then a built-in default.
+ *
+ * Kept in a leaf module so `plugin.ts`, `server.ts`, `model.ts`, and
+ * `memory.ts` can import them without creating a cycle.
+ *
+ * @module
+ */
+import { getExecutionContext } from "@databricks/appkit";
+import { MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY } from "@mastra/core/request-context";
+/**
+ * `RequestContext` key under which {@link MastraServer} stores the
+ * resolved AppKit user. `model.ts` reads it to mint user-scoped
+ * Databricks tokens.
+ */
+export const MASTRA_USER_KEY = "mastra__user";
+/**
+ * `RequestContext` keys for AppKit user metadata stamped by
+ * {@link MastraServer}. Surfaced as trace metadata via
+ * {@link TRACE_REQUEST_CONTEXT_KEYS} so traces are filterable by who
+ * issued the request without leaking the full user object.
+ */
+export const MASTRA_USER_NAME_KEY = "mastra__userName";
+export const MASTRA_USER_EMAIL_KEY = "mastra__userEmail";
+/**
+ * `RequestContext` key for the per-HTTP-request id stamped by
+ * {@link MastraServer}. Reads `X-Request-Id` from the incoming
+ * headers when present (so an upstream load balancer / API gateway
+ * can keep its trace correlation), falls back to a freshly minted
+ * UUID. Echoed back on the response and surfaced on every span via
+ * {@link TRACE_REQUEST_CONTEXT_KEYS} so logs and traces share a
+ * join key.
+ */
+export const MASTRA_REQUEST_ID_KEY = "mastra__requestId";
+/**
+ * `RequestContext` key for OAuth scopes parsed from the forwarded
+ * access token by {@link MastraServer.configureRequestContextScopes}.
+ * Workspace mounts that touch Databricks workspace files require
+ * `workspace` or `all-apis` in this list.
+ */
+export const MASTRA_SCOPES_KEY = "mastra__scopes";
+/**
+ * Canonical list of `RequestContext` keys we want Mastra to extract
+ * as metadata on every observability span (agent runs, model calls,
+ * tool invocations, workflow steps).
+ *
+ * Mirrors {@link https://mastra.ai/docs/observability/tracing/overview#automatic-metadata-from-requestcontext}:
+ * passed verbatim into `Observability.configs[*].requestContextKeys`,
+ * so any key listed here is read from `RequestContext` at trace
+ * start and attached as scalar span metadata. Keep the set to plain
+ * scalars - never include {@link MASTRA_USER_KEY} (it carries the
+ * full AppKit execution context with a `WorkspaceClient` reference).
+ *
+ * Order is purely cosmetic; Mastra de-dupes internally.
+ */
+export const TRACE_REQUEST_CONTEXT_KEYS = [
+    MASTRA_RESOURCE_ID_KEY,
+    MASTRA_THREAD_ID_KEY,
+    MASTRA_REQUEST_ID_KEY,
+    MASTRA_USER_NAME_KEY,
+    MASTRA_USER_EMAIL_KEY,
+    // Model override key is owned by `serving.ts`; spelled inline here
+    // so this module stays leaf-level (no cycles with `serving.ts`).
+    "mastra__model_override",
+];
+/**
+ * Canonical identity for an AppKit execution context: the OBO user id on a
+ * user-scoped call, the service principal id otherwise.
+ */
+export function executionContextUserId(context) {
+    return "userId" in context ? context.userId : context.serviceUserId;
+}
+/**
+ * Identity every per-user cache entry is namespaced under, so an OBO result
+ * cannot be read back by another caller.
+ *
+ * Prefers the {@link User} that {@link MastraServer} stamps on the request
+ * context. The MCP transport routes do not thread that context into tool
+ * execution, so those fall back to the ambient execution context (the active
+ * OBO scope, or the service principal).
+ */
+export function resolveUserKey(requestContext) {
+    const user = requestContext?.get(MASTRA_USER_KEY);
+    return user?.id ?? executionContextUserId(getExecutionContext());
+}
+/**
+ * JSON Schema published on the manifest's `config.schema`, mirroring the
+ * documented defaults and environment fallbacks of {@link MastraPluginConfig}.
+ *
+ * Covers the JSON-expressible options only. `agents`, `tools`, and a
+ * `defaultModel` passed as a Mastra `DynamicArgument` are code-defined
+ * (functions / class instances), so they carry no schema entry; the
+ * `defaultModel` property below describes its string form.
+ */
+export const MASTRA_CONFIG_SCHEMA = {
+    type: "object",
+    properties: {
+        providerId: {
+            type: "string",
+            description: 'Mastra OpenAI-compatible provider id. Defaults to "databricks".',
+        },
+        storage: {
+            type: ["boolean", "object"],
+            description: "PostgresStore for Mastra threads / messages. `true` reuses the `lakebase` plugin's pool, an object opens a dedicated store. Auto-enabled when the `lakebase` plugin is registered.",
+        },
+        memory: {
+            type: ["boolean", "object"],
+            description: "PgVector store for Mastra semantic recall. `true` reuses the `lakebase` plugin's pool, an object opens a dedicated store. Auto-enabled when the `lakebase` plugin is registered.",
+        },
+        defaultAgent: {
+            type: "string",
+            description: "Agent id used when the client names none. Defaults to the first registered agent, else the built-in `default`.",
+        },
+        defaultModel: {
+            type: "string",
+            description: "Serving endpoint applied to every agent that omits its own model. Falls back to DATABRICKS_SERVING_ENDPOINT_NAME, then the auto-resolved catalogue.",
+        },
+        defaultModelFallbacks: {
+            type: "array",
+            items: { type: "string" },
+            description: "Priority-ordered endpoint names tried before the score-classified catalogue when nothing else pins a model.",
+        },
+        modelFuzzyMatch: {
+            type: "boolean",
+            description: "Fuzzy-match loose model names against the workspace catalogue. Defaults to true.",
+        },
+        modelFuzzyThreshold: {
+            type: "number",
+            description: "Fuse.js score threshold for the fuzzy matcher, 0 (exact) to 1 (anything). Defaults to 0.4.",
+        },
+        modelCacheTtlMs: {
+            type: "number",
+            description: "TTL in ms for the serving-endpoints list cache, per workspace host. Defaults to 5 minutes.",
+        },
+        modelOverride: {
+            type: "boolean",
+            description: "Honor a per-request model override from the X-Mastra-Model header, ?model= query, or a `model` body field. Defaults to true.",
+        },
+        genieSpaces: {
+            type: "object",
+            additionalProperties: { type: ["string", "object"] },
+            description: "Genie spaces the agents can delegate to, keyed by alias (the tool-name suffix). Each value is a space id or `{ spaceId, hint }`. Falls back to the `genie` plugin's own `spaces` config, then DATABRICKS_GENIE_SPACE_ID under the `default` alias.",
+        },
+        genieSpaceCacheTtlMs: {
+            type: "number",
+            description: "TTL in ms for the Genie space metadata cache. Defaults to 5 minutes.",
+        },
+        agentMaxSteps: {
+            type: "number",
+            description: "Maximum LLM steps each agent gets per turn (a tool call and the final reply each consume one). Defaults to 25.",
+        },
+        stripStaleCharts: {
+            type: "boolean",
+            description: "Strip chartIds from recalled assistant tool results so the model cannot reuse a turn-scoped chart marker. Defaults to true.",
+        },
+        styleInstructions: {
+            type: ["string", "boolean"],
+            description: "Style guardrails appended to every agent's instructions. A string replaces the built-in block, `false` disables it.",
+        },
+        observability: {
+            type: "boolean",
+            description: "Bridge Mastra spans into AppKit's OTel pipeline. Defaults to on only when OTEL_EXPORTER_OTLP_ENDPOINT or OTEL_EXPORTER_OTLP_TRACES_ENDPOINT is set.",
+        },
+        feedback: {
+            type: "boolean",
+            description: "Log thumbs / comment assessments to MLflow and surface the feedback controls. Defaults to on only when an OTLP endpoint and MLFLOW_EXPERIMENT_ID or MLFLOW_EXPERIMENT_NAME are set.",
+        },
+        mcp: {
+            type: ["boolean", "object"],
+            description: "Expose the registered agents over MCP. Defaults to agents-only; an object tunes the server id, advertised metadata, and whether ambient tools are exposed.",
+        },
+        apiAccess: {
+            type: "string",
+            enum: ["scoped", "full"],
+            description: 'How much of the stock @mastra/express API is reachable through the mount. "scoped" (default) allows agent inference, read-only agent metadata, this plugin\'s own routes, and MCP; "full" dispatches the entire management surface.',
+        },
+        brand: {
+            type: "object",
+            description: "Portable brand context applied to generated charts (series palette from colors.primary / colors.accent, base font from typography.sans).",
+        },
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Plugin configuration types and shared `RequestContext` keys.\n *\n * Owns the typed {@link MastraPluginConfig} (the plugin's slice of AppKit\n * config) and {@link MASTRA_CONFIG_SCHEMA}, the JSON Schema the manifest\n * publishes for it so scaffolding tools and agents can read the option set.\n *\n * Precedence per field is explicit plugin config, then the environment\n * variable named on the field, then a built-in default.\n *\n * Kept in a leaf module so `plugin.ts`, `server.ts`, `model.ts`, and\n * `memory.ts` can import them without creating a cycle.\n *\n * @module\n */\n\nimport { getExecutionContext, type BasePluginConfig, type ConfigSchema } from \"@databricks/appkit\";\nimport { appkit } from \"@dbx-tools/appkit\";\nimport type { BrandContext } from \"@dbx-tools/shared-core\";\nimport type { AgentConfig } from \"@mastra/core/agent\";\nimport type { RequestContext } from \"@mastra/core/request-context\";\nimport { MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY } from \"@mastra/core/request-context\";\nimport type { PgVectorConfig, PostgresStoreConfig } from \"@mastra/pg\";\n\nimport type { MastraAgentDefinition, MastraTools } from \"./agents\";\nimport type { GenieSpacesConfig } from \"./genie\";\n\n/**\n * `RequestContext` key under which {@link MastraServer} stores the\n * resolved AppKit user. `model.ts` reads it to mint user-scoped\n * Databricks tokens.\n */\nexport const MASTRA_USER_KEY = \"mastra__user\";\n\n/**\n * `RequestContext` keys for AppKit user metadata stamped by\n * {@link MastraServer}. Surfaced as trace metadata via\n * {@link TRACE_REQUEST_CONTEXT_KEYS} so traces are filterable by who\n * issued the request without leaking the full user object.\n */\nexport const MASTRA_USER_NAME_KEY = \"mastra__userName\";\nexport const MASTRA_USER_EMAIL_KEY = \"mastra__userEmail\";\n\n/**\n * `RequestContext` key for the per-HTTP-request id stamped by\n * {@link MastraServer}. Reads `X-Request-Id` from the incoming\n * headers when present (so an upstream load balancer / API gateway\n * can keep its trace correlation), falls back to a freshly minted\n * UUID. Echoed back on the response and surfaced on every span via\n * {@link TRACE_REQUEST_CONTEXT_KEYS} so logs and traces share a\n * join key.\n */\nexport const MASTRA_REQUEST_ID_KEY = \"mastra__requestId\";\n\n/**\n * `RequestContext` key for OAuth scopes parsed from the forwarded\n * access token by {@link MastraServer.configureRequestContextScopes}.\n * Workspace mounts that touch Databricks workspace files require\n * `workspace` or `all-apis` in this list.\n */\nexport const MASTRA_SCOPES_KEY = \"mastra__scopes\";\n\n/**\n * Canonical list of `RequestContext` keys we want Mastra to extract\n * as metadata on every observability span (agent runs, model calls,\n * tool invocations, workflow steps).\n *\n * Mirrors {@link https://mastra.ai/docs/observability/tracing/overview#automatic-metadata-from-requestcontext}:\n * passed verbatim into `Observability.configs[*].requestContextKeys`,\n * so any key listed here is read from `RequestContext` at trace\n * start and attached as scalar span metadata. Keep the set to plain\n * scalars - never include {@link MASTRA_USER_KEY} (it carries the\n * full AppKit execution context with a `WorkspaceClient` reference).\n *\n * Order is purely cosmetic; Mastra de-dupes internally.\n */\nexport const TRACE_REQUEST_CONTEXT_KEYS: readonly string[] = [\n  MASTRA_RESOURCE_ID_KEY,\n  MASTRA_THREAD_ID_KEY,\n  MASTRA_REQUEST_ID_KEY,\n  MASTRA_USER_NAME_KEY,\n  MASTRA_USER_EMAIL_KEY,\n  // Model override key is owned by `serving.ts`; spelled inline here\n  // so this module stays leaf-level (no cycles with `serving.ts`).\n  \"mastra__model_override\",\n];\n\n/** AppKit execution context plus the canonical user id. */\nexport interface User {\n  id: string;\n  executionContext: appkit.ExecutionContextLike;\n}\n\n/**\n * Canonical identity for an AppKit execution context: the OBO user id on a\n * user-scoped call, the service principal id otherwise.\n */\nexport function executionContextUserId(context: appkit.ExecutionContextLike): string {\n  return \"userId\" in context ? context.userId : context.serviceUserId;\n}\n\n/**\n * Identity every per-user cache entry is namespaced under, so an OBO result\n * cannot be read back by another caller.\n *\n * Prefers the {@link User} that {@link MastraServer} stamps on the request\n * context. The MCP transport routes do not thread that context into tool\n * execution, so those fall back to the ambient execution context (the active\n * OBO scope, or the service principal).\n */\nexport function resolveUserKey(requestContext?: RequestContext): string {\n  const user = requestContext?.get(MASTRA_USER_KEY) as User | undefined;\n  return user?.id ?? executionContextUserId(getExecutionContext());\n}\n\n/** PgVector config with an optional Mastra store id. */\nexport type MastraMemoryConfig = PgVectorConfig & {\n  id?: string;\n};\n\n/**\n * Fine-grained control for the optional MCP server exposure\n * ({@link MastraPluginConfig.mcp}). Every field is optional; the object\n * form only needs to set what differs from the defaults.\n */\nexport interface MastraMcpConfig {\n  /**\n   * Server id used in the route path (`/mcp/<serverId>/...`) and as the\n   * MCP registry id. Defaults to the plugin's registered name.\n   */\n  serverId?: string;\n  /** Display name advertised over MCP. Defaults to `\"<displayName> MCP\"`. */\n  name?: string;\n  /** Semantic version advertised over MCP. Defaults to `\"1.0.0\"`. */\n  version?: string;\n  /** Optional human-readable description advertised over MCP. */\n  description?: string;\n  /**\n   * Expose every registered agent as an `ask_<agentId>` MCP tool.\n   * Defaults to `true` - this is the \"leverage the Mastra agents over\n   * MCP\" behavior most callers want.\n   */\n  agents?: boolean;\n  /**\n   * Also expose the plugin's ambient tools (the built-in `render_data`\n   * plus anything in `config.tools`) as MCP tools. Defaults to `false`:\n   * the ambient tools assume an in-process chat turn (they publish\n   * writer events the chat UI consumes), so they aren't useful to a\n   * standalone MCP client. Turn this on only when those tools are safe\n   * to call out-of-band.\n   */\n  tools?: boolean;\n  /**\n   * Extra tools to expose over MCP beyond the agent / ambient sets.\n   * Use this for tools written specifically for MCP consumers.\n   */\n  extraTools?: MastraTools;\n}\n\n/** Configuration accepted by the Mastra AppKit plugin. */\nexport interface MastraPluginConfig extends BasePluginConfig {\n  /** Mastra OpenAI-compatible provider id. Defaults to `\"databricks\"`; no env fallback. */\n  providerId?: string;\n  /**\n   * PostgresStore for Mastra threads/messages. `true` reuses the\n   * `lakebase` plugin's pool; an object opens a dedicated store.\n   */\n  storage?: boolean | PostgresStoreConfig;\n  /**\n   * PgVector store for Mastra memory recall. `true` reuses the\n   * `lakebase` plugin's pool; an object opens a dedicated store.\n   */\n  memory?: boolean | MastraMemoryConfig;\n  /**\n   * Code-defined agents. Accepts three shapes for convenience:\n   *\n   * - **Record**: `{ analyst: def, helper: def }` - keys become the\n   *   registered ids and the first key is the default.\n   * - **Single definition**: `def` - registered under\n   *   `slugify(def.name)` (or `\"default\"` when `name` is omitted) and\n   *   automatically marked as the default agent.\n   * - **Array**: `[def1, def2]` - each registered under\n   *   `slugify(def.name)` (or `agent_${i}` when `name` is omitted);\n   *   the first entry is the default.\n   *\n   * Each entry becomes a Mastra `Agent` reachable at\n   * `/api/<plugin>/route/chat/<id>` (the chat route also matches\n   * `:agentId`). When `agents` is omitted entirely, the plugin\n   * registers a single built-in `default` analyst so the bare\n   * `mastra()` call still mounts a working chat endpoint.\n   *\n   * @example Single-agent shorthand\n   * ```ts\n   * mastra({\n   *   agents: createAgent({ instructions: \"...\" }),\n   * });\n   * ```\n   *\n   * @example Array\n   * ```ts\n   * mastra({\n   *   agents: [\n   *     createAgent({ name: \"analyst\", instructions: \"...\" }),\n   *     createAgent({ name: \"helper\", instructions: \"...\" }),\n   *   ],\n   * });\n   * ```\n   *\n   * @example Record (explicit ids)\n   * ```ts\n   * mastra({\n   *   agents: {\n   *     analyst: createAgent({ instructions: \"...\" }),\n   *     helper: createAgent({ instructions: \"...\" }),\n   *   },\n   *   defaultAgent: \"analyst\",\n   * });\n   * ```\n   */\n  agents?: Record<string, MastraAgentDefinition> | MastraAgentDefinition | MastraAgentDefinition[];\n  /**\n   * Ambient tools spread into every registered agent's tools record;\n   * per-agent tools win on key collision. Use for a small shared\n   * library; for per-agent tools set `agents[id].tools` instead.\n   */\n  tools?: MastraTools;\n  /**\n   * Agent id used when the client doesn't specify one (the bare,\n   * un-suffixed history / suggestions routes resolve to it).\n   * Defaults to the first key in `agents` (or `\"default\"` when\n   * `agents` is omitted). Must match an id in `agents` when both are\n   * set; a mismatch throws at setup with the available candidates.\n   */\n  defaultAgent?: string;\n  /**\n   * Plugin-level default model applied to every agent that omits its\n   * own `model`. Mirrors AppKit's `agents({ defaultModel })`.\n   *\n   * - `string`: shorthand for \"use the OBO auto-resolver but swap the\n   *   `modelId`\" (e.g. `\"databricks-claude-sonnet-4-6\"`).\n   * - Any other Mastra `DynamicArgument<MastraModelConfig>`: passed\n   *   through verbatim. Use this when you need full control over auth\n   *   or `providerId`.\n   *\n   * Resolution order per agent: `def.model` → `defaultModel` →\n   * `DATABRICKS_SERVING_ENDPOINT_NAME` → built-in `/serving-endpoints`\n   * resolver.\n   */\n  defaultModel?: AgentConfig[\"model\"] | string;\n  /**\n   * Fuzzy-match loose model names (`\"claude sonnet\"`) against the workspace's\n   * Model Serving endpoints. Defaults to `true`; no env fallback.\n   *\n   * Set `false` to require exact endpoint names everywhere.\n   */\n  modelFuzzyMatch?: boolean;\n  /**\n   * Fuse.js score threshold for the fuzzy matcher, 0 (exact) to 1 (anything).\n   * Defaults to `0.4`; no env fallback.\n   *\n   * Lower values reject loose matches; raise it if you have a sprawling\n   * endpoint catalogue with similar-looking names.\n   */\n  modelFuzzyThreshold?: number;\n  /**\n   * TTL for the in-memory serving-endpoints list cache, in milliseconds.\n   * Defaults to 5 minutes; no env fallback.\n   *\n   * The cache is per workspace host and shared across users; concurrent\n   * callers coalesce on a single in-flight fetch.\n   */\n  modelCacheTtlMs?: number;\n  /**\n   * Let clients pick the backing endpoint per request. Defaults to `true`;\n   * no env fallback.\n   *\n   * Reads the `X-Mastra-Model` header, the `?model=` query string, or a\n   * `model` body field, in that order. Disable when running multi-tenant\n   * where untrusted clients shouldn't choose the endpoint.\n   */\n  modelOverride?: boolean;\n  /**\n   * Priority-ordered list of endpoint names tried *first* when no\n   * agent / plugin / env / request-override model id is set, ahead of\n   * the dynamic score-classified catalogue. The resolver picks the\n   * first id that is actually present in the workspace's\n   * `/serving-endpoints` listing.\n   *\n   * When unset, resolution is driven by the live Foundation Model API\n   * `quality` / `speed` / `cost` scores: endpoints are classified into\n   * chat classes (`classifyEndpoints`) and walked best-first\n   * (ChatThinking -> ChatBalanced -> ChatFast), with the small built-in\n   * `FALLBACK_MODEL_IDS` list as the floor when the catalogue can't be\n   * read. Set this to\n   * pin a regulated workspace to an approved subset, or to put custom\n   * endpoints in front of the auto-classified catalogue.\n   */\n  defaultModelFallbacks?: readonly string[];\n  /**\n   * When `true` (default), every agent gets a built-in input\n   * processor that strips `chartId` fields from prior assistant\n   * tool-invocation results before they reach the model. This\n   * prevents the model from reusing turn-scoped chartIds it sees\n   * in memory recall (which would leave `[chart:<id>]` markers\n   * pointing at writer events that no longer exist).\n   *\n   * Set to `false` to opt out - useful if a non-default agent\n   * needs full visibility into prior chartIds (e.g. an audit\n   * agent reasoning about chart lineage).\n   */\n  stripStaleCharts?: boolean;\n  /**\n   * Style guardrails appended to every agent's `instructions` to curb\n   * common LLM-isms (em dashes, emojis, sycophantic openers, throwaway\n   * closers, excessive hedging).\n   *\n   * - `undefined` (default): use the built-in\n   *   `DEFAULT_STYLE_INSTRUCTIONS` from `agents.ts`.\n   * - `string`: replace the default with the supplied block.\n   * - `false`: disable entirely (agents see only their bespoke\n   *   `instructions`).\n   *\n   * Appended (not prepended) so the agent's role and rules come first\n   * and the style block leans on the model's recency bias.\n   */\n  styleInstructions?: string | false;\n  /**\n   * Genie spaces this plugin's agents can delegate to. One Mastra\n   * tool is registered per alias (`genie` for the well-known\n   * `default` alias, `genie_<alias>` otherwise). Each tool spins\n   * up a per-question Genie sub-agent that runs Databricks\n   * \"agent mode\" against the space, broadcasts wire events to the\n   * UI, fetches statement rows for non-empty results, and returns\n   * a `(string | data | chart)[]` summary the host UI renders\n   * inline.\n   *\n   * Entries accept either a full {@link GenieSpaceConfig} object\n   * or a bare `space_id` string when no extras are needed:\n   *\n   * ```ts\n   * mastra({\n   *   genieSpaces: {\n   *     default: \"01ef0d3c0e1b1f4a8d2c3e4f5a6b7c8d\",\n   *     forecasts: { spaceId: \"01ef...\", hint: \"weekly demand forecasts\" },\n   *   },\n   * });\n   * ```\n   *\n   * Reach the spaces from an agent's `tools(plugins)` callback via\n   * `plugins.genie?.toolkit()`; the resulting tools accept\n   * `{ content, conversationId? }` and return a hydrated summary.\n   *\n   * **Fallback discovery** (highest precedence first): if this\n   * field is omitted, the Genie agent also picks up spaces from\n   * (1) the AppKit `genie({ spaces: { ... } })` plugin instance\n   * when registered, and (2) the `DATABRICKS_GENIE_SPACE_ID`\n   * env var (registered under the `default` alias). This keeps\n   * existing AppKit deployments working without restating the\n   * spaces config in two places.\n   */\n  genieSpaces?: GenieSpacesConfig;\n  /**\n   * TTL for the in-memory Genie space metadata cache, in\n   * milliseconds. Defaults to 5 minutes. The Genie agent calls\n   * `client.genie.getSpace(...)` on every cold-start to get the\n   * title / description / warehouse id; cached responses skip the\n   * round-trip and concurrent callers coalesce on a single\n   * in-flight fetch. Drop to a smaller value when analysts are\n   * actively editing space metadata and you want changes visible\n   * within seconds; raise it to amortise the round-trip when\n   * space metadata is effectively frozen.\n   *\n   * Backed by AppKit's `CacheManager`, so the cache participates\n   * in telemetry spans (`cache.getOrExecute`) and benefits from\n   * Lakebase persistence when the `lakebase` plugin is wired up.\n   */\n  genieSpaceCacheTtlMs?: number;\n  /**\n   * Maximum LLM steps each agent gets per turn. One step = one\n   * round-trip to the underlying model (a tool call consumes a\n   * step, the final-text reply consumes one too). Applies to\n   * every agent registered through {@link MastraPluginConfig.agents}\n   * - per-agent overrides aren't surfaced yet because the same\n   * ceiling has been sufficient across every workload we've run.\n   *\n   * Defaults to {@link DEFAULT_AGENT_MAX_STEPS} (25), sized to fit\n   * a decomposed Genie turn (grounding + several `ask_genie` calls\n   * + `prepare_chart` per dataset + the final-text reply) with\n   * headroom for the model to chain a couple of follow-ups before\n   * answering. Mastra's own `agent.generate` default of 5 would\n   * cut multi-step orchestration off after 2-3 tool calls, so\n   * explicitly raising the ceiling here is what lets the\n   * agent-mode loop play out.\n   *\n   * Lower when an unusually slow or expensive model makes long\n   * turns unaffordable; raise for exploratory workloads that need\n   * to drill deep into a dataset within a single turn.\n   */\n  agentMaxSteps?: number;\n  /**\n   * Wire Mastra spans into AppKit's global OTel pipeline via\n   * `@mastra/otel-bridge`.\n   *\n   * - `undefined` (default, auto): on only when\n   *   `OTEL_EXPORTER_OTLP_ENDPOINT` or\n   *   `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` is set. When unset, the\n   *   bridge is skipped so Mastra does not log\n   *   `[OtelBridge] No OTEL span found` on the noop tracer.\n   * - `true`: force on even without an OTLP endpoint.\n   * - `false`: force off.\n   */\n  observability?: boolean;\n  /**\n   * Log user feedback (thumbs up/down + freeform comments) to MLflow as\n   * trace assessments, and surface the feedback controls in the chat UI.\n   *\n   * - `undefined` (default, auto): enabled only when MLflow tracing is\n   *   wired - an OTLP exporter endpoint is set and an MLflow experiment\n   *   is named (the same signals the observability pipeline needs to\n   *   ship traces to MLflow). Otherwise off, since there'd be no trace\n   *   to attach feedback to.\n   * - `true`: force on. Feedback controls show and writes are attempted\n   *   regardless of env detection (use when the env is configured in a\n   *   way the auto-probe doesn't recognize).\n   * - `false`: force off. No trace-id header, no feedback route, no UI.\n   *\n   * Feedback attaches to a turn's MLflow trace via the OpenTelemetry\n   * trace id the server stamps on each response; see `mlflow.ts`.\n   */\n  feedback?: boolean;\n  /**\n   * Expose the plugin's agents (and optionally tools) as a Mastra MCP\n   * server so external MCP clients - Claude Desktop, Cursor, the Mastra\n   * playground, or another agent - can call them over the standard MCP\n   * transports. Enabled by default (agents only): wrapping the\n   * already-registered agents costs nothing extra, so the endpoint is on\n   * out of the box; only the ambient tools (which assume an in-process\n   * chat turn) stay off unless explicitly opted in.\n   *\n   * - `undefined` (default) / `true`: expose every registered agent as\n   *   an `ask_<agentId>` MCP tool under a server whose id is the plugin\n   *   name.\n   * - `false`: no MCP endpoints.\n   * - {@link MastraMcpConfig}: fine-grained control over the server id,\n   *   advertised metadata, and which agents / tools are exposed.\n   *\n   * When enabled, the stock Mastra MCP routes mount under the plugin's\n   * base path (no bespoke route is added - the server is handed to the\n   * `Mastra` instance via `mcpServers`, which `@mastra/express` serves):\n   *\n   * - Streamable HTTP: `POST /api/<plugin>/mcp/<serverId>/mcp`\n   * - SSE (legacy):    `GET  /api/<plugin>/mcp/<serverId>/sse`\n   *                    `POST /api/<plugin>/mcp/<serverId>/messages`\n   *\n   * Requests run under the same AppKit OBO scope as the chat routes, so\n   * an agent invoked over MCP resolves its model and tools as the\n   * calling user.\n   */\n  mcp?: boolean | MastraMcpConfig;\n  /**\n   * How much of the stock `@mastra/express` management API is reachable\n   * through the plugin mount. `@mastra/express` registers its full route\n   * table (agent inference plus admin / mutating routes: direct tool\n   * execution, workflow control, raw memory read/write, telemetry, logs,\n   * scores). AppKit already authenticates every request as the OBO user,\n   * but nothing there restricts *which* of those operations the browser\n   * client may invoke.\n   *\n   * - `\"scoped\"` (default): only the routes the chat client legitimately\n   *   needs are dispatched to Mastra - agent inference\n   *   (`stream` / `generate` / `network`), read-only agent metadata, this\n   *   plugin's own OBO- and resource-scoped `/route/*` routes (history /\n   *   threads), and, when {@link mcp} is enabled, the MCP transport.\n   *   Everything else (tool execution, workflow control, raw memory,\n   *   telemetry, logs, scores, and other mutations) is rejected with\n   *   `403` before it reaches Mastra.\n   * - `\"full\"`: dispatch the entire stock Mastra API. Use only for a\n   *   trusted first-party console that genuinely needs the management\n   *   surface.\n   */\n  apiAccess?: \"scoped\" | \"full\";\n  /**\n   * Optional brand context applied to charts produced by the built-in\n   * `render_data` / `prepare_chart` tools. When set, the chart planner's\n   * Echarts output is themed with the brand's palette (series colors derived\n   * from `colors.primary` / `colors.accent`) and sans font\n   * (`typography.sans`) instead of Echarts' defaults. Omit for the default\n   * Echarts look.\n   *\n   * Pass the portable {@link BrandContext} shared across the UI and\n   * libraries (e.g. `brand.defaultBrandContext` from `@dbx-tools/shared-core`,\n   * or a customer brand) - the same object the email add-on and the UI\n   * `BrandProvider` consume, so a host themes charts, email, and UI from one\n   * source.\n   */\n  brand?: BrandContext;\n}\n\n/**\n * JSON Schema published on the manifest's `config.schema`, mirroring the\n * documented defaults and environment fallbacks of {@link MastraPluginConfig}.\n *\n * Covers the JSON-expressible options only. `agents`, `tools`, and a\n * `defaultModel` passed as a Mastra `DynamicArgument` are code-defined\n * (functions / class instances), so they carry no schema entry; the\n * `defaultModel` property below describes its string form.\n */\nexport const MASTRA_CONFIG_SCHEMA: ConfigSchema = {\n  type: \"object\",\n  properties: {\n    providerId: {\n      type: \"string\",\n      description: 'Mastra OpenAI-compatible provider id. Defaults to \"databricks\".',\n    },\n    storage: {\n      type: [\"boolean\", \"object\"],\n      description:\n        \"PostgresStore for Mastra threads / messages. `true` reuses the `lakebase` plugin's pool, an object opens a dedicated store. Auto-enabled when the `lakebase` plugin is registered.\",\n    },\n    memory: {\n      type: [\"boolean\", \"object\"],\n      description:\n        \"PgVector store for Mastra semantic recall. `true` reuses the `lakebase` plugin's pool, an object opens a dedicated store. Auto-enabled when the `lakebase` plugin is registered.\",\n    },\n    defaultAgent: {\n      type: \"string\",\n      description:\n        \"Agent id used when the client names none. Defaults to the first registered agent, else the built-in `default`.\",\n    },\n    defaultModel: {\n      type: \"string\",\n      description:\n        \"Serving endpoint applied to every agent that omits its own model. Falls back to DATABRICKS_SERVING_ENDPOINT_NAME, then the auto-resolved catalogue.\",\n    },\n    defaultModelFallbacks: {\n      type: \"array\",\n      items: { type: \"string\" },\n      description:\n        \"Priority-ordered endpoint names tried before the score-classified catalogue when nothing else pins a model.\",\n    },\n    modelFuzzyMatch: {\n      type: \"boolean\",\n      description:\n        \"Fuzzy-match loose model names against the workspace catalogue. Defaults to true.\",\n    },\n    modelFuzzyThreshold: {\n      type: \"number\",\n      description:\n        \"Fuse.js score threshold for the fuzzy matcher, 0 (exact) to 1 (anything). Defaults to 0.4.\",\n    },\n    modelCacheTtlMs: {\n      type: \"number\",\n      description:\n        \"TTL in ms for the serving-endpoints list cache, per workspace host. Defaults to 5 minutes.\",\n    },\n    modelOverride: {\n      type: \"boolean\",\n      description:\n        \"Honor a per-request model override from the X-Mastra-Model header, ?model= query, or a `model` body field. Defaults to true.\",\n    },\n    genieSpaces: {\n      type: \"object\",\n      additionalProperties: { type: [\"string\", \"object\"] },\n      description:\n        \"Genie spaces the agents can delegate to, keyed by alias (the tool-name suffix). Each value is a space id or `{ spaceId, hint }`. Falls back to the `genie` plugin's own `spaces` config, then DATABRICKS_GENIE_SPACE_ID under the `default` alias.\",\n    },\n    genieSpaceCacheTtlMs: {\n      type: \"number\",\n      description: \"TTL in ms for the Genie space metadata cache. Defaults to 5 minutes.\",\n    },\n    agentMaxSteps: {\n      type: \"number\",\n      description:\n        \"Maximum LLM steps each agent gets per turn (a tool call and the final reply each consume one). Defaults to 25.\",\n    },\n    stripStaleCharts: {\n      type: \"boolean\",\n      description:\n        \"Strip chartIds from recalled assistant tool results so the model cannot reuse a turn-scoped chart marker. Defaults to true.\",\n    },\n    styleInstructions: {\n      type: [\"string\", \"boolean\"],\n      description:\n        \"Style guardrails appended to every agent's instructions. A string replaces the built-in block, `false` disables it.\",\n    },\n    observability: {\n      type: \"boolean\",\n      description:\n        \"Bridge Mastra spans into AppKit's OTel pipeline. Defaults to on only when OTEL_EXPORTER_OTLP_ENDPOINT or OTEL_EXPORTER_OTLP_TRACES_ENDPOINT is set.\",\n    },\n    feedback: {\n      type: \"boolean\",\n      description:\n        \"Log thumbs / comment assessments to MLflow and surface the feedback controls. Defaults to on only when an OTLP endpoint and MLFLOW_EXPERIMENT_ID or MLFLOW_EXPERIMENT_NAME are set.\",\n    },\n    mcp: {\n      type: [\"boolean\", \"object\"],\n      description:\n        \"Expose the registered agents over MCP. Defaults to agents-only; an object tunes the server id, advertised metadata, and whether ambient tools are exposed.\",\n    },\n    apiAccess: {\n      type: \"string\",\n      enum: [\"scoped\", \"full\"],\n      description:\n        'How much of the stock @mastra/express API is reachable through the mount. \"scoped\" (default) allows agent inference, read-only agent metadata, this plugin\\'s own routes, and MCP; \"full\" dispatches the entire management surface.',\n    },\n    brand: {\n      type: \"object\",\n      description:\n        \"Portable brand context applied to generated charts (series palette from colors.primary / colors.accent, base font from typography.sans).\",\n    },\n  },\n};\n"]}

package/lib/src/defaults.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Interceptor defaults for every outbound call the plugin's own routes make
+ * through `Plugin.execute()`.
+ *
+ * One constant per call site so the cache / retry / timeout decision lives
+ * beside its reasoning instead of at the call site. The interceptor chain runs
+ * telemetry, timeout, retry, cache, so a disabled interceptor is a deliberate
+ * choice and is commented as such.
+ *
+ * The cache interceptor is inert without a `cache.cacheKey`, which is
+ * request-specific (a statement id, an agent id). Call sites therefore spread
+ * the constant and add the key; the identity namespace comes from the
+ * execution context's user id, which `execute()` resolves on its own.
+ *
+ * Cancellation is not expressed here: `execute()` derives a signal from the
+ * `timeout` setting only, so a caller's own signal is combined with it at the
+ * call site instead.
+ *
+ * @module
+ */
+/**
+ * Per-call interceptor settings. Structural stand-in for AppKit's
+ * `PluginExecuteConfig`: the barrel exports `StreamExecutionSettings` but not
+ * the non-streaming config, so the nominal type is unimportable here. Declared
+ * as a type alias (not an interface) so it keeps the implicit index signature
+ * AppKit's own config carries.
+ */
+type ExecuteConfig = {
+    cache?: {
+        enabled?: boolean;
+        ttl?: number;
+        cacheKey?: (string | number | object)[];
+    };
+    retry?: {
+        enabled?: boolean;
+        attempts?: number;
+        initialDelay?: number;
+        maxDelay?: number;
+    };
+    timeout?: number;
+};
+/** Default plus optional user-scoped settings, as `execute()` accepts them. */
+type ExecuteSettings = {
+    default: ExecuteConfig;
+    user?: ExecuteConfig;
+};
+/**
+ * `GET /models`: the workspace's Model Serving catalogue.
+ */
+export declare const modelCatalogueDefaults: ExecuteSettings;
+/**
+ * `GET /suggestions`: the curated `sample_questions` on each Genie space.
+ */
+export declare const genieSuggestionDefaults: ExecuteSettings;
+/**
+ * `GET /embed/data/:id`: one Statement Execution result set.
+ */
+export declare const statementDataDefaults: ExecuteSettings;
+/**
+ * `GET /embed/chart/:id`: the cached chart entry behind a `[chart:<id>]`
+ * marker.
+ */
+export declare const chartFetchDefaults: ExecuteSettings;
+/**
+ * `POST /route/feedback`: an MLflow trace assessment.
+ */
+export declare const feedbackWriteDefaults: ExecuteSettings;
+export {};

package/lib/src/defaults.js

@@ -0,0 +1,107 @@
+/**
+ * Interceptor defaults for every outbound call the plugin's own routes make
+ * through `Plugin.execute()`.
+ *
+ * One constant per call site so the cache / retry / timeout decision lives
+ * beside its reasoning instead of at the call site. The interceptor chain runs
+ * telemetry, timeout, retry, cache, so a disabled interceptor is a deliberate
+ * choice and is commented as such.
+ *
+ * The cache interceptor is inert without a `cache.cacheKey`, which is
+ * request-specific (a statement id, an agent id). Call sites therefore spread
+ * the constant and add the key; the identity namespace comes from the
+ * execution context's user id, which `execute()` resolves on its own.
+ *
+ * Cancellation is not expressed here: `execute()` derives a signal from the
+ * `timeout` setting only, so a caller's own signal is combined with it at the
+ * call site instead.
+ *
+ * @module
+ */
+/** Ceiling on a single Model Serving / Genie / MLflow REST round-trip. */
+const REST_TIMEOUT_MS = 30_000;
+/** Ceiling on one Statement Execution fetch, which can page a large result. */
+const STATEMENT_TIMEOUT_MS = 60_000;
+/** TTL for a cached statement result set, in seconds. */
+const STATEMENT_CACHE_TTL_SEC = 5 * 60;
+/**
+ * `GET /models`: the workspace's Model Serving catalogue.
+ */
+export const modelCatalogueDefaults = {
+    default: {
+        // Cache disabled here because `listServingEndpoints` already memoizes the
+        // catalogue through the same `CacheManager`, keyed by workspace host with
+        // `config.modelCacheTtlMs`. That entry is shared across identities; a
+        // second interceptor cache would duplicate it once per user.
+        cache: { enabled: false },
+        // Retry enabled: listing endpoints is an idempotent GET, and the listing
+        // is on the chat UI's load path, so a transient 5xx should not blank the
+        // model picker.
+        retry: { enabled: true, attempts: 3 },
+        timeout: REST_TIMEOUT_MS,
+    },
+};
+/**
+ * `GET /suggestions`: the curated `sample_questions` on each Genie space.
+ */
+export const genieSuggestionDefaults = {
+    default: {
+        // Cache disabled here because `collectSpaceSuggestions` keeps its own
+        // space-id-keyed entry; the questions are authored config, identical for
+        // every caller, so caching them per identity would only fan out copies.
+        cache: { enabled: false },
+        // Retry enabled: reading space metadata is idempotent, and the route
+        // degrades to an empty starter list on failure, so one retry is cheaper
+        // than an empty chat state.
+        retry: { enabled: true, attempts: 2 },
+        timeout: REST_TIMEOUT_MS,
+    },
+};
+/**
+ * `GET /embed/data/:id`: one Statement Execution result set.
+ */
+export const statementDataDefaults = {
+    default: {
+        // Cache enabled: a completed statement's result set is immutable, and the
+        // same id is re-fetched every time the transcript re-renders a
+        // `[data:<statement_id>]` marker. The entry is namespaced by the caller's
+        // identity, so an OBO result never crosses users.
+        cache: { enabled: true, ttl: STATEMENT_CACHE_TTL_SEC },
+        // Retry enabled: fetching a statement by id is idempotent.
+        retry: { enabled: true, attempts: 3 },
+        timeout: STATEMENT_TIMEOUT_MS,
+    },
+};
+/**
+ * `GET /embed/chart/:id`: the cached chart entry behind a `[chart:<id>]`
+ * marker.
+ */
+export const chartFetchDefaults = {
+    default: {
+        // Cache disabled: the read long-polls a cache entry that is expected to
+        // change from processing to settled, so a cached answer would pin the
+        // client to the pre-planner state.
+        cache: { enabled: false },
+        // Retry disabled: the helper already polls to its own deadline, so a retry
+        // would only restart a wait the caller is already inside.
+        retry: { enabled: false },
+        // No timeout: the poll budget is per request (`?timeoutMs=`, capped by the
+        // route) and cancellation rides the connection's abort signal, so a second
+        // ceiling here could cut a legitimate long-poll short.
+    },
+};
+/**
+ * `POST /route/feedback`: an MLflow trace assessment.
+ */
+export const feedbackWriteDefaults = {
+    default: {
+        // Cache disabled: a write, and each submission is a distinct assessment.
+        cache: { enabled: false },
+        // Retry disabled: posting an assessment is not idempotent (a retry records
+        // a duplicate), and `logFeedback` already retries the one recoverable case
+        // itself, the trace not having finished exporting to MLflow yet.
+        retry: { enabled: false },
+        timeout: REST_TIMEOUT_MS,
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../src/defaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAqBH,0EAA0E;AAC1E,MAAM,eAAe,GAAG,MAAM,CAAC;AAE/B,+EAA+E;AAC/E,MAAM,oBAAoB,GAAG,MAAM,CAAC;AAEpC,yDAAyD;AACzD,MAAM,uBAAuB,GAAG,CAAC,GAAG,EAAE,CAAC;AAEvC;;GAEG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAoB;IACrD,OAAO,EAAE;QACP,0EAA0E;QAC1E,0EAA0E;QAC1E,sEAAsE;QACtE,6DAA6D;QAC7D,KAAK,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;QACzB,yEAAyE;QACzE,yEAAyE;QACzE,gBAAgB;QAChB,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE;QACrC,OAAO,EAAE,eAAe;KACzB;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAoB;IACtD,OAAO,EAAE;QACP,sEAAsE;QACtE,yEAAyE;QACzE,wEAAwE;QACxE,KAAK,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;QACzB,qEAAqE;QACrE,wEAAwE;QACxE,4BAA4B;QAC5B,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE;QACrC,OAAO,EAAE,eAAe;KACzB;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAoB;IACpD,OAAO,EAAE;QACP,0EAA0E;QAC1E,+DAA+D;QAC/D,0EAA0E;QAC1E,kDAAkD;QAClD,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,uBAAuB,EAAE;QACtD,2DAA2D;QAC3D,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE;QACrC,OAAO,EAAE,oBAAoB;KAC9B;CACF,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAoB;IACjD,OAAO,EAAE;QACP,wEAAwE;QACxE,sEAAsE;QACtE,mCAAmC;QACnC,KAAK,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;QACzB,2EAA2E;QAC3E,0DAA0D;QAC1D,KAAK,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;QACzB,2EAA2E;QAC3E,2EAA2E;QAC3E,uDAAuD;KACxD;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAoB;IACpD,OAAO,EAAE;QACP,yEAAyE;QACzE,KAAK,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;QACzB,2EAA2E;QAC3E,2EAA2E;QAC3E,iEAAiE;QACjE,KAAK,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;QACzB,OAAO,EAAE,eAAe;KACzB;CACF,CAAC","sourcesContent":["/**\n * Interceptor defaults for every outbound call the plugin's own routes make\n * through `Plugin.execute()`.\n *\n * One constant per call site so the cache / retry / timeout decision lives\n * beside its reasoning instead of at the call site. The interceptor chain runs\n * telemetry, timeout, retry, cache, so a disabled interceptor is a deliberate\n * choice and is commented as such.\n *\n * The cache interceptor is inert without a `cache.cacheKey`, which is\n * request-specific (a statement id, an agent id). Call sites therefore spread\n * the constant and add the key; the identity namespace comes from the\n * execution context's user id, which `execute()` resolves on its own.\n *\n * Cancellation is not expressed here: `execute()` derives a signal from the\n * `timeout` setting only, so a caller's own signal is combined with it at the\n * call site instead.\n *\n * @module\n */\n\n/**\n * Per-call interceptor settings. Structural stand-in for AppKit's\n * `PluginExecuteConfig`: the barrel exports `StreamExecutionSettings` but not\n * the non-streaming config, so the nominal type is unimportable here. Declared\n * as a type alias (not an interface) so it keeps the implicit index signature\n * AppKit's own config carries.\n */\ntype ExecuteConfig = {\n  cache?: { enabled?: boolean; ttl?: number; cacheKey?: (string | number | object)[] };\n  retry?: { enabled?: boolean; attempts?: number; initialDelay?: number; maxDelay?: number };\n  timeout?: number;\n};\n\n/** Default plus optional user-scoped settings, as `execute()` accepts them. */\ntype ExecuteSettings = {\n  default: ExecuteConfig;\n  user?: ExecuteConfig;\n};\n\n/** Ceiling on a single Model Serving / Genie / MLflow REST round-trip. */\nconst REST_TIMEOUT_MS = 30_000;\n\n/** Ceiling on one Statement Execution fetch, which can page a large result. */\nconst STATEMENT_TIMEOUT_MS = 60_000;\n\n/** TTL for a cached statement result set, in seconds. */\nconst STATEMENT_CACHE_TTL_SEC = 5 * 60;\n\n/**\n * `GET /models`: the workspace's Model Serving catalogue.\n */\nexport const modelCatalogueDefaults: ExecuteSettings = {\n  default: {\n    // Cache disabled here because `listServingEndpoints` already memoizes the\n    // catalogue through the same `CacheManager`, keyed by workspace host with\n    // `config.modelCacheTtlMs`. That entry is shared across identities; a\n    // second interceptor cache would duplicate it once per user.\n    cache: { enabled: false },\n    // Retry enabled: listing endpoints is an idempotent GET, and the listing\n    // is on the chat UI's load path, so a transient 5xx should not blank the\n    // model picker.\n    retry: { enabled: true, attempts: 3 },\n    timeout: REST_TIMEOUT_MS,\n  },\n};\n\n/**\n * `GET /suggestions`: the curated `sample_questions` on each Genie space.\n */\nexport const genieSuggestionDefaults: ExecuteSettings = {\n  default: {\n    // Cache disabled here because `collectSpaceSuggestions` keeps its own\n    // space-id-keyed entry; the questions are authored config, identical for\n    // every caller, so caching them per identity would only fan out copies.\n    cache: { enabled: false },\n    // Retry enabled: reading space metadata is idempotent, and the route\n    // degrades to an empty starter list on failure, so one retry is cheaper\n    // than an empty chat state.\n    retry: { enabled: true, attempts: 2 },\n    timeout: REST_TIMEOUT_MS,\n  },\n};\n\n/**\n * `GET /embed/data/:id`: one Statement Execution result set.\n */\nexport const statementDataDefaults: ExecuteSettings = {\n  default: {\n    // Cache enabled: a completed statement's result set is immutable, and the\n    // same id is re-fetched every time the transcript re-renders a\n    // `[data:<statement_id>]` marker. The entry is namespaced by the caller's\n    // identity, so an OBO result never crosses users.\n    cache: { enabled: true, ttl: STATEMENT_CACHE_TTL_SEC },\n    // Retry enabled: fetching a statement by id is idempotent.\n    retry: { enabled: true, attempts: 3 },\n    timeout: STATEMENT_TIMEOUT_MS,\n  },\n};\n\n/**\n * `GET /embed/chart/:id`: the cached chart entry behind a `[chart:<id>]`\n * marker.\n */\nexport const chartFetchDefaults: ExecuteSettings = {\n  default: {\n    // Cache disabled: the read long-polls a cache entry that is expected to\n    // change from processing to settled, so a cached answer would pin the\n    // client to the pre-planner state.\n    cache: { enabled: false },\n    // Retry disabled: the helper already polls to its own deadline, so a retry\n    // would only restart a wait the caller is already inside.\n    retry: { enabled: false },\n    // No timeout: the poll budget is per request (`?timeoutMs=`, capped by the\n    // route) and cancellation rides the connection's abort signal, so a second\n    // ceiling here could cut a legitimate long-poll short.\n  },\n};\n\n/**\n * `POST /route/feedback`: an MLflow trace assessment.\n */\nexport const feedbackWriteDefaults: ExecuteSettings = {\n  default: {\n    // Cache disabled: a write, and each submission is a distinct assessment.\n    cache: { enabled: false },\n    // Retry disabled: posting an assessment is not idempotent (a retry records\n    // a duplicate), and `logFeedback` already retries the one recoverable case\n    // itself, the trace not having finished exporting to MLflow yet.\n    retry: { enabled: false },\n    timeout: REST_TIMEOUT_MS,\n  },\n};\n"]}