@mastra/server 1.46.0-alpha.2 → 1.46.0-alpha.4

package/dist/chunk-I6AIWII6.cjs

@@ -0,0 +1,1138 @@
+'use strict';
+
+var chunkZ7LCIYK7_cjs = require('./chunk-Z7LCIYK7.cjs');
+var chunkG54X6VE6_cjs = require('./chunk-G54X6VE6.cjs');
+var chunk64ITUOXI_cjs = require('./chunk-64ITUOXI.cjs');
+var v4 = require('zod/v4');
+
+function getHarnessOrThrow(mastra, harnessId) {
+  const harness = mastra.getHarness(harnessId);
+  if (!harness) {
+    throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `harness "${harnessId}" not found` });
+  }
+  return harness;
+}
+async function getSession(harness, resourceId) {
+  await harness.init();
+  return harness.createSession({ resourceId });
+}
+var harnessIdPathParams = v4.z.object({ harnessId: v4.z.string() });
+var sessionPathParams = v4.z.object({ harnessId: v4.z.string(), resourceId: v4.z.string() });
+var createSessionBodySchema = v4.z.object({ resourceId: v4.z.string() });
+var sendMessageBodySchema = v4.z.object({ message: v4.z.string() });
+var steerBodySchema = v4.z.object({ message: v4.z.string() });
+var toolApprovalBodySchema = v4.z.object({
+  toolCallId: v4.z.string(),
+  approved: v4.z.boolean()
+});
+var toolSuspensionBodySchema = v4.z.object({
+  toolCallId: v4.z.string(),
+  // Free-form resume payload. For ask_user this is a string (or string[] for
+  // multi-select); for submit_plan it's `{ action, feedback? }`; for
+  // request_access it's "Yes"/"No".
+  resumeData: v4.z.any()
+});
+var switchModeBodySchema = v4.z.object({ modeId: v4.z.string() });
+var switchModelBodySchema = v4.z.object({
+  modelId: v4.z.string(),
+  scope: v4.z.enum(["global", "thread"]).optional(),
+  modeId: v4.z.string().optional()
+});
+var switchThreadBodySchema = v4.z.object({ threadId: v4.z.string() });
+var createThreadBodySchema = v4.z.object({ title: v4.z.string().optional() });
+var renameThreadBodySchema = v4.z.object({ title: v4.z.string() });
+var threadPathParams = v4.z.object({ harnessId: v4.z.string(), resourceId: v4.z.string(), threadId: v4.z.string() });
+var cloneThreadBodySchema = v4.z.object({
+  sourceThreadId: v4.z.string().optional(),
+  title: v4.z.string().optional()
+});
+var listMessagesQuerySchema = v4.z.object({ limit: v4.z.coerce.number().optional() });
+var listThreadsQuerySchema = v4.z.object({ limit: v4.z.coerce.number().optional() });
+var followUpBodySchema = v4.z.object({ message: v4.z.string() });
+var sendNotificationBodySchema = v4.z.object({
+  source: v4.z.string(),
+  kind: v4.z.string(),
+  summary: v4.z.string(),
+  priority: v4.z.enum(["low", "medium", "high", "urgent"]).optional(),
+  payload: v4.z.any().optional(),
+  sourceId: v4.z.string().optional(),
+  dedupeKey: v4.z.string().optional(),
+  coalesceKey: v4.z.string().optional(),
+  attributes: v4.z.record(v4.z.string(), v4.z.unknown()).optional(),
+  metadata: v4.z.record(v4.z.string(), v4.z.unknown()).optional()
+});
+var listHarnessesResponseSchema = v4.z.object({
+  harnesses: v4.z.array(v4.z.object({ id: v4.z.string() }))
+});
+var createSessionResponseSchema = v4.z.object({
+  harnessId: v4.z.string(),
+  resourceId: v4.z.string(),
+  threadId: v4.z.string().optional()
+});
+var ackResponseSchema = v4.z.object({ ok: v4.z.boolean() });
+var sessionStateResponseSchema = v4.z.object({
+  harnessId: v4.z.string(),
+  resourceId: v4.z.string(),
+  threadId: v4.z.string().optional(),
+  modeId: v4.z.string(),
+  modelId: v4.z.string()
+});
+var listModesResponseSchema = v4.z.object({
+  modes: v4.z.array(v4.z.object({ id: v4.z.string(), name: v4.z.string().optional() }))
+});
+var listThreadsResponseSchema = v4.z.object({
+  threads: v4.z.array(
+    v4.z.object({
+      id: v4.z.string(),
+      title: v4.z.string().optional(),
+      updatedAt: v4.z.string().optional()
+    })
+  )
+});
+var threadResponseSchema = v4.z.object({
+  id: v4.z.string(),
+  title: v4.z.string().optional(),
+  resourceId: v4.z.string().optional(),
+  createdAt: v4.z.string().optional(),
+  updatedAt: v4.z.string().optional()
+});
+var messageContentSchema = v4.z.object({
+  type: v4.z.string()
+}).passthrough();
+var listMessagesResponseSchema = v4.z.object({
+  messages: v4.z.array(
+    v4.z.object({
+      id: v4.z.string(),
+      role: v4.z.enum(["user", "assistant", "system"]),
+      content: v4.z.array(messageContentSchema),
+      createdAt: v4.z.string().optional()
+    })
+  )
+});
+var listModelsResponseSchema = v4.z.object({
+  models: v4.z.array(
+    v4.z.object({
+      id: v4.z.string(),
+      provider: v4.z.string(),
+      modelName: v4.z.string(),
+      hasApiKey: v4.z.boolean(),
+      useCount: v4.z.number()
+    })
+  )
+});
+var workspaceStatusResponseSchema = v4.z.object({
+  hasWorkspace: v4.z.boolean(),
+  isReady: v4.z.boolean()
+});
+var omRecordResponseSchema = v4.z.object({
+  record: v4.z.any().optional()
+});
+var permissionPolicyEnum = v4.z.enum(["allow", "ask", "deny"]);
+var toolCategoryEnum = v4.z.enum(["read", "edit", "execute", "mcp", "other"]);
+var permissionRulesResponseSchema = v4.z.object({
+  categories: v4.z.record(v4.z.string(), permissionPolicyEnum).optional(),
+  tools: v4.z.record(v4.z.string(), permissionPolicyEnum).optional()
+});
+var setCategoryPermissionBodySchema = v4.z.object({
+  category: toolCategoryEnum,
+  policy: permissionPolicyEnum
+});
+var setToolPermissionBodySchema = v4.z.object({
+  toolName: v4.z.string(),
+  policy: permissionPolicyEnum
+});
+var LIST_HARNESSES_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "GET",
+  path: "/harness",
+  responseType: "json",
+  responseSchema: listHarnessesResponseSchema,
+  summary: "List harnesses",
+  description: "Lists the harnesses hosted on this Mastra instance.",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:read",
+  handler: async ({ mastra }) => {
+    try {
+      const harnesses = mastra.listHarnesses();
+      return { harnesses: Object.keys(harnesses).map((id) => ({ id })) };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error listing harnesses");
+    }
+  }
+});
+var CREATE_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions",
+  responseType: "json",
+  pathParamSchema: harnessIdPathParams,
+  bodySchema: createSessionBodySchema,
+  responseSchema: createSessionResponseSchema,
+  summary: "Create or resume a harness session",
+  description: "Creates a session for the given resourceId, or returns the existing one (get-or-create), so reconnects resume the conversation.",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      return {
+        harnessId,
+        resourceId,
+        threadId: session.thread.getId() ?? void 0
+      };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error creating harness session");
+    }
+  }
+});
+var STREAM_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "GET",
+  path: "/harness/:harnessId/sessions/:resourceId/stream",
+  responseType: "stream",
+  streamFormat: "sse",
+  sseFlushOnConnect: true,
+  pathParamSchema: sessionPathParams,
+  summary: "Stream harness session events",
+  description: "Subscribes to a session\u2019s event bus and streams events to the client over SSE.",
+  tags: ["Harness", "Streaming"],
+  requiresAuth: true,
+  requiresPermission: "harness:read",
+  handler: async ({ mastra, harnessId, resourceId, abortSignal }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      let cleanedUp = false;
+      let heartbeat;
+      let unsubscribe;
+      const clearHeartbeat = () => {
+        if (heartbeat) {
+          clearTimeout(heartbeat);
+          heartbeat = void 0;
+        }
+      };
+      const cleanup = (controller) => {
+        if (cleanedUp) return;
+        cleanedUp = true;
+        clearHeartbeat();
+        unsubscribe?.();
+        if (controller) {
+          try {
+            controller.close();
+          } catch {
+          }
+        }
+      };
+      return new ReadableStream({
+        start(controller) {
+          const scheduleHeartbeat = () => {
+            if (cleanedUp) return;
+            clearHeartbeat();
+            heartbeat = setTimeout(() => {
+              heartbeat = void 0;
+              if (cleanedUp) return;
+              try {
+                controller.enqueue(": heartbeat\n\n");
+              } catch {
+                cleanup();
+                return;
+              }
+              scheduleHeartbeat();
+            }, 25e3);
+          };
+          unsubscribe = session.subscribe((event) => {
+            if (cleanedUp) return;
+            try {
+              controller.enqueue(`data: ${JSON.stringify(event)}
+
+`);
+              scheduleHeartbeat();
+            } catch {
+              cleanup();
+            }
+          });
+          const abortCleanup = () => cleanup(controller);
+          abortSignal?.addEventListener("abort", abortCleanup, { once: true });
+          scheduleHeartbeat();
+        },
+        cancel() {
+          cleanup();
+        }
+      });
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error streaming harness session");
+    }
+  }
+});
+var SEND_HARNESS_MESSAGE_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/messages",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: sendMessageBodySchema,
+  responseSchema: ackResponseSchema,
+  summary: "Send a message to a harness session",
+  description: "Sends a user message to the session. The reply streams as events on the session\u2019s SSE stream.",
+  tags: ["Harness", "Streaming"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, message }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      void session.sendMessage({ content: message });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error sending harness message");
+    }
+  }
+});
+var ABORT_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/abort",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  responseSchema: ackResponseSchema,
+  summary: "Abort a harness session run",
+  description: "Aborts the in-flight run for the session, if any.",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      session.abort();
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error aborting harness session");
+    }
+  }
+});
+var HARNESS_TOOL_APPROVAL_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/tool-approval",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: toolApprovalBodySchema,
+  responseSchema: ackResponseSchema,
+  summary: "Respond to a harness tool approval",
+  description: "Approves or declines a pending tool call surfaced by the session.",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, toolCallId, approved }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      session.respondToToolApproval({ toolCallId, decision: approved ? "approve" : "decline" });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error responding to harness tool approval");
+    }
+  }
+});
+var HARNESS_TOOL_SUSPENSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/tool-suspension",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: toolSuspensionBodySchema,
+  responseSchema: ackResponseSchema,
+  summary: "Respond to a suspended harness tool",
+  description: "Resumes a suspended interactive tool (ask_user, request_access, submit_plan) with the provided resume data.",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, toolCallId, resumeData }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      await session.respondToToolSuspension({ toolCallId, resumeData });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error responding to harness tool suspension");
+    }
+  }
+});
+var STEER_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/steer",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: steerBodySchema,
+  responseSchema: ackResponseSchema,
+  summary: "Steer the in-flight run",
+  description: "Injects a message into the running turn (interjection) without starting a new run.",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, message }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      void session.steer({ content: message });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error steering harness session");
+    }
+  }
+});
+var SWITCH_HARNESS_MODE_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/mode",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: switchModeBodySchema,
+  responseSchema: ackResponseSchema,
+  summary: "Switch the session mode",
+  description: "Switches the active mode (e.g. build, plan) for the session.",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, modeId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      await session.mode.switch({ modeId });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error switching harness mode");
+    }
+  }
+});
+var SWITCH_HARNESS_MODEL_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/model",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: switchModelBodySchema,
+  responseSchema: ackResponseSchema,
+  summary: "Switch the session model",
+  description: "Switches the model for the session, scoped to the thread by default.",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, modelId, scope, modeId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      await session.model.switch({ modelId, scope, modeId });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error switching harness model");
+    }
+  }
+});
+var SWITCH_HARNESS_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/thread",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: switchThreadBodySchema,
+  responseSchema: ackResponseSchema,
+  summary: "Switch the session thread",
+  description: "Switches the session to an existing thread (rebinding its stream and state).",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, threadId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      await session.thread.switch({ threadId });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error switching harness thread");
+    }
+  }
+});
+var GET_HARNESS_SESSION_STATE_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "GET",
+  path: "/harness/:harnessId/sessions/:resourceId",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  responseSchema: sessionStateResponseSchema,
+  summary: "Get session state",
+  description: "Returns the current mode, model, and thread for the session (for initial UI hydration).",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:read",
+  handler: async ({ mastra, harnessId, resourceId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      return {
+        harnessId,
+        resourceId,
+        threadId: session.thread.getId() ?? void 0,
+        modeId: session.mode.get(),
+        modelId: session.model.get()
+      };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error reading harness session state");
+    }
+  }
+});
+var LIST_HARNESS_MODES_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "GET",
+  path: "/harness/:harnessId/modes",
+  responseType: "json",
+  pathParamSchema: harnessIdPathParams,
+  responseSchema: listModesResponseSchema,
+  summary: "List harness modes",
+  description: "Lists the modes configured on the harness (e.g. build, plan).",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:read",
+  handler: async ({ mastra, harnessId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      return {
+        modes: harness.listModes().map((mode) => ({ id: mode.id, name: mode.name }))
+      };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error listing harness modes");
+    }
+  }
+});
+var LIST_HARNESS_THREADS_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "GET",
+  path: "/harness/:harnessId/sessions/:resourceId/threads",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  queryParamSchema: listThreadsQuerySchema,
+  responseSchema: listThreadsResponseSchema,
+  summary: "List session threads",
+  description: "Lists the threads for the session\u2019s resource, most-recently-updated first. Pass `limit` to return only the newest N (e.g. for a sidebar).",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:read",
+  handler: async ({ mastra, harnessId, resourceId, limit }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      const threads = await session.thread.list();
+      const toTime = (t) => (t.updatedAt ?? t.createdAt)?.getTime() ?? 0;
+      const sorted = [...threads].sort((a, b) => toTime(b) - toTime(a));
+      const max = Number(limit);
+      const limited = Number.isFinite(max) && max > 0 ? sorted.slice(0, max) : sorted;
+      return {
+        threads: limited.map((t) => ({
+          id: t.id,
+          title: t.title,
+          updatedAt: t.updatedAt instanceof Date ? t.updatedAt.toISOString() : void 0
+        }))
+      };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error listing harness threads");
+    }
+  }
+});
+var SEND_HARNESS_NOTIFICATION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/notifications",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: sendNotificationBodySchema,
+  responseSchema: v4.z.object({
+    accepted: v4.z.boolean(),
+    notificationId: v4.z.string().optional(),
+    decision: v4.z.string().optional(),
+    runId: v4.z.string().optional()
+  }),
+  summary: "Send a notification signal to a session",
+  description: "Delivers a notification to the session\u2019s current agent/thread. The agent\u2019s delivery policy determines whether the notification wakes an idle thread, is summarised, or is persisted for later.",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({
+    mastra,
+    harnessId,
+    resourceId,
+    source,
+    kind,
+    summary,
+    priority,
+    payload,
+    sourceId,
+    dedupeKey,
+    coalesceKey,
+    attributes,
+    metadata
+  }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      const result = await session.sendNotificationSignal({
+        source,
+        kind,
+        summary,
+        priority,
+        payload,
+        sourceId,
+        dedupeKey,
+        coalesceKey,
+        attributes,
+        metadata
+      });
+      return {
+        accepted: result.accepted !== void 0,
+        notificationId: result.record?.id,
+        decision: result.decision?.action,
+        runId: result.runId
+      };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error sending harness notification");
+    }
+  }
+});
+var CREATE_HARNESS_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/threads",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: createThreadBodySchema,
+  responseSchema: threadResponseSchema,
+  summary: "Create a new thread",
+  description: "Creates a new thread in the session (unbinds the previous thread, binds the new one).",
+  tags: ["Harness", "Threads"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, title }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      const thread = await session.thread.create({ title });
+      return {
+        id: thread.id,
+        title: thread.title,
+        resourceId: thread.resourceId,
+        createdAt: thread.createdAt instanceof Date ? thread.createdAt.toISOString() : void 0,
+        updatedAt: thread.updatedAt instanceof Date ? thread.updatedAt.toISOString() : void 0
+      };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error creating harness thread");
+    }
+  }
+});
+var DELETE_HARNESS_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "DELETE",
+  path: "/harness/:harnessId/sessions/:resourceId/threads/:threadId",
+  responseType: "json",
+  pathParamSchema: threadPathParams,
+  responseSchema: ackResponseSchema,
+  summary: "Delete a thread",
+  description: "Deletes a thread. If the deleted thread is the active one, the session is unbound.",
+  tags: ["Harness", "Threads"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, threadId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      await session.thread.delete({ threadId });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error deleting harness thread");
+    }
+  }
+});
+var RENAME_HARNESS_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "PUT",
+  path: "/harness/:harnessId/sessions/:resourceId/threads/:threadId",
+  responseType: "json",
+  pathParamSchema: threadPathParams,
+  bodySchema: renameThreadBodySchema,
+  responseSchema: ackResponseSchema,
+  summary: "Rename a thread",
+  description: "Renames the specified thread.",
+  tags: ["Harness", "Threads"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, threadId, title }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      if (session.thread.getId() !== threadId) {
+        await session.thread.switch({ threadId });
+      }
+      await session.thread.rename({ title });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error renaming harness thread");
+    }
+  }
+});
+var CLONE_HARNESS_THREAD_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/threads/clone",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: cloneThreadBodySchema,
+  responseSchema: threadResponseSchema,
+  summary: "Clone a thread",
+  description: "Clones a thread (and its messages). The session binds to the new clone.",
+  tags: ["Harness", "Threads"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, sourceThreadId, title }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      const thread = await session.thread.clone({ sourceThreadId, title });
+      return {
+        id: thread.id,
+        title: thread.title,
+        resourceId: thread.resourceId,
+        createdAt: thread.createdAt instanceof Date ? thread.createdAt.toISOString() : void 0,
+        updatedAt: thread.updatedAt instanceof Date ? thread.updatedAt.toISOString() : void 0
+      };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error cloning harness thread");
+    }
+  }
+});
+var LIST_HARNESS_THREAD_MESSAGES_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "GET",
+  path: "/harness/:harnessId/sessions/:resourceId/threads/:threadId/messages",
+  responseType: "json",
+  pathParamSchema: threadPathParams,
+  queryParamSchema: listMessagesQuerySchema,
+  responseSchema: listMessagesResponseSchema,
+  summary: "List thread messages",
+  description: "Lists messages for a specific thread. Returns most recent messages first.",
+  tags: ["Harness", "Threads"],
+  requiresAuth: true,
+  requiresPermission: "harness:read",
+  handler: async ({ mastra, harnessId, resourceId, threadId, limit }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      const messages = await session.thread.listMessages({ threadId, limit });
+      return {
+        messages: messages.map((m) => ({
+          id: m.id,
+          role: m.role,
+          content: m.content,
+          createdAt: m.createdAt instanceof Date ? m.createdAt.toISOString() : void 0
+        }))
+      };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error listing harness thread messages");
+    }
+  }
+});
+var FOLLOW_UP_HARNESS_SESSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/follow-up",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: followUpBodySchema,
+  responseSchema: ackResponseSchema,
+  summary: "Queue a follow-up message",
+  description: "Queues a follow-up message. If the session is idle it sends immediately; if a run is active it queues for after completion.",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, message }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      void session.followUp({ content: message });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error queuing harness follow-up");
+    }
+  }
+});
+var LIST_HARNESS_MODELS_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "GET",
+  path: "/harness/:harnessId/models",
+  responseType: "json",
+  pathParamSchema: harnessIdPathParams,
+  responseSchema: listModelsResponseSchema,
+  summary: "List available models",
+  description: "Lists all models available on this harness (with auth status and use counts).",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:read",
+  handler: async ({ mastra, harnessId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      await harness.init();
+      const models = await harness.listAvailableModels();
+      return {
+        models: models.map((m) => ({
+          id: m.id,
+          provider: m.provider,
+          modelName: m.modelName,
+          hasApiKey: m.hasApiKey,
+          useCount: m.useCount
+        }))
+      };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error listing harness models");
+    }
+  }
+});
+var GET_HARNESS_WORKSPACE_STATUS_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "GET",
+  path: "/harness/:harnessId/workspace",
+  responseType: "json",
+  pathParamSchema: harnessIdPathParams,
+  responseSchema: workspaceStatusResponseSchema,
+  summary: "Get workspace status",
+  description: "Returns whether the harness has a workspace configured and whether it is ready.",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:read",
+  handler: async ({ mastra, harnessId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      await harness.init();
+      return {
+        hasWorkspace: harness.hasWorkspace(),
+        isReady: harness.isWorkspaceReady()
+      };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error reading harness workspace status");
+    }
+  }
+});
+var GET_HARNESS_OM_RECORD_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "GET",
+  path: "/harness/:harnessId/sessions/:resourceId/om",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  responseSchema: omRecordResponseSchema,
+  summary: "Get observational memory record",
+  description: "Returns the current observational memory record for the session\u2019s thread/resource.",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:read",
+  handler: async ({ mastra, harnessId, resourceId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      const record = await harness.getObservationalMemoryRecord(session);
+      return { record: record ?? void 0 };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error reading harness OM record");
+    }
+  }
+});
+var SET_HARNESS_RESOURCE_ID_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/resource",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: v4.z.object({ newResourceId: v4.z.string() }),
+  responseSchema: ackResponseSchema,
+  summary: "Change the session resource ID",
+  description: "Updates the session\u2019s resource identity (e.g. when a user logs in).",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, newResourceId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      await harness.setResourceId(session, { resourceId: newResourceId });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error setting harness resource ID");
+    }
+  }
+});
+var GET_HARNESS_RESOURCE_IDS_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "GET",
+  path: "/harness/:harnessId/sessions/:resourceId/resources",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  responseSchema: v4.z.object({ resourceIds: v4.z.array(v4.z.string()) }),
+  summary: "Get known resource IDs",
+  description: "Lists the resource IDs known to this session (from threads).",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:read",
+  handler: async ({ mastra, harnessId, resourceId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      const resourceIds = await harness.getKnownResourceIds(session);
+      return { resourceIds };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error listing harness resource IDs");
+    }
+  }
+});
+var setGoalBodySchema = v4.z.object({
+  objective: v4.z.string(),
+  judgeModelId: v4.z.string().optional(),
+  maxRuns: v4.z.number().optional()
+});
+var updateGoalBodySchema = v4.z.object({
+  judgeModelId: v4.z.string().optional(),
+  maxRuns: v4.z.number().optional(),
+  status: v4.z.enum(["active", "paused", "done"]).optional()
+});
+var goalRecordSchema = v4.z.object({
+  id: v4.z.string().optional(),
+  objective: v4.z.string(),
+  status: v4.z.enum(["active", "paused", "done"]),
+  runsUsed: v4.z.number(),
+  maxRuns: v4.z.number().optional(),
+  judgeModelId: v4.z.string().optional(),
+  startedAt: v4.z.number(),
+  updatedAt: v4.z.number(),
+  pausedReason: v4.z.string().optional()
+});
+var goalResponseSchema = v4.z.object({ goal: goalRecordSchema.optional() });
+function getAgentForSession(harness, session) {
+  return harness.getCurrentAgent(session);
+}
+var GET_HARNESS_GOAL_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "GET",
+  path: "/harness/:harnessId/sessions/:resourceId/goal",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  responseSchema: goalResponseSchema,
+  summary: "Get the current goal",
+  description: "Returns the active/paused/done goal objective for the session\u2019s thread, if any.",
+  tags: ["Harness", "Goals"],
+  requiresAuth: true,
+  requiresPermission: "harness:read",
+  handler: async ({ mastra, harnessId, resourceId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      const threadId = session.thread.getId();
+      if (!threadId) return { goal: void 0 };
+      const agent = getAgentForSession(harness, session);
+      const record = await agent.getObjective({ threadId });
+      return { goal: record ?? void 0 };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error reading harness goal");
+    }
+  }
+});
+var SET_HARNESS_GOAL_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "POST",
+  path: "/harness/:harnessId/sessions/:resourceId/goal",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: setGoalBodySchema,
+  responseSchema: goalResponseSchema,
+  summary: "Set a goal",
+  description: "Sets a new objective for the session\u2019s thread. The agent\u2019s in-loop goal judge evaluates progress after each turn.",
+  tags: ["Harness", "Goals"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, objective, judgeModelId, maxRuns }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      const threadId = session.thread.getId();
+      if (!threadId) throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "session has no active thread" });
+      const agent = getAgentForSession(harness, session);
+      const record = await agent.setObjective(objective, {
+        threadId,
+        resourceId: session.identity.getResourceId(),
+        ...judgeModelId ? { judgeModelId } : {},
+        ...maxRuns != null ? { maxRuns } : {}
+      });
+      return { goal: record ?? void 0 };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error setting harness goal");
+    }
+  }
+});
+var UPDATE_HARNESS_GOAL_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "PUT",
+  path: "/harness/:harnessId/sessions/:resourceId/goal",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: updateGoalBodySchema,
+  responseSchema: goalResponseSchema,
+  summary: "Update goal options",
+  description: "Updates the judge model, max runs, or status of the active goal. No-op when no goal is set.",
+  tags: ["Harness", "Goals"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, judgeModelId, maxRuns, status }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      const threadId = session.thread.getId();
+      if (!threadId) throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "session has no active thread" });
+      const agent = getAgentForSession(harness, session);
+      const record = await agent.updateObjectiveOptions({
+        threadId,
+        ...judgeModelId !== void 0 ? { judgeModelId } : {},
+        ...maxRuns !== void 0 ? { maxRuns } : {},
+        ...status !== void 0 ? { status } : {}
+      });
+      return { goal: record ?? void 0 };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error updating harness goal");
+    }
+  }
+});
+var CLEAR_HARNESS_GOAL_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "DELETE",
+  path: "/harness/:harnessId/sessions/:resourceId/goal",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  responseSchema: ackResponseSchema,
+  summary: "Clear the goal",
+  description: "Removes the active goal from the session\u2019s thread.",
+  tags: ["Harness", "Goals"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      const threadId = session.thread.getId();
+      if (!threadId) throw new chunk64ITUOXI_cjs.HTTPException(400, { message: "session has no active thread" });
+      const agent = getAgentForSession(harness, session);
+      await agent.clearObjective({ threadId });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error clearing harness goal");
+    }
+  }
+});
+var GET_HARNESS_PERMISSIONS_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "GET",
+  path: "/harness/:harnessId/sessions/:resourceId/permissions",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  responseSchema: permissionRulesResponseSchema,
+  summary: "Get permission rules",
+  description: "Returns the current permission rules (per-category and per-tool policies) for the session.",
+  tags: ["Harness", "Permissions"],
+  requiresAuth: true,
+  requiresPermission: "harness:read",
+  handler: async ({ mastra, harnessId, resourceId }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      const rules = session.permissions.getRules();
+      return {
+        categories: rules.categories,
+        tools: rules.tools
+      };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error getting harness permissions");
+    }
+  }
+});
+var SET_HARNESS_CATEGORY_PERMISSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "PUT",
+  path: "/harness/:harnessId/sessions/:resourceId/permissions/category",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: setCategoryPermissionBodySchema,
+  responseSchema: ackResponseSchema,
+  summary: "Set permission for a tool category",
+  description: "Sets the approval policy (allow/ask/deny) for all tools in a category.",
+  tags: ["Harness", "Permissions"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, category, policy }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      await session.permissions.setForCategory({ category, policy });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error setting harness category permission");
+    }
+  }
+});
+var SET_HARNESS_TOOL_PERMISSION_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "PUT",
+  path: "/harness/:harnessId/sessions/:resourceId/permissions/tool",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: setToolPermissionBodySchema,
+  responseSchema: ackResponseSchema,
+  summary: "Set permission for a specific tool",
+  description: "Sets the approval policy (allow/ask/deny) for a specific tool by name. Per-tool overrides take precedence over category policies.",
+  tags: ["Harness", "Permissions"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, toolName, policy }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      await session.permissions.setForTool({ toolName, policy });
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error setting harness tool permission");
+    }
+  }
+});
+var setSessionStateBodySchema = v4.z.object({ state: v4.z.record(v4.z.string(), v4.z.unknown()) });
+var SET_HARNESS_SESSION_STATE_ROUTE = chunkG54X6VE6_cjs.createRoute({
+  method: "PUT",
+  path: "/harness/:harnessId/sessions/:resourceId/state",
+  responseType: "json",
+  pathParamSchema: sessionPathParams,
+  bodySchema: setSessionStateBodySchema,
+  responseSchema: ackResponseSchema,
+  summary: "Set session state",
+  description: "Merges the provided key-value pairs into the session state. Existing keys not in the payload are preserved.",
+  tags: ["Harness"],
+  requiresAuth: true,
+  requiresPermission: "harness:execute",
+  handler: async ({ mastra, harnessId, resourceId, state }) => {
+    try {
+      const harness = getHarnessOrThrow(mastra, harnessId);
+      const session = await getSession(harness, resourceId);
+      await session.state.set(state);
+      return { ok: true };
+    } catch (error) {
+      return chunkZ7LCIYK7_cjs.handleError(error, "error setting harness session state");
+    }
+  }
+});
+
+exports.ABORT_HARNESS_SESSION_ROUTE = ABORT_HARNESS_SESSION_ROUTE;
+exports.CLEAR_HARNESS_GOAL_ROUTE = CLEAR_HARNESS_GOAL_ROUTE;
+exports.CLONE_HARNESS_THREAD_ROUTE = CLONE_HARNESS_THREAD_ROUTE;
+exports.CREATE_HARNESS_SESSION_ROUTE = CREATE_HARNESS_SESSION_ROUTE;
+exports.CREATE_HARNESS_THREAD_ROUTE = CREATE_HARNESS_THREAD_ROUTE;
+exports.DELETE_HARNESS_THREAD_ROUTE = DELETE_HARNESS_THREAD_ROUTE;
+exports.FOLLOW_UP_HARNESS_SESSION_ROUTE = FOLLOW_UP_HARNESS_SESSION_ROUTE;
+exports.GET_HARNESS_GOAL_ROUTE = GET_HARNESS_GOAL_ROUTE;
+exports.GET_HARNESS_OM_RECORD_ROUTE = GET_HARNESS_OM_RECORD_ROUTE;
+exports.GET_HARNESS_PERMISSIONS_ROUTE = GET_HARNESS_PERMISSIONS_ROUTE;
+exports.GET_HARNESS_RESOURCE_IDS_ROUTE = GET_HARNESS_RESOURCE_IDS_ROUTE;
+exports.GET_HARNESS_SESSION_STATE_ROUTE = GET_HARNESS_SESSION_STATE_ROUTE;
+exports.GET_HARNESS_WORKSPACE_STATUS_ROUTE = GET_HARNESS_WORKSPACE_STATUS_ROUTE;
+exports.HARNESS_TOOL_APPROVAL_ROUTE = HARNESS_TOOL_APPROVAL_ROUTE;
+exports.HARNESS_TOOL_SUSPENSION_ROUTE = HARNESS_TOOL_SUSPENSION_ROUTE;
+exports.LIST_HARNESSES_ROUTE = LIST_HARNESSES_ROUTE;
+exports.LIST_HARNESS_MODELS_ROUTE = LIST_HARNESS_MODELS_ROUTE;
+exports.LIST_HARNESS_MODES_ROUTE = LIST_HARNESS_MODES_ROUTE;
+exports.LIST_HARNESS_THREADS_ROUTE = LIST_HARNESS_THREADS_ROUTE;
+exports.LIST_HARNESS_THREAD_MESSAGES_ROUTE = LIST_HARNESS_THREAD_MESSAGES_ROUTE;
+exports.RENAME_HARNESS_THREAD_ROUTE = RENAME_HARNESS_THREAD_ROUTE;
+exports.SEND_HARNESS_MESSAGE_ROUTE = SEND_HARNESS_MESSAGE_ROUTE;
+exports.SEND_HARNESS_NOTIFICATION_ROUTE = SEND_HARNESS_NOTIFICATION_ROUTE;
+exports.SET_HARNESS_CATEGORY_PERMISSION_ROUTE = SET_HARNESS_CATEGORY_PERMISSION_ROUTE;
+exports.SET_HARNESS_GOAL_ROUTE = SET_HARNESS_GOAL_ROUTE;
+exports.SET_HARNESS_RESOURCE_ID_ROUTE = SET_HARNESS_RESOURCE_ID_ROUTE;
+exports.SET_HARNESS_SESSION_STATE_ROUTE = SET_HARNESS_SESSION_STATE_ROUTE;
+exports.SET_HARNESS_TOOL_PERMISSION_ROUTE = SET_HARNESS_TOOL_PERMISSION_ROUTE;
+exports.STEER_HARNESS_SESSION_ROUTE = STEER_HARNESS_SESSION_ROUTE;
+exports.STREAM_HARNESS_SESSION_ROUTE = STREAM_HARNESS_SESSION_ROUTE;
+exports.SWITCH_HARNESS_MODEL_ROUTE = SWITCH_HARNESS_MODEL_ROUTE;
+exports.SWITCH_HARNESS_MODE_ROUTE = SWITCH_HARNESS_MODE_ROUTE;
+exports.SWITCH_HARNESS_THREAD_ROUTE = SWITCH_HARNESS_THREAD_ROUTE;
+exports.UPDATE_HARNESS_GOAL_ROUTE = UPDATE_HARNESS_GOAL_ROUTE;
+//# sourceMappingURL=chunk-I6AIWII6.cjs.map
+//# sourceMappingURL=chunk-I6AIWII6.cjs.map