@dbx-tools/appkit-mastra 0.3.44 → 0.4.0

package/lib/src/threads.js

@@ -0,0 +1,301 @@
+/**
+ * Conversation-thread listing exposed as a Mastra custom API route.
+ *
+ * Backed entirely by native Mastra: looks up the active agent by id,
+ * asks its `Memory` instance to `listThreads` filtered to the caller's
+ * resource, and shapes each into the JSON-safe {@link MastraThread}
+ * wire type. A sibling `DELETE` removes a single named thread.
+ *
+ * A sibling `DELETE` removes a single named thread; a `PATCH` renames
+ * one ({@link renameThread}).
+ *
+ * Like {@link historyRoute} this registers through Mastra's
+ * `registerApiRoute` so it shares the `MastraServer` auth-middleware
+ * pipeline (in `./server.ts`), which has already stamped the resource
+ * id (`MASTRA_RESOURCE_ID_KEY`) and the targeted thread id
+ * (`MASTRA_THREAD_ID_KEY`, resolved from the thread-selection header /
+ * cookie) on `RequestContext` by the time a handler runs. Resource
+ * scoping lives here so a caller can only ever see, rename, or delete
+ * its own threads; no cookie or user lookups happen in this module.
+ *
+ * @module
+ */
+import { ValidationError } from "@databricks/appkit";
+import { log } from "@dbx-tools/shared-core";
+import { wire, } from "@dbx-tools/shared-mastra";
+import { MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY } from "@mastra/core/request-context";
+import { registerApiRoute } from "@mastra/core/server";
+import { clampPerPage, parseIntParam } from "./pagination.js";
+import { invalidFields } from "./validation.js";
+const logger = log.logger("mastra/threads");
+/** Default threads page size. */
+const DEFAULT_PER_PAGE = 30;
+/** Hard cap so a misbehaving client can't fetch every thread at once. */
+const MAX_PER_PAGE = 200;
+/** Stable client message for a rename body that fails schema validation. */
+const INVALID_RENAME_MESSAGE = "Invalid thread rename request";
+/**
+ * Fetch a page of the resource's conversation threads, newest
+ * (`updatedAt` DESC) first.
+ *
+ * Uses the agent's resolved `Memory` (`getMemory()`) so the per-agent
+ * storage namespace (`mastra_<agentId>` schema) applies automatically.
+ * When the agent has no memory configured the response is a successful
+ * empty page so callers don't have to special-case stateless agents.
+ */
+export async function listThreads(opts) {
+    const perPage = clampPerPage(opts.perPage, {
+        fallback: DEFAULT_PER_PAGE,
+        max: MAX_PER_PAGE,
+    });
+    const page = Math.max(0, Math.trunc(opts.page ?? 0));
+    const memory = await opts.agent.getMemory();
+    if (!memory) {
+        logger.debug("list:no-memory", { agentId: opts.agent.id });
+        return { threads: [], page, perPage, total: 0, hasMore: false };
+    }
+    const startedAt = Date.now();
+    const result = await memory.listThreads({
+        filter: { resourceId: opts.resourceId },
+        page,
+        perPage,
+        orderBy: { field: "updatedAt", direction: "DESC" },
+    });
+    const threads = result.threads.map(toWireThread);
+    logger.debug("list:done", {
+        agentId: opts.agent.id,
+        resourceId: opts.resourceId,
+        page,
+        perPage,
+        returned: threads.length,
+        total: result.total,
+        hasMore: result.hasMore,
+        elapsedMs: Date.now() - startedAt,
+    });
+    return {
+        threads,
+        page,
+        perPage,
+        total: result.total,
+        hasMore: result.hasMore,
+    };
+}
+/**
+ * Delete a single named thread (and every message on it).
+ *
+ * Ownership is enforced: the thread is only removed when it belongs to
+ * the calling resource, so a client can't delete another user's
+ * conversation by guessing its id. A thread that doesn't exist (or
+ * isn't owned by the caller) is a successful no-op (`deleted: false`)
+ * so the UI can fire-and-forget.
+ */
+export async function deleteThread(opts) {
+    const memory = await opts.agent.getMemory();
+    if (!memory) {
+        logger.debug("delete:no-memory", { agentId: opts.agent.id });
+        return { deleted: false };
+    }
+    // Confirm the thread exists and is owned by the caller before
+    // deleting; never let a guessed id touch another resource's data.
+    const existing = await memory.getThreadById({ threadId: opts.threadId });
+    if (!existing || existing.resourceId !== opts.resourceId) {
+        logger.debug("delete:not-owned", {
+            agentId: opts.agent.id,
+            threadId: opts.threadId,
+            found: existing !== null,
+        });
+        return { deleted: false };
+    }
+    const startedAt = Date.now();
+    await memory.deleteThread(opts.threadId);
+    logger.info("delete:done", {
+        agentId: opts.agent.id,
+        threadId: opts.threadId,
+        elapsedMs: Date.now() - startedAt,
+    });
+    return { deleted: true };
+}
+/**
+ * Rename a single thread, returning the updated wire thread.
+ *
+ * Ownership is enforced the same way {@link deleteThread} enforces it:
+ * the title is only changed when the thread belongs to the calling
+ * resource, so a client can't rename another user's conversation by
+ * guessing its id. Existing thread `metadata` is preserved untouched
+ * (Mastra's `updateThread` replaces the row, so it must be passed back
+ * in). Returns `null` when the thread doesn't exist, isn't owned by the
+ * caller, or the agent has no memory configured, letting the route map
+ * that to a 404.
+ */
+export async function renameThread(opts) {
+    const memory = await opts.agent.getMemory();
+    if (!memory) {
+        logger.debug("rename:no-memory", { agentId: opts.agent.id });
+        return null;
+    }
+    const existing = await memory.getThreadById({ threadId: opts.threadId });
+    if (!existing || existing.resourceId !== opts.resourceId) {
+        logger.debug("rename:not-owned", {
+            agentId: opts.agent.id,
+            threadId: opts.threadId,
+            found: existing !== null,
+        });
+        return null;
+    }
+    const startedAt = Date.now();
+    const updated = await memory.updateThread({
+        id: opts.threadId,
+        title: opts.title,
+        metadata: existing.metadata ?? {},
+    });
+    logger.info("rename:done", {
+        agentId: opts.agent.id,
+        threadId: opts.threadId,
+        elapsedMs: Date.now() - startedAt,
+    });
+    return toWireThread(updated);
+}
+/**
+ * Register the `<path>` Mastra custom API route. Handles three methods
+ * on the same mount:
+ *
+ *   - `GET`: a page of the resource's conversation threads
+ *     ({@link listThreads}).
+ *   - `DELETE`: remove the thread named by the thread-selection header
+ *     / `?threadId=` query ({@link deleteThread}). The id is read from
+ *     `RequestContext` (the auth middleware resolves it the same way it
+ *     does for streaming and history), so the client deletes any of its
+ *     threads by stamping the target id - no separate path param.
+ *   - `PATCH`: rename the thread named by the thread-selection header /
+ *     `?threadId=` query to the `{ title }` in the JSON body
+ *     ({@link renameThread}). Targets a thread the same way `DELETE`
+ *     does; 404s when the thread isn't owned by the caller.
+ *
+ * Follows the `@mastra/ai-sdk` agent-binding convention: pass `agent`
+ * for a fixed-agent mount, or include `:agentId` in the path for
+ * dynamic routing. The plugin registers both `/route/threads` (default
+ * agent) and `/route/threads/:agentId`.
+ */
+export function threadsRoute(options) {
+    const { path } = options;
+    const fixedAgent = "agent" in options ? options.agent : undefined;
+    if (!fixedAgent && !path.includes(":agentId")) {
+        throw ValidationError.invalidValue("threadsRoute.path", path, "a path containing `:agentId`, or an explicit `agent`");
+    }
+    // Shared by GET / DELETE: resolve the active agent and the caller's
+    // resource id, returning a JSON error response when either is
+    // missing. Keeps both handlers thin with identical validation.
+    const resolveContext = (c) => {
+        const mastra = c.get("mastra");
+        const requestContext = c.get("requestContext");
+        const agentId = fixedAgent ?? c.req.param("agentId");
+        if (!agentId) {
+            return { error: c.json({ error: "agentId is required" }, 400) };
+        }
+        const agent = mastra.getAgentById(agentId);
+        if (!agent) {
+            return {
+                error: c.json({ error: `Unknown agent "${agentId}"` }, 404),
+            };
+        }
+        const resourceId = requestContext.get(MASTRA_RESOURCE_ID_KEY);
+        if (!resourceId) {
+            return {
+                error: c.json({ error: "resource id missing from request context" }, 400),
+            };
+        }
+        return { agentId, agent, requestContext, resourceId };
+    };
+    return [
+        registerApiRoute(path, {
+            method: "GET",
+            handler: async (c) => {
+                const ctx = resolveContext(c);
+                if ("error" in ctx)
+                    return ctx.error;
+                const payload = await listThreads({
+                    agent: ctx.agent,
+                    resourceId: ctx.resourceId,
+                    page: parseIntParam(c.req.query("page")),
+                    perPage: parseIntParam(c.req.query("perPage")),
+                });
+                return c.json(payload);
+            },
+        }),
+        registerApiRoute(path, {
+            method: "DELETE",
+            handler: async (c) => {
+                const ctx = resolveContext(c);
+                if ("error" in ctx)
+                    return ctx.error;
+                const threadId = ctx.requestContext.get(MASTRA_THREAD_ID_KEY);
+                if (!threadId) {
+                    return c.json({ error: "thread id missing from request context" }, 400);
+                }
+                const { deleted } = await deleteThread({
+                    agent: ctx.agent,
+                    threadId,
+                    resourceId: ctx.resourceId,
+                });
+                const payload = {
+                    ok: true,
+                    agentId: ctx.agentId,
+                    threadId,
+                    deleted,
+                };
+                return c.json(payload);
+            },
+        }),
+        registerApiRoute(path, {
+            method: "PATCH",
+            handler: async (c) => {
+                const ctx = resolveContext(c);
+                if ("error" in ctx)
+                    return ctx.error;
+                const threadId = ctx.requestContext.get(MASTRA_THREAD_ID_KEY);
+                if (!threadId) {
+                    return c.json({ error: "thread id missing from request context" }, 400);
+                }
+                const body = wire.MastraUpdateThreadRequestSchema.safeParse(await c.req.json());
+                if (!body.success) {
+                    logger.warn("rename:invalid", { error: body.error.message });
+                    return c.json({ error: INVALID_RENAME_MESSAGE, fields: invalidFields(body.error) }, 400);
+                }
+                const thread = await renameThread({
+                    agent: ctx.agent,
+                    threadId,
+                    resourceId: ctx.resourceId,
+                    title: body.data.title,
+                });
+                if (!thread) {
+                    return c.json({ error: `Unknown thread "${threadId}"` }, 404);
+                }
+                const payload = {
+                    ok: true,
+                    agentId: ctx.agentId,
+                    thread,
+                };
+                return c.json(payload);
+            },
+        }),
+    ];
+}
+/** Coerce a Mastra `StorageThreadType` into the JSON-safe wire shape. */
+function toWireThread(thread) {
+    return {
+        id: thread.id,
+        ...(thread.title ? { title: thread.title } : {}),
+        resourceId: thread.resourceId,
+        createdAt: toIso(thread.createdAt),
+        updatedAt: toIso(thread.updatedAt),
+        ...(thread.metadata ? { metadata: thread.metadata } : {}),
+    };
+}
+/** Render a storage timestamp as an ISO-8601 string for the wire. */
+function toIso(value) {
+    if (value instanceof Date)
+        return value.toISOString();
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? new Date(0).toISOString() : parsed.toISOString();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"threads.js","sourceRoot":"","sources":["../../src/threads.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Conversation-thread listing exposed as a Mastra custom API route.\n *\n * Backed entirely by native Mastra: looks up the active agent by id,\n * asks its `Memory` instance to `listThreads` filtered to the caller's\n * resource, and shapes each into the JSON-safe {@link MastraThread}\n * wire type. A sibling `DELETE` removes a single named thread.\n *\n * A sibling `DELETE` removes a single named thread; a `PATCH` renames\n * one ({@link renameThread}).\n *\n * Like {@link historyRoute} this registers through Mastra's\n * `registerApiRoute` so it shares the `MastraServer` auth-middleware\n * pipeline (in `./server.ts`), which has already stamped the resource\n * id (`MASTRA_RESOURCE_ID_KEY`) and the targeted thread id\n * (`MASTRA_THREAD_ID_KEY`, resolved from the thread-selection header /\n * cookie) on `RequestContext` by the time a handler runs. Resource\n * scoping lives here so a caller can only ever see, rename, or delete\n * its own threads; no cookie or user lookups happen in this module.\n *\n * @module\n */\n\nimport { ValidationError } from \"@databricks/appkit\";\nimport { log } from \"@dbx-tools/shared-core\";\nimport {\n  wire,\n  type MastraDeleteThreadResponse,\n  type MastraThread,\n  type MastraThreadsResponse,\n  type MastraUpdateThreadResponse,\n} from \"@dbx-tools/shared-mastra\";\nimport type { Agent } from \"@mastra/core/agent\";\nimport type { StorageThreadType } from \"@mastra/core/memory\";\nimport { MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY } from \"@mastra/core/request-context\";\nimport type { ContextWithMastra } from \"@mastra/core/server\";\nimport { registerApiRoute } from \"@mastra/core/server\";\n\nimport { clampPerPage, parseIntParam } from \"./pagination\";\nimport { invalidFields } from \"./validation\";\n\nconst logger = log.logger(\"mastra/threads\");\n\n/** Default threads page size. */\nconst DEFAULT_PER_PAGE = 30;\n/** Hard cap so a misbehaving client can't fetch every thread at once. */\nconst MAX_PER_PAGE = 200;\n/** Stable client message for a rename body that fails schema validation. */\nconst INVALID_RENAME_MESSAGE = \"Invalid thread rename request\";\n\n/** Inputs accepted by {@link listThreads}. */\nexport interface ListThreadsOptions {\n  agent: Agent;\n  resourceId: string;\n  page?: number;\n  perPage?: number;\n}\n\n/**\n * Fetch a page of the resource's conversation threads, newest\n * (`updatedAt` DESC) first.\n *\n * Uses the agent's resolved `Memory` (`getMemory()`) so the per-agent\n * storage namespace (`mastra_<agentId>` schema) applies automatically.\n * When the agent has no memory configured the response is a successful\n * empty page so callers don't have to special-case stateless agents.\n */\nexport async function listThreads(opts: ListThreadsOptions): Promise<MastraThreadsResponse> {\n  const perPage = clampPerPage(opts.perPage, {\n    fallback: DEFAULT_PER_PAGE,\n    max: MAX_PER_PAGE,\n  });\n  const page = Math.max(0, Math.trunc(opts.page ?? 0));\n  const memory = await opts.agent.getMemory();\n  if (!memory) {\n    logger.debug(\"list:no-memory\", { agentId: opts.agent.id });\n    return { threads: [], page, perPage, total: 0, hasMore: false };\n  }\n  const startedAt = Date.now();\n  const result = await memory.listThreads({\n    filter: { resourceId: opts.resourceId },\n    page,\n    perPage,\n    orderBy: { field: \"updatedAt\", direction: \"DESC\" },\n  });\n  const threads = result.threads.map(toWireThread);\n  logger.debug(\"list:done\", {\n    agentId: opts.agent.id,\n    resourceId: opts.resourceId,\n    page,\n    perPage,\n    returned: threads.length,\n    total: result.total,\n    hasMore: result.hasMore,\n    elapsedMs: Date.now() - startedAt,\n  });\n  return {\n    threads,\n    page,\n    perPage,\n    total: result.total,\n    hasMore: result.hasMore,\n  };\n}\n\n/** Inputs accepted by {@link deleteThread}. */\nexport interface DeleteThreadOptions {\n  agent: Agent;\n  threadId: string;\n  resourceId: string;\n}\n\n/**\n * Delete a single named thread (and every message on it).\n *\n * Ownership is enforced: the thread is only removed when it belongs to\n * the calling resource, so a client can't delete another user's\n * conversation by guessing its id. A thread that doesn't exist (or\n * isn't owned by the caller) is a successful no-op (`deleted: false`)\n * so the UI can fire-and-forget.\n */\nexport async function deleteThread(opts: DeleteThreadOptions): Promise<{ deleted: boolean }> {\n  const memory = await opts.agent.getMemory();\n  if (!memory) {\n    logger.debug(\"delete:no-memory\", { agentId: opts.agent.id });\n    return { deleted: false };\n  }\n  // Confirm the thread exists and is owned by the caller before\n  // deleting; never let a guessed id touch another resource's data.\n  const existing = await memory.getThreadById({ threadId: opts.threadId });\n  if (!existing || existing.resourceId !== opts.resourceId) {\n    logger.debug(\"delete:not-owned\", {\n      agentId: opts.agent.id,\n      threadId: opts.threadId,\n      found: existing !== null,\n    });\n    return { deleted: false };\n  }\n  const startedAt = Date.now();\n  await memory.deleteThread(opts.threadId);\n  logger.info(\"delete:done\", {\n    agentId: opts.agent.id,\n    threadId: opts.threadId,\n    elapsedMs: Date.now() - startedAt,\n  });\n  return { deleted: true };\n}\n\n/** Inputs accepted by {@link renameThread}. */\nexport interface RenameThreadOptions {\n  agent: Agent;\n  threadId: string;\n  resourceId: string;\n  title: string;\n}\n\n/**\n * Rename a single thread, returning the updated wire thread.\n *\n * Ownership is enforced the same way {@link deleteThread} enforces it:\n * the title is only changed when the thread belongs to the calling\n * resource, so a client can't rename another user's conversation by\n * guessing its id. Existing thread `metadata` is preserved untouched\n * (Mastra's `updateThread` replaces the row, so it must be passed back\n * in). Returns `null` when the thread doesn't exist, isn't owned by the\n * caller, or the agent has no memory configured, letting the route map\n * that to a 404.\n */\nexport async function renameThread(opts: RenameThreadOptions): Promise<MastraThread | null> {\n  const memory = await opts.agent.getMemory();\n  if (!memory) {\n    logger.debug(\"rename:no-memory\", { agentId: opts.agent.id });\n    return null;\n  }\n  const existing = await memory.getThreadById({ threadId: opts.threadId });\n  if (!existing || existing.resourceId !== opts.resourceId) {\n    logger.debug(\"rename:not-owned\", {\n      agentId: opts.agent.id,\n      threadId: opts.threadId,\n      found: existing !== null,\n    });\n    return null;\n  }\n  const startedAt = Date.now();\n  const updated = await memory.updateThread({\n    id: opts.threadId,\n    title: opts.title,\n    metadata: existing.metadata ?? {},\n  });\n  logger.info(\"rename:done\", {\n    agentId: opts.agent.id,\n    threadId: opts.threadId,\n    elapsedMs: Date.now() - startedAt,\n  });\n  return toWireThread(updated);\n}\n\n/** Options accepted by {@link threadsRoute}. */\nexport type ThreadsRouteOptions =\n  { path: `${string}:agentId${string}`; agent?: never } | { path: string; agent: string };\n\n/**\n * Register the `<path>` Mastra custom API route. Handles three methods\n * on the same mount:\n *\n *   - `GET`: a page of the resource's conversation threads\n *     ({@link listThreads}).\n *   - `DELETE`: remove the thread named by the thread-selection header\n *     / `?threadId=` query ({@link deleteThread}). The id is read from\n *     `RequestContext` (the auth middleware resolves it the same way it\n *     does for streaming and history), so the client deletes any of its\n *     threads by stamping the target id - no separate path param.\n *   - `PATCH`: rename the thread named by the thread-selection header /\n *     `?threadId=` query to the `{ title }` in the JSON body\n *     ({@link renameThread}). Targets a thread the same way `DELETE`\n *     does; 404s when the thread isn't owned by the caller.\n *\n * Follows the `@mastra/ai-sdk` agent-binding convention: pass `agent`\n * for a fixed-agent mount, or include `:agentId` in the path for\n * dynamic routing. The plugin registers both `/route/threads` (default\n * agent) and `/route/threads/:agentId`.\n */\nexport function threadsRoute(options: ThreadsRouteOptions) {\n  const { path } = options;\n  const fixedAgent = \"agent\" in options ? options.agent : undefined;\n  if (!fixedAgent && !path.includes(\":agentId\")) {\n    throw ValidationError.invalidValue(\n      \"threadsRoute.path\",\n      path,\n      \"a path containing `:agentId`, or an explicit `agent`\",\n    );\n  }\n  // Shared by GET / DELETE: resolve the active agent and the caller's\n  // resource id, returning a JSON error response when either is\n  // missing. Keeps both handlers thin with identical validation.\n  const resolveContext = (c: ContextWithMastra) => {\n    const mastra = c.get(\"mastra\");\n    const requestContext = c.get(\"requestContext\");\n    const agentId = fixedAgent ?? c.req.param(\"agentId\");\n    if (!agentId) {\n      return { error: c.json({ error: \"agentId is required\" }, 400) } as const;\n    }\n    const agent = mastra.getAgentById(agentId);\n    if (!agent) {\n      return {\n        error: c.json({ error: `Unknown agent \"${agentId}\"` }, 404),\n      } as const;\n    }\n    const resourceId = requestContext.get(MASTRA_RESOURCE_ID_KEY) as string | undefined;\n    if (!resourceId) {\n      return {\n        error: c.json({ error: \"resource id missing from request context\" }, 400),\n      } as const;\n    }\n    return { agentId, agent, requestContext, resourceId } as const;\n  };\n\n  return [\n    registerApiRoute(path, {\n      method: \"GET\",\n      handler: async (c: ContextWithMastra) => {\n        const ctx = resolveContext(c);\n        if (\"error\" in ctx) return ctx.error;\n        const payload = await listThreads({\n          agent: ctx.agent,\n          resourceId: ctx.resourceId,\n          page: parseIntParam(c.req.query(\"page\")),\n          perPage: parseIntParam(c.req.query(\"perPage\")),\n        });\n        return c.json(payload);\n      },\n    }),\n    registerApiRoute(path, {\n      method: \"DELETE\",\n      handler: async (c: ContextWithMastra) => {\n        const ctx = resolveContext(c);\n        if (\"error\" in ctx) return ctx.error;\n        const threadId = ctx.requestContext.get(MASTRA_THREAD_ID_KEY) as string | undefined;\n        if (!threadId) {\n          return c.json({ error: \"thread id missing from request context\" }, 400);\n        }\n        const { deleted } = await deleteThread({\n          agent: ctx.agent,\n          threadId,\n          resourceId: ctx.resourceId,\n        });\n        const payload: MastraDeleteThreadResponse = {\n          ok: true,\n          agentId: ctx.agentId,\n          threadId,\n          deleted,\n        };\n        return c.json(payload);\n      },\n    }),\n    registerApiRoute(path, {\n      method: \"PATCH\",\n      handler: async (c: ContextWithMastra) => {\n        const ctx = resolveContext(c);\n        if (\"error\" in ctx) return ctx.error;\n        const threadId = ctx.requestContext.get(MASTRA_THREAD_ID_KEY) as string | undefined;\n        if (!threadId) {\n          return c.json({ error: \"thread id missing from request context\" }, 400);\n        }\n        const body = wire.MastraUpdateThreadRequestSchema.safeParse(await c.req.json());\n        if (!body.success) {\n          logger.warn(\"rename:invalid\", { error: body.error.message });\n          return c.json({ error: INVALID_RENAME_MESSAGE, fields: invalidFields(body.error) }, 400);\n        }\n        const thread = await renameThread({\n          agent: ctx.agent,\n          threadId,\n          resourceId: ctx.resourceId,\n          title: body.data.title,\n        });\n        if (!thread) {\n          return c.json({ error: `Unknown thread \"${threadId}\"` }, 404);\n        }\n        const payload: MastraUpdateThreadResponse = {\n          ok: true,\n          agentId: ctx.agentId,\n          thread,\n        };\n        return c.json(payload);\n      },\n    }),\n  ];\n}\n\n/** Coerce a Mastra `StorageThreadType` into the JSON-safe wire shape. */\nfunction toWireThread(thread: StorageThreadType): MastraThread {\n  return {\n    id: thread.id,\n    ...(thread.title ? { title: thread.title } : {}),\n    resourceId: thread.resourceId,\n    createdAt: toIso(thread.createdAt),\n    updatedAt: toIso(thread.updatedAt),\n    ...(thread.metadata ? { metadata: thread.metadata } : {}),\n  };\n}\n\n/** Render a storage timestamp as an ISO-8601 string for the wire. */\nfunction toIso(value: Date | string | number): string {\n  if (value instanceof Date) return value.toISOString();\n  const parsed = new Date(value);\n  return Number.isNaN(parsed.getTime()) ? new Date(0).toISOString() : parsed.toISOString();\n}\n"]}

package/lib/src/validation.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Request-body validation helpers shared by every route that parses a JSON
+ * body with a schema from `@dbx-tools/shared-mastra`.
+ *
+ * A schema library's own issue text quotes the received body back, so it is
+ * logged rather than returned. What a client gets instead is a stable message
+ * plus the field paths that failed, which is enough to highlight the offending
+ * inputs.
+ *
+ * @module
+ */
+/** The subset of a failed parse result these helpers read. */
+export interface SchemaIssues {
+    issues: ReadonlyArray<{
+        path: PropertyKey[];
+    }>;
+}
+/** Distinct dot-joined field paths a failed parse flagged. */
+export declare function invalidFields(error: SchemaIssues): string[];

package/lib/src/validation.js

@@ -0,0 +1,17 @@
+/**
+ * Request-body validation helpers shared by every route that parses a JSON
+ * body with a schema from `@dbx-tools/shared-mastra`.
+ *
+ * A schema library's own issue text quotes the received body back, so it is
+ * logged rather than returned. What a client gets instead is a stable message
+ * plus the field paths that failed, which is enough to highlight the offending
+ * inputs.
+ *
+ * @module
+ */
+/** Distinct dot-joined field paths a failed parse flagged. */
+export function invalidFields(error) {
+    const fields = error.issues.map((issue) => issue.path.map(String).join(".")).filter(Boolean);
+    return [...new Set(fields)];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92YWxpZGF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7O0dBVUc7QUFPSCw4REFBOEQ7QUFDOUQsTUFBTSxVQUFVLGFBQWEsQ0FBQyxLQUFtQjtJQUMvQyxNQUFNLE1BQU0sR0FBRyxLQUFLLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQzdGLE9BQU8sQ0FBQyxHQUFHLElBQUksR0FBRyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7QUFDOUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogUmVxdWVzdC1ib2R5IHZhbGlkYXRpb24gaGVscGVycyBzaGFyZWQgYnkgZXZlcnkgcm91dGUgdGhhdCBwYXJzZXMgYSBKU09OXG4gKiBib2R5IHdpdGggYSBzY2hlbWEgZnJvbSBgQGRieC10b29scy9zaGFyZWQtbWFzdHJhYC5cbiAqXG4gKiBBIHNjaGVtYSBsaWJyYXJ5J3Mgb3duIGlzc3VlIHRleHQgcXVvdGVzIHRoZSByZWNlaXZlZCBib2R5IGJhY2ssIHNvIGl0IGlzXG4gKiBsb2dnZWQgcmF0aGVyIHRoYW4gcmV0dXJuZWQuIFdoYXQgYSBjbGllbnQgZ2V0cyBpbnN0ZWFkIGlzIGEgc3RhYmxlIG1lc3NhZ2VcbiAqIHBsdXMgdGhlIGZpZWxkIHBhdGhzIHRoYXQgZmFpbGVkLCB3aGljaCBpcyBlbm91Z2ggdG8gaGlnaGxpZ2h0IHRoZSBvZmZlbmRpbmdcbiAqIGlucHV0cy5cbiAqXG4gKiBAbW9kdWxlXG4gKi9cblxuLyoqIFRoZSBzdWJzZXQgb2YgYSBmYWlsZWQgcGFyc2UgcmVzdWx0IHRoZXNlIGhlbHBlcnMgcmVhZC4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2NoZW1hSXNzdWVzIHtcbiAgaXNzdWVzOiBSZWFkb25seUFycmF5PHsgcGF0aDogUHJvcGVydHlLZXlbXSB9Pjtcbn1cblxuLyoqIERpc3RpbmN0IGRvdC1qb2luZWQgZmllbGQgcGF0aHMgYSBmYWlsZWQgcGFyc2UgZmxhZ2dlZC4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpbnZhbGlkRmllbGRzKGVycm9yOiBTY2hlbWFJc3N1ZXMpOiBzdHJpbmdbXSB7XG4gIGNvbnN0IGZpZWxkcyA9IGVycm9yLmlzc3Vlcy5tYXAoKGlzc3VlKSA9PiBpc3N1ZS5wYXRoLm1hcChTdHJpbmcpLmpvaW4oXCIuXCIpKS5maWx0ZXIoQm9vbGVhbik7XG4gIHJldHVybiBbLi4ubmV3IFNldChmaWVsZHMpXTtcbn1cbiJdfQ==

package/lib/src/workspaces.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Mastra workspace factory for Databricks Apps.
+ *
+ * Builds a per-request {@link Workspace} whose filesystem is a
+ * {@link CompositeFilesystem} over Databricks paths resolved from the
+ * OBO client on {@link MASTRA_USER_KEY}. Optional mount resolver
+ * contributions merge extra filesystems and skill scan roots; built-in
+ * Assistant skill trees are toggled with `assistantSkills` (on by default).
+ *
+ * @module
+ */
+import type { RequestContext } from "@mastra/core/request-context";
+import { Workspace, type SkillsResolver, type WorkspaceFilesystem } from "@mastra/core/workspace";
+/** Per-request context for mount resolvers. */
+interface WorkspaceMountContext {
+    requestContext?: RequestContext;
+}
+/** Mount map plus optional Mastra skill scan roots for one resolver. */
+interface WorkspaceMountContribution {
+    mounts: Record<string, WorkspaceFilesystem>;
+    /** Paths within the composite namespace where `SKILL.md` files are scanned. */
+    skillPaths?: string[];
+}
+/** Contributes filesystem mounts (and optional skill paths) for one request. */
+type WorkspaceMountResolver = (context: WorkspaceMountContext) => WorkspaceMountContribution | Promise<WorkspaceMountContribution>;
+/** Options for {@link createWorkspace}. */
+export interface CreateWorkspaceOptions {
+    /** Workspace id; derived from `name` or `"workspace"` when omitted. */
+    id?: string;
+    /** Display name; derived from `id` when omitted. */
+    name?: string;
+    /**
+     * Mount read-only Assistant skill trees from `/Workspace/.assistant/skills`
+     * and `/Users/<email>/.assistant/skills`. Defaults to `true`.
+     */
+    assistantSkills?: boolean;
+    /** Extra per-request mount resolvers (run after built-in options). */
+    mounts?: WorkspaceMountResolver[];
+    /** Replace the auto-built dynamic skills resolver. */
+    skills?: SkillsResolver;
+    /** Forwarded to Mastra when skill discovery is enabled. */
+    checkSkillFileMtime?: boolean;
+    /** Enable BM25 keyword search over indexed workspace content. */
+    bm25?: boolean;
+}
+/**
+ * Create a Mastra {@link Workspace} with per-request Databricks mounts.
+ *
+ * @example Assistant skills only (default for agents in this plugin)
+ * ```ts
+ * createWorkspace()
+ * ```
+ *
+ * @example Assistant skills plus a custom mount resolver
+ * ```ts
+ * createWorkspace({
+ *   assistantSkills: true,
+ *   mounts: [
+ *     async ({ requestContext }) => ({
+ *       mounts: { "/data": myFilesystem },
+ *       skillPaths: [],
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+export declare function createWorkspace(options?: CreateWorkspaceOptions): Workspace;
+export {};