@bike4mind/cli 0.2.24-feat-pr-files-diff-tools.18476 → 0.2.24-feat-parallel-tool-execution.18470

package/dist/index.js

@@ -4,12 +4,12 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-FV2VQXYX.js";
+} from "./chunk-AHVXP2NS.js";
 import {
   ConfigStore
 } from "./chunk-23T2XGSZ.js";
-import "./chunk-JHCQOESZ.js";
-import "./chunk-GGQZHK5U.js";
+import "./chunk-LPM3TSSU.js";
+import "./chunk-U4GFPBS7.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -21,7 +21,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-XFN2ICKP.js";
+} from "./chunk-6ZSQC2VF.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -77,7 +77,7 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-LOIWIBZT.js";
+} from "./chunk-7L7YVDTP.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
@@ -3132,6 +3132,127 @@ You can use:
 
 // ../../b4m-core/packages/agents/src/ReActAgent.ts
 import { EventEmitter } from "events";
+
+// ../../b4m-core/packages/agents/src/toolParallelizer.ts
+var DEFAULT_WRITE_TOOLS = /* @__PURE__ */ new Set([
+  "edit_file",
+  "edit_local_file",
+  "create_file",
+  "delete_file",
+  "shell_execute",
+  "bash_execute",
+  "git_commit",
+  "git_push"
+]);
+function defaultIsReadOnlyTool(toolName) {
+  return !DEFAULT_WRITE_TOOLS.has(toolName);
+}
+function getToolId(tool) {
+  return `${tool.name}_${JSON.stringify(tool.arguments)}`;
+}
+function categorizeTools(toolsUsed, isReadOnly = defaultIsReadOnlyTool) {
+  const parallelBatch = [];
+  const sequentialBatch = [];
+  const originalOrder = [];
+  for (const tool of toolsUsed) {
+    originalOrder.push(getToolId(tool));
+    if (isReadOnly(tool.name)) {
+      parallelBatch.push(tool);
+    } else {
+      sequentialBatch.push(tool);
+    }
+  }
+  return {
+    parallelBatch,
+    sequentialBatch,
+    originalOrder
+  };
+}
+async function executeToolsInParallel(plan, executor, signal) {
+  const results = /* @__PURE__ */ new Map();
+  if (signal?.aborted) {
+    throw new Error("Tool execution aborted");
+  }
+  if (plan.parallelBatch.length > 0) {
+    const parallelPromises = plan.parallelBatch.map(async (tool) => {
+      const toolId = getToolId(tool);
+      if (signal?.aborted) {
+        return {
+          toolId,
+          result: {
+            toolName: tool.name,
+            error: new Error("Tool execution aborted"),
+            status: "rejected"
+          }
+        };
+      }
+      try {
+        const result = await executor(tool);
+        return {
+          toolId,
+          result: {
+            toolName: tool.name,
+            result,
+            status: "fulfilled"
+          }
+        };
+      } catch (error) {
+        return {
+          toolId,
+          result: {
+            toolName: tool.name,
+            error: error instanceof Error ? error : new Error(String(error)),
+            status: "rejected"
+          }
+        };
+      }
+    });
+    const settledResults = await Promise.allSettled(parallelPromises);
+    for (const settled of settledResults) {
+      if (settled.status === "fulfilled") {
+        results.set(settled.value.toolId, settled.value.result);
+      }
+    }
+  }
+  if (signal?.aborted) {
+    throw new Error("Tool execution aborted");
+  }
+  for (const tool of plan.sequentialBatch) {
+    const toolId = getToolId(tool);
+    if (signal?.aborted) {
+      results.set(toolId, {
+        toolName: tool.name,
+        error: new Error("Tool execution aborted"),
+        status: "rejected"
+      });
+      throw new Error("Tool execution aborted");
+    }
+    try {
+      const result = await executor(tool);
+      results.set(toolId, {
+        toolName: tool.name,
+        result,
+        status: "fulfilled"
+      });
+    } catch (error) {
+      results.set(toolId, {
+        toolName: tool.name,
+        error: error instanceof Error ? error : new Error(String(error)),
+        status: "rejected"
+      });
+    }
+  }
+  return results;
+}
+function shouldUseParallelExecution(toolsUsed, isReadOnly = defaultIsReadOnlyTool) {
+  if (toolsUsed.length < 2) {
+    return false;
+  }
+  const readOnlyCount = toolsUsed.filter((tool) => isReadOnly(tool.name)).length;
+  return readOnlyCount >= 2;
+}
+
+// ../../b4m-core/packages/agents/src/ReActAgent.ts
 var ReActAgent = class extends EventEmitter {
   constructor(context) {
     super();
@@ -3259,77 +3380,51 @@ ${options.context}` : this.getSystemPrompt()
               if (completionInfo.toolsUsed && completionInfo.toolsUsed.length > 0) {
                 hadToolCalls = true;
                 const thinkingBlocks = completionInfo.thinking || [];
+                const unprocessedTools = [];
                 for (const toolUse of completionInfo.toolsUsed) {
-                  const toolCallId = `${toolUse.name}_${JSON.stringify(toolUse.arguments)}`;
-                  if (processedToolIds.has(toolCallId)) {
-                    continue;
+                  const toolCallIdStr = getToolId(toolUse);
+                  if (!processedToolIds.has(toolCallIdStr)) {
+                    processedToolIds.add(toolCallIdStr);
+                    unprocessedTools.push(toolUse);
                   }
-                  processedToolIds.add(toolCallId);
-                  this.toolCallCount++;
-                  const actionStep = {
-                    type: "action",
-                    content: `Using tool: ${toolUse.name}`,
-                    metadata: {
-                      toolName: toolUse.name,
-                      toolInput: toolUse.arguments,
-                      timestamp: Date.now()
-                    }
-                  };
-                  this.steps.push(actionStep);
-                  this.emit("action", actionStep);
-                  const queuedObs = this.observationQueue.find((obs) => obs.toolName === toolUse.name);
-                  let observation;
-                  if (queuedObs) {
-                    observation = queuedObs.result;
-                    const index = this.observationQueue.indexOf(queuedObs);
-                    this.observationQueue.splice(index, 1);
-                  } else {
-                    const tool = this.context.tools.find((t) => t.toolSchema.name === toolUse.name);
-                    if (!tool) {
-                      throw new Error(`Tool ${toolUse.name} not found in agent context`);
-                    }
-                    const params = typeof toolUse.arguments === "string" ? JSON.parse(toolUse.arguments) : toolUse.arguments;
-                    observation = await tool.toolFn(params);
-                    const toolCallId2 = `${toolUse.name}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-                    const assistantContent = [
-                      // Include thinking blocks first (required by Anthropic when thinking is enabled)
-                      ...thinkingBlocks,
-                      // Then the tool use
-                      {
-                        type: "tool_use",
-                        id: toolCallId2,
-                        name: toolUse.name,
-                        input: params
-                      }
-                    ];
-                    this.context.logger.debug(
-                      `[assistantContent] ${assistantContent.length} blocks (${thinkingBlocks.length} thinking, 1 tool_use)`
-                    );
-                    messages.push({
-                      role: "assistant",
-                      content: assistantContent
-                    });
-                    messages.push({
-                      role: "user",
-                      content: [
-                        {
-                          type: "tool_result",
-                          tool_use_id: toolCallId2,
-                          content: typeof observation === "string" ? observation : JSON.stringify(observation)
-                        }
-                      ]
-                    });
+                }
+                if (unprocessedTools.length === 0) {
+                } else if (options.parallelExecution && shouldUseParallelExecution(unprocessedTools, options.isReadOnlyTool ?? defaultIsReadOnlyTool)) {
+                  this.context.logger.debug(
+                    `[ReActAgent] Parallel execution enabled for ${unprocessedTools.length} tools`
+                  );
+                  for (const toolUse of unprocessedTools) {
+                    this.emitActionStep(toolUse);
                   }
-                  const observationStep = {
-                    type: "observation",
-                    content: typeof observation === "string" ? observation : JSON.stringify(observation),
-                    metadata: {
-                      toolName: toolUse.name,
-                      timestamp: Date.now()
+                  const plan = categorizeTools(unprocessedTools, options.isReadOnlyTool ?? defaultIsReadOnlyTool);
+                  const results = await executeToolsInParallel(
+                    plan,
+                    (toolUse) => this.executeToolWithQueueFallback(toolUse),
+                    options.signal
+                  );
+                  for (const toolUse of unprocessedTools) {
+                    const toolIdStr = getToolId(toolUse);
+                    const result2 = results.get(toolIdStr);
+                    const observation = result2?.status === "fulfilled" ? result2.result ?? "" : `Error: ${result2?.error?.message ?? "Unknown error"}`;
+                    this.appendToolMessages(messages, toolUse, observation, thinkingBlocks);
+                    this.emitObservationStep(toolUse.name, observation);
+                  }
+                } else {
+                  for (const toolUse of unprocessedTools) {
+                    this.emitActionStep(toolUse);
+                    const queuedObs = this.observationQueue.find((obs) => obs.toolId === getToolId(toolUse));
+                    let observation;
+                    if (queuedObs) {
+                      const result2 = queuedObs.result;
+                      const index = this.observationQueue.indexOf(queuedObs);
+                      this.observationQueue.splice(index, 1);
+                      observation = typeof result2 === "string" ? result2 : JSON.stringify(result2);
+                    } else {
+                      observation = await this.executeToolWithQueueFallback(toolUse);
+                      this.appendToolMessages(messages, toolUse, observation, thinkingBlocks);
                     }
-                  };
-                  this.steps.push(observationStep);
-                  this.emit("observation", observationStep);
+                    this.emitObservationStep(toolUse.name, observation);
+                  }
                 }
               }
             }
@@ -3466,8 +3561,160 @@ Remember: You are an autonomous AGENT. Act independently and solve problems proa
   getToolCallCount() {
     return this.toolCallCount;
   }
+  /**
+   * Create and emit an action step for a tool use
+   */
+  emitActionStep(toolUse) {
+    this.toolCallCount++;
+    const actionStep = {
+      type: "action",
+      content: `Using tool: ${toolUse.name}`,
+      metadata: {
+        toolName: toolUse.name,
+        toolInput: toolUse.arguments,
+        timestamp: Date.now()
+      }
+    };
+    this.steps.push(actionStep);
+    this.emit("action", actionStep);
+  }
+  /**
+   * Create and emit an observation step
+   */
+  emitObservationStep(toolName, observation) {
+    const observationStep = {
+      type: "observation",
+      content: observation,
+      metadata: {
+        toolName,
+        timestamp: Date.now()
+      }
+    };
+    this.steps.push(observationStep);
+    this.emit("observation", observationStep);
+  }
+  /**
+   * Parse tool arguments, handling both string and object forms
+   */
+  parseToolArguments(args) {
+    return typeof args === "string" ? JSON.parse(args) : args;
+  }
+  /**
+   * Execute a tool and return the result as a string.
+   * Checks observation queue first for backward compatibility.
+   */
+  async executeToolWithQueueFallback(toolUse) {
+    const queuedObs = this.observationQueue.find((obs) => obs.toolId === getToolId(toolUse));
+    if (queuedObs) {
+      const result2 = queuedObs.result;
+      const index = this.observationQueue.indexOf(queuedObs);
+      this.observationQueue.splice(index, 1);
+      return typeof result2 === "string" ? result2 : JSON.stringify(result2);
+    }
+    const tool = this.context.tools.find((t) => t.toolSchema.name === toolUse.name);
+    if (!tool) {
+      throw new Error(`Tool ${toolUse.name} not found in agent context`);
+    }
+    const params = this.parseToolArguments(toolUse.arguments);
+    const result = await tool.toolFn(params);
+    return typeof result === "string" ? result : JSON.stringify(result);
+  }
+  /**
+   * Build and append tool call/result messages for the conversation history
+   */
+  appendToolMessages(messages, toolUse, observation, thinkingBlocks) {
+    const params = this.parseToolArguments(toolUse.arguments);
+    const msgToolCallId = `${toolUse.name}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const assistantContent = [
+      ...thinkingBlocks,
+      {
+        type: "tool_use",
+        id: msgToolCallId,
+        name: toolUse.name,
+        input: params
+      }
+    ];
+    messages.push({
+      role: "assistant",
+      content: assistantContent
+    });
+    messages.push({
+      role: "user",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: msgToolCallId,
+          content: observation
+        }
+      ]
+    });
+  }
 };
 
+// src/config/toolSafety.ts
+import { z as z2 } from "zod";
+var ToolCategorySchema = z2.enum([
+  "auto_approve",
+  // Safe tools that run automatically without permission
+  "prompt_always",
+  // Dangerous tools that ALWAYS require permission (cannot be trusted)
+  "prompt_default"
+  // Tools that prompt by default but can be trusted
+]);
+var ToolSafetyConfigSchema = z2.object({
+  categories: z2.record(z2.string(), ToolCategorySchema),
+  trustedTools: z2.array(z2.string())
+});
+var DEFAULT_TOOL_CATEGORIES = {
+  // ===== AUTO APPROVE (Safe tools) =====
+  // These tools have no side effects and are always safe to execute
+  math_evaluate: "auto_approve",
+  current_datetime: "auto_approve",
+  dice_roll: "auto_approve",
+  prompt_enhancement: "auto_approve",
+  weather_info: "prompt_default",
+  // ===== PROMPT ALWAYS (Dangerous tools) =====
+  // These tools can modify files, execute code, or have other dangerous side effects
+  // They ALWAYS require permission and cannot be trusted automatically
+  edit_file: "prompt_always",
+  edit_local_file: "prompt_always",
+  create_file: "prompt_always",
+  delete_file: "prompt_always",
+  shell_execute: "prompt_always",
+  bash_execute: "prompt_always",
+  git_commit: "prompt_always",
+  git_push: "prompt_always",
+  // ===== PROMPT DEFAULT (Repository read tools) =====
+  // These tools read from the repository but don't modify anything
+  // Users can trust them if they want to avoid prompts
+  web_search: "prompt_default",
+  deep_research: "prompt_default",
+  file_read: "prompt_default",
+  grep_search: "prompt_default",
+  glob_files: "prompt_default",
+  get_file_tree: "prompt_default",
+  git_status: "prompt_default",
+  git_diff: "prompt_default",
+  git_log: "prompt_default",
+  git_branch: "prompt_default"
+};
+function getToolCategory(toolName, customCategories) {
+  if (customCategories && toolName in customCategories) {
+    return customCategories[toolName];
+  }
+  if (toolName in DEFAULT_TOOL_CATEGORIES) {
+    return DEFAULT_TOOL_CATEGORIES[toolName];
+  }
+  return "prompt_default";
+}
+function canTrustTool(toolName, customCategories) {
+  const category = getToolCategory(toolName, customCategories);
+  return category !== "prompt_always";
+}
+function isReadOnlyTool(toolName, customCategories) {
+  return getToolCategory(toolName, customCategories) !== "prompt_always";
+}
+
 // src/core/prompts.ts
 var TOOL_GREP_SEARCH = "grep_search";
 var TOOL_GLOB_FILES = "glob_files";
@@ -3568,38 +3815,38 @@ Remember: Use context from previous messages to understand follow-up questions.$
 // ../../b4m-core/packages/services/dist/src/referService/generateCodes.js
 import { randomBytes } from "crypto";
 import range from "lodash/range.js";
-import { z as z2 } from "zod";
-var generateReferralCodesSchema = z2.object({
-  count: z2.number().optional(),
-  unlimitedUse: z2.boolean().optional(),
-  expiresAt: z2.date().optional()
+import { z as z3 } from "zod";
+var generateReferralCodesSchema = z3.object({
+  count: z3.number().optional(),
+  unlimitedUse: z3.boolean().optional(),
+  expiresAt: z3.date().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/referService/delete.js
-import { z as z3 } from "zod";
-var deleteInviteCodesSchema = z3.object({
-  ids: z3.array(z3.string())
+import { z as z4 } from "zod";
+var deleteInviteCodesSchema = z4.object({
+  ids: z4.array(z4.string())
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/login.js
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 import bcrypt from "bcryptjs";
-var loginUserSchema = z4.object({
-  usernameOrEmail: z4.string(),
-  password: z4.string(),
-  metadata: z4.object({
-    loginTime: z4.date(),
-    userAgent: z4.string(),
-    browser: z4.string(),
-    operatingSystem: z4.string(),
-    deviceType: z4.string(),
-    screenResolution: z4.string(),
-    viewportSize: z4.string(),
-    colorDepth: z4.number(),
-    pixelDepth: z4.number(),
-    devicePixelRatio: z4.number(),
-    ip: z4.string().optional().default(""),
-    location: z4.string().optional()
+var loginUserSchema = z5.object({
+  usernameOrEmail: z5.string(),
+  password: z5.string(),
+  metadata: z5.object({
+    loginTime: z5.date(),
+    userAgent: z5.string(),
+    browser: z5.string(),
+    operatingSystem: z5.string(),
+    deviceType: z5.string(),
+    screenResolution: z5.string(),
+    viewportSize: z5.string(),
+    colorDepth: z5.number(),
+    pixelDepth: z5.number(),
+    devicePixelRatio: z5.number(),
+    ip: z5.string().optional().default(""),
+    location: z5.string().optional()
   }).optional()
 });
 
@@ -3609,78 +3856,78 @@ import escapeRegExp from "lodash/escapeRegExp.js";
 
 // ../../b4m-core/packages/services/dist/src/userService/forgotPassword.js
 import { randomUUID } from "crypto";
-import { z as z5 } from "zod";
-var forgotPasswordUserSchema = z5.object({
-  email: z5.string().email()
+import { z as z6 } from "zod";
+var forgotPasswordUserSchema = z6.object({
+  email: z6.string().email()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/update.js
 import bcrypt3 from "bcryptjs";
-import { z as z6 } from "zod";
-var updateUserSchema = z6.object({
-  name: z6.string().optional(),
-  username: z6.string().optional(),
+import { z as z7 } from "zod";
+var updateUserSchema = z7.object({
+  name: z7.string().optional(),
+  username: z7.string().optional(),
   // email field removed - users must use the secure email change verification flow
   // See requestEmailChange and verifyEmailChange in userService
-  password: z6.string().nullable().optional(),
-  team: z6.string().nullable().optional(),
-  role: z6.string().nullable().optional(),
-  phone: z6.string().nullable().optional(),
-  preferredLanguage: z6.string().nullable().optional(),
-  preferredContact: z6.string().nullable().optional(),
-  preferredVoice: z6.string().nullable().optional(),
-  tshirtSize: z6.string().nullable().optional(),
-  geoLocation: z6.string().nullable().optional(),
-  lastNotebookId: z6.string().nullable().optional(),
-  tags: z6.array(z6.string()).nullable().optional(),
-  lastCreditsPurchasedAt: z6.date().nullable().optional(),
-  systemFiles: z6.array(z6.object({
-    fileId: z6.string(),
-    enabled: z6.boolean()
+  password: z7.string().nullable().optional(),
+  team: z7.string().nullable().optional(),
+  role: z7.string().nullable().optional(),
+  phone: z7.string().nullable().optional(),
+  preferredLanguage: z7.string().nullable().optional(),
+  preferredContact: z7.string().nullable().optional(),
+  preferredVoice: z7.string().nullable().optional(),
+  tshirtSize: z7.string().nullable().optional(),
+  geoLocation: z7.string().nullable().optional(),
+  lastNotebookId: z7.string().nullable().optional(),
+  tags: z7.array(z7.string()).nullable().optional(),
+  lastCreditsPurchasedAt: z7.date().nullable().optional(),
+  systemFiles: z7.array(z7.object({
+    fileId: z7.string(),
+    enabled: z7.boolean()
   })).nullable().optional(),
-  securityQuestions: z6.array(z6.object({ question: z6.string(), answer: z6.string() })).nullable().optional(),
-  photoUrl: z6.string().nullable().optional(),
-  showCreditsUsed: z6.boolean().optional()
+  securityQuestions: z7.array(z7.object({ question: z7.string(), answer: z7.string() })).nullable().optional(),
+  photoUrl: z7.string().nullable().optional(),
+  showCreditsUsed: z7.boolean().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/adminUpdate.js
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/sendFriendRequest.js
-import { z as z7 } from "zod";
-var sendFriendRequestSchema = z7.object({
-  requesterId: z7.string(),
-  recipientId: z7.string(),
-  message: z7.string().optional()
+import { z as z8 } from "zod";
+var sendFriendRequestSchema = z8.object({
+  requesterId: z8.string(),
+  recipientId: z8.string(),
+  message: z8.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/adminUpdate.js
 var adminUpdateUserSchema = updateUserSchema.extend({
-  id: z8.string(),
+  id: z9.string(),
   // Admins can directly update email addresses without verification
-  email: z8.string().email().optional(),
-  role: z8.string().optional().nullable(),
-  isAdmin: z8.boolean().optional(),
-  organizationId: z8.string().optional().nullable(),
-  storageLimit: z8.number().optional(),
-  currentCredits: z8.number().optional(),
-  isBanned: z8.boolean().optional(),
-  isModerated: z8.boolean().optional(),
-  subscribedUntil: z8.string().optional().nullable(),
-  systemFiles: z8.array(z8.object({ fileId: z8.string(), enabled: z8.boolean() })).optional(),
-  level: z8.enum(["DemoUser", "PaidUser", "VIPUser", "ManagerUser", "AdminUser"]).optional(),
-  lastNotebookId: z8.string().optional().nullable(),
-  userNotes: z8.array(z8.object({ timestamp: z8.string(), note: z8.string(), userName: z8.string() })).optional(),
-  numReferralsAvailable: z8.number().optional()
+  email: z9.string().email().optional(),
+  role: z9.string().optional().nullable(),
+  isAdmin: z9.boolean().optional(),
+  organizationId: z9.string().optional().nullable(),
+  storageLimit: z9.number().optional(),
+  currentCredits: z9.number().optional(),
+  isBanned: z9.boolean().optional(),
+  isModerated: z9.boolean().optional(),
+  subscribedUntil: z9.string().optional().nullable(),
+  systemFiles: z9.array(z9.object({ fileId: z9.string(), enabled: z9.boolean() })).optional(),
+  level: z9.enum(["DemoUser", "PaidUser", "VIPUser", "ManagerUser", "AdminUser"]).optional(),
+  lastNotebookId: z9.string().optional().nullable(),
+  userNotes: z9.array(z9.object({ timestamp: z9.string(), note: z9.string(), userName: z9.string() })).optional(),
+  numReferralsAvailable: z9.number().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/register.js
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 import bcrypt4 from "bcryptjs";
 
 // ../../b4m-core/packages/services/dist/src/creditService/addCredits.js
-import { z as z9 } from "zod";
-var AddCreditsSchema = z9.discriminatedUnion("type", [
+import { z as z10 } from "zod";
+var AddCreditsSchema = z10.discriminatedUnion("type", [
   PurchaseTransaction.omit({ createdAt: true, updatedAt: true }),
   SubscriptionCreditTransaction.omit({ createdAt: true, updatedAt: true }),
   GenericCreditAddTransaction.omit({ createdAt: true, updatedAt: true }),
@@ -3688,57 +3935,57 @@ var AddCreditsSchema = z9.discriminatedUnion("type", [
 ]);
 
 // ../../b4m-core/packages/services/dist/src/userService/register.js
-var registerUserSchema = z10.object({
-  username: z10.string(),
-  email: z10.string(),
-  name: z10.string(),
-  inviteCode: z10.string(),
-  password: z10.string(),
-  metadata: z10.object({
-    loginTime: z10.date(),
-    userAgent: z10.string(),
-    browser: z10.string(),
-    operatingSystem: z10.string(),
-    deviceType: z10.string(),
-    screenResolution: z10.string(),
-    viewportSize: z10.string(),
-    colorDepth: z10.number(),
-    pixelDepth: z10.number(),
-    devicePixelRatio: z10.number(),
-    ip: z10.string().optional().default(""),
-    location: z10.string().optional()
+var registerUserSchema = z11.object({
+  username: z11.string(),
+  email: z11.string(),
+  name: z11.string(),
+  inviteCode: z11.string(),
+  password: z11.string(),
+  metadata: z11.object({
+    loginTime: z11.date(),
+    userAgent: z11.string(),
+    browser: z11.string(),
+    operatingSystem: z11.string(),
+    deviceType: z11.string(),
+    screenResolution: z11.string(),
+    viewportSize: z11.string(),
+    colorDepth: z11.number(),
+    pixelDepth: z11.number(),
+    devicePixelRatio: z11.number(),
+    ip: z11.string().optional().default(""),
+    location: z11.string().optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/adminDelete.js
-import { z as z11 } from "zod";
-var adminDeleteUserSchema = z11.object({
-  id: z11.string()
+import { z as z12 } from "zod";
+var adminDeleteUserSchema = z12.object({
+  id: z12.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/searchUserCollection.js
-import { z as z12 } from "zod";
-var searchUserCollectionSchema = z12.object({
-  userId: z12.string(),
-  page: z12.coerce.number().optional().default(1),
-  limit: z12.coerce.number().optional().default(10),
-  search: z12.string().optional().default(""),
-  type: z12.nativeEnum(CollectionType).optional()
+import { z as z13 } from "zod";
+var searchUserCollectionSchema = z13.object({
+  userId: z13.string(),
+  page: z13.coerce.number().optional().default(1),
+  limit: z13.coerce.number().optional().default(10),
+  search: z13.string().optional().default(""),
+  type: z13.nativeEnum(CollectionType).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/recalculateUserStorage.js
-import { z as z13 } from "zod";
-var recalculateUserStorageSchema = z13.object({
+import { z as z14 } from "zod";
+var recalculateUserStorageSchema = z14.object({
   /**
    * The user to recalculate the storage for
    */
-  userId: z13.string()
+  userId: z14.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/listRecentActivities.js
-import { z as z14 } from "zod";
-var listRecentActivitiesSchema = z14.object({
-  coverage: z14.enum(["all", "important"]).default("important")
+import { z as z15 } from "zod";
+var listRecentActivitiesSchema = z15.object({
+  coverage: z15.enum(["all", "important"]).default("important")
 });
 var IMPORTANT_COUNTER_NAMES = [
   SessionEvents.CREATE_SESSION,
@@ -3752,82 +3999,82 @@ var IMPORTANT_COUNTER_NAMES = [
 
 // ../../b4m-core/packages/services/dist/src/userService/sendEmailVerification.js
 import { randomUUID as randomUUID2 } from "crypto";
-import { z as z15 } from "zod";
-var sendEmailVerificationSchema = z15.object({
-  userId: z15.string()
+import { z as z16 } from "zod";
+var sendEmailVerificationSchema = z16.object({
+  userId: z16.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/verifyEmailToken.js
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/utils/crypto.js
 import crypto from "crypto";
 
 // ../../b4m-core/packages/services/dist/src/userService/verifyEmailToken.js
-var verifyEmailTokenSchema = z16.object({
-  token: z16.string()
+var verifyEmailTokenSchema = z17.object({
+  token: z17.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/resendEmailVerification.js
 import { randomUUID as randomUUID3 } from "crypto";
-import { z as z17 } from "zod";
-var resendEmailVerificationSchema = z17.object({
-  userId: z17.string()
+import { z as z18 } from "zod";
+var resendEmailVerificationSchema = z18.object({
+  userId: z18.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/requestEmailChange.js
 import { randomUUID as randomUUID4 } from "crypto";
-import { z as z18 } from "zod";
-var requestEmailChangeSchema = z18.object({
-  userId: z18.string(),
-  newEmail: z18.string().email(),
-  password: z18.string()
+import { z as z19 } from "zod";
+var requestEmailChangeSchema = z19.object({
+  userId: z19.string(),
+  newEmail: z19.string().email(),
+  password: z19.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/verifyEmailChange.js
-import { z as z19 } from "zod";
-var verifyEmailChangeSchema = z19.object({
-  token: z19.string()
+import { z as z20 } from "zod";
+var verifyEmailChangeSchema = z20.object({
+  token: z20.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userService/cancelEmailChange.js
-import { z as z20 } from "zod";
-var cancelEmailChangeSchema = z20.object({
-  userId: z20.string()
+import { z as z21 } from "zod";
+var cancelEmailChangeSchema = z21.object({
+  userId: z21.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/create.js
 import { randomBytes as randomBytes2 } from "crypto";
 import bcrypt5 from "bcryptjs";
-import { z as z21 } from "zod";
-var createUserApiKeySchema = z21.object({
-  name: z21.string().min(1).max(100),
-  scopes: z21.array(z21.nativeEnum(ApiKeyScope)).min(1),
-  expiresAt: z21.date().optional(),
-  rateLimit: z21.object({
-    requestsPerMinute: z21.number().min(1).max(1e3).default(60),
-    requestsPerDay: z21.number().min(1).max(1e4).default(1e3)
+import { z as z22 } from "zod";
+var createUserApiKeySchema = z22.object({
+  name: z22.string().min(1).max(100),
+  scopes: z22.array(z22.nativeEnum(ApiKeyScope)).min(1),
+  expiresAt: z22.date().optional(),
+  rateLimit: z22.object({
+    requestsPerMinute: z22.number().min(1).max(1e3).default(60),
+    requestsPerDay: z22.number().min(1).max(1e4).default(1e3)
   }).optional(),
-  metadata: z21.object({
-    clientIP: z21.string().optional(),
-    userAgent: z21.string().optional(),
-    createdFrom: z21.enum(["dashboard", "cli", "api"])
+  metadata: z22.object({
+    clientIP: z22.string().optional(),
+    userAgent: z22.string().optional(),
+    createdFrom: z22.enum(["dashboard", "cli", "api"])
   })
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/revoke.js
-import { z as z22 } from "zod";
-var revokeUserApiKeySchema = z22.object({
-  keyId: z22.string(),
-  reason: z22.string().optional()
+import { z as z23 } from "zod";
+var revokeUserApiKeySchema = z23.object({
+  keyId: z23.string(),
+  reason: z23.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/rotate.js
 import { randomBytes as randomBytes3 } from "crypto";
 import bcrypt6 from "bcryptjs";
-import { z as z23 } from "zod";
-var rotateUserApiKeySchema = z23.object({
-  keyId: z23.string()
+import { z as z24 } from "zod";
+var rotateUserApiKeySchema = z24.object({
+  keyId: z24.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/userApiKeyService/validate.js
@@ -3974,29 +4221,29 @@ var EVENT_GROUPS = [
 ];
 
 // ../../b4m-core/packages/services/dist/src/countersService/generateReport.js
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/countersService/getAllCounterFrom24Hours.js
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 import dayjs2 from "dayjs";
-var getCounterTotalsForLast24HoursSchema = z24.object({
-  date: z24.string(),
-  endDate: z24.string().optional()
+var getCounterTotalsForLast24HoursSchema = z25.object({
+  date: z25.string(),
+  endDate: z25.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/countersService/generateReport.js
-var generateDailyReportSchema = z25.object({
-  date: z25.string(),
-  startDate: z25.string().optional(),
-  endDate: z25.string().optional()
+var generateDailyReportSchema = z26.object({
+  date: z26.string(),
+  startDate: z26.string().optional(),
+  endDate: z26.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/countersService/incrementUserCounter.js
-import { z as z26 } from "zod";
-var incrementUserCounterSchema = z26.object({
-  action: z26.string(),
-  increment: z26.coerce.number().default(1).optional(),
-  metadata: z26.record(z26.unknown()).optional()
+import { z as z27 } from "zod";
+var incrementUserCounterSchema = z27.object({
+  action: z27.string(),
+  increment: z27.coerce.number().default(1).optional(),
+  metadata: z27.record(z27.unknown()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/countersService/sendSlackReport.js
@@ -4017,42 +4264,42 @@ import yauzl from "yauzl";
 import axios3 from "axios";
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/importOpenaiHistory.js
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 import last from "lodash/last.js";
-var epochDate = () => z27.preprocess((val) => new Date(Number(val) * 1e3), z27.date());
-var openaiConversationSchema = z27.object({
-  id: z27.string(),
-  title: z27.string(),
+var epochDate = () => z28.preprocess((val) => new Date(Number(val) * 1e3), z28.date());
+var openaiConversationSchema = z28.object({
+  id: z28.string(),
+  title: z28.string(),
   create_time: epochDate(),
   update_time: epochDate().nullable(),
-  mapping: z27.record(
-    z27.string(),
-    z27.object({
-      id: z27.string(),
-      parent: z27.string().nullable(),
-      children: z27.array(z27.string()),
-      message: z27.object({
-        id: z27.string(),
+  mapping: z28.record(
+    z28.string(),
+    z28.object({
+      id: z28.string(),
+      parent: z28.string().nullable(),
+      children: z28.array(z28.string()),
+      message: z28.object({
+        id: z28.string(),
         create_time: epochDate(),
         update_time: epochDate().nullable(),
-        author: z27.object({
-          role: z27.string(),
-          name: z27.string().nullable(),
-          metadata: z27.any()
+        author: z28.object({
+          role: z28.string(),
+          name: z28.string().nullable(),
+          metadata: z28.any()
           // Accept any metadata structure
         }).passthrough(),
         // Allow extra fields in author
-        content: z27.object({
-          content_type: z27.string(),
-          parts: z27.array(z27.any()).optional()
+        content: z28.object({
+          content_type: z28.string(),
+          parts: z28.array(z28.any()).optional()
           // Accept any type in parts array (strings, objects, etc.)
         }).passthrough(),
         // Allow extra fields in content
-        status: z27.string(),
-        end_turn: z27.boolean().nullable(),
-        metadata: z27.any(),
+        status: z28.string(),
+        end_turn: z28.boolean().nullable(),
+        metadata: z28.any(),
         // Accept any metadata structure since it varies widely
-        recipient: z27.string()
+        recipient: z28.string()
       }).passthrough().nullable()
     }).passthrough()
     // Allow extra fields in mapping node
@@ -4060,38 +4307,38 @@ var openaiConversationSchema = z27.object({
 }).passthrough();
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/importClaudeHistory.js
-import { z as z28 } from "zod";
-var claudeChatMessageSchema = z28.object({
-  uuid: z28.string().uuid(),
-  text: z28.string(),
-  content: z28.array(
-    z28.object({
-      type: z28.string(),
+import { z as z29 } from "zod";
+var claudeChatMessageSchema = z29.object({
+  uuid: z29.string().uuid(),
+  text: z29.string(),
+  content: z29.array(
+    z29.object({
+      type: z29.string(),
       // Accept any type: "text", "image", "tool_result", etc.
-      text: z28.string().optional()
+      text: z29.string().optional()
       // Make text optional since tool_result may not have it
     }).passthrough()
     // Allow all other fields
   ),
-  sender: z28.enum(["human", "assistant"]),
-  created_at: z28.coerce.date(),
-  updated_at: z28.coerce.date(),
-  attachments: z28.array(z28.any()),
+  sender: z29.enum(["human", "assistant"]),
+  created_at: z29.coerce.date(),
+  updated_at: z29.coerce.date(),
+  attachments: z29.array(z29.any()),
   // Accept any attachment structure
-  files: z28.array(z28.any())
+  files: z29.array(z29.any())
   // Accept any file structure
 }).passthrough();
-var claudeConversationSchema = z28.object({
-  uuid: z28.string().uuid(),
-  name: z28.string(),
-  summary: z28.string().optional(),
+var claudeConversationSchema = z29.object({
+  uuid: z29.string().uuid(),
+  name: z29.string(),
+  summary: z29.string().optional(),
   // Summary field is optional
-  created_at: z28.coerce.date(),
-  updated_at: z28.coerce.date(),
-  account: z28.object({
-    uuid: z28.string().uuid()
+  created_at: z29.coerce.date(),
+  updated_at: z29.coerce.date(),
+  account: z29.object({
+    uuid: z29.string().uuid()
   }),
-  chat_messages: z28.array(claudeChatMessageSchema)
+  chat_messages: z29.array(claudeChatMessageSchema)
 }).passthrough();
 
 // ../../b4m-core/packages/services/dist/src/importHistoryService/index.js
@@ -4102,357 +4349,357 @@ var ImportSource;
 })(ImportSource || (ImportSource = {}));
 
 // ../../b4m-core/packages/services/dist/src/sessionService/create.js
-import { z as z29 } from "zod";
-var createSessionParametersSchema = z29.object({
-  name: z29.string(),
-  knowledgeIds: z29.array(z29.string()).optional(),
-  artifactIds: z29.array(z29.string()).optional(),
-  agentIds: z29.array(z29.string()).optional(),
-  tags: z29.array(z29.object({ name: z29.string(), strength: z29.number() })).optional(),
-  summary: z29.string().optional(),
-  summaryAt: z29.date().optional(),
-  clonedSourceId: z29.string().optional().nullable(),
-  forkedSourceId: z29.string().optional().nullable(),
-  projectId: z29.string().optional(),
-  lastUsedModel: z29.string().optional().nullable()
+import { z as z30 } from "zod";
+var createSessionParametersSchema = z30.object({
+  name: z30.string(),
+  knowledgeIds: z30.array(z30.string()).optional(),
+  artifactIds: z30.array(z30.string()).optional(),
+  agentIds: z30.array(z30.string()).optional(),
+  tags: z30.array(z30.object({ name: z30.string(), strength: z30.number() })).optional(),
+  summary: z30.string().optional(),
+  summaryAt: z30.date().optional(),
+  clonedSourceId: z30.string().optional().nullable(),
+  forkedSourceId: z30.string().optional().nullable(),
+  projectId: z30.string().optional(),
+  lastUsedModel: z30.string().optional().nullable()
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/delete.js
-import { z as z30 } from "zod";
-var deleteSessionSchema = z30.object({
-  id: z30.string()
+import { z as z31 } from "zod";
+var deleteSessionSchema = z31.object({
+  id: z31.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sessionService/sumarize.js
-import { z as z31 } from "zod";
-var sumarizeSessionSchema = z31.object({
-  id: z31.string()
+import { z as z32 } from "zod";
+var sumarizeSessionSchema = z32.object({
+  id: z32.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/create.js
-import { z as z32 } from "zod";
-var createProjectSchema = z32.object({
-  name: z32.string().min(1),
-  description: z32.string().min(1),
-  sessionIds: z32.array(z32.string()).optional(),
-  fileIds: z32.array(z32.string()).optional()
+import { z as z33 } from "zod";
+var createProjectSchema = z33.object({
+  name: z33.string().min(1),
+  description: z33.string().min(1),
+  sessionIds: z33.array(z33.string()).optional(),
+  fileIds: z33.array(z33.string()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/search.js
-import { z as z33 } from "zod";
-var searchProjectsSchema = z33.object({
-  search: z33.string().optional(),
-  filters: z33.object({
-    favorite: z33.coerce.boolean().optional(),
-    scope: z33.record(z33.any()).optional()
+import { z as z34 } from "zod";
+var searchProjectsSchema = z34.object({
+  search: z34.string().optional(),
+  filters: z34.object({
+    favorite: z34.coerce.boolean().optional(),
+    scope: z34.record(z34.any()).optional()
   }).optional(),
-  pagination: z33.object({
-    page: z33.coerce.number().optional(),
-    limit: z33.coerce.number().optional()
+  pagination: z34.object({
+    page: z34.coerce.number().optional(),
+    limit: z34.coerce.number().optional()
   }).optional(),
-  orderBy: z33.object({
-    by: z33.enum(["createdAt", "updatedAt"]).optional(),
-    direction: z33.enum(["asc", "desc"]).optional()
+  orderBy: z34.object({
+    by: z34.enum(["createdAt", "updatedAt"]).optional(),
+    direction: z34.enum(["asc", "desc"]).optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addSessions.js
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 import uniq2 from "lodash/uniq.js";
 
 // ../../b4m-core/packages/services/dist/src/sharingService/accept.js
-import { z as z34 } from "zod";
-var acceptInviteSchema = z34.object({
-  id: z34.string()
+import { z as z35 } from "zod";
+var acceptInviteSchema = z35.object({
+  id: z35.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/cancel.js
-import { z as z35 } from "zod";
-var cancelInviteSchema = z35.object({
-  id: z35.string(),
-  type: z35.nativeEnum(InviteType),
-  email: z35.string().email().optional()
+import { z as z36 } from "zod";
+var cancelInviteSchema = z36.object({
+  id: z36.string(),
+  type: z36.nativeEnum(InviteType),
+  email: z36.string().email().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/cancelOwnDocument.js
-import { z as z36 } from "zod";
-var cancelOwnDocumentInvitesSchema = z36.object({
-  documentId: z36.string(),
-  type: z36.nativeEnum(InviteType)
+import { z as z37 } from "zod";
+var cancelOwnDocumentInvitesSchema = z37.object({
+  documentId: z37.string(),
+  type: z37.nativeEnum(InviteType)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/create.js
-import { z as z37 } from "zod";
+import { z as z38 } from "zod";
 var defaultExpiration = () => new Date((/* @__PURE__ */ new Date()).getFullYear() + 100, (/* @__PURE__ */ new Date()).getMonth(), (/* @__PURE__ */ new Date()).getDate());
 var DEFAULT_AVAILABLE = 1;
-var createInviteSchema = z37.object({
-  id: z37.string(),
-  type: z37.nativeEnum(InviteType),
-  permissions: z37.array(z37.nativeEnum(Permission)),
-  recipients: z37.string().array().optional(),
-  description: z37.string().optional(),
-  expiresAt: z37.date().optional().default(defaultExpiration()),
-  available: z37.number().optional().default(DEFAULT_AVAILABLE)
+var createInviteSchema = z38.object({
+  id: z38.string(),
+  type: z38.nativeEnum(InviteType),
+  permissions: z38.array(z38.nativeEnum(Permission)),
+  recipients: z38.string().array().optional(),
+  description: z38.string().optional(),
+  expiresAt: z38.date().optional().default(defaultExpiration()),
+  available: z38.number().optional().default(DEFAULT_AVAILABLE)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/get.js
-import { z as z38 } from "zod";
-var getInviteSchema = z38.object({
-  id: z38.string(),
-  withUsername: z38.boolean().optional()
+import { z as z39 } from "zod";
+var getInviteSchema = z39.object({
+  id: z39.string(),
+  withUsername: z39.boolean().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/listByDocumentIdAndType.js
-import { z as z39 } from "zod";
-var listInviteByDocumentIdAndTypeSchema = z39.object({
-  documentId: z39.string(),
-  type: z39.nativeEnum(InviteType)
+import { z as z40 } from "zod";
+var listInviteByDocumentIdAndTypeSchema = z40.object({
+  documentId: z40.string(),
+  type: z40.nativeEnum(InviteType)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/listOwnPending.js
-import { z as z40 } from "zod";
-var listOwnPendingInvitesSchema = z40.object({
-  limit: z40.number().min(1).max(100).default(20),
-  page: z40.number().min(1).default(1)
+import { z as z41 } from "zod";
+var listOwnPendingInvitesSchema = z41.object({
+  limit: z41.number().min(1).max(100).default(20),
+  page: z41.number().min(1).default(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/refuse.js
-import { z as z41 } from "zod";
-var refuseInviteSchema = z41.object({
-  id: z41.string()
+import { z as z42 } from "zod";
+var refuseInviteSchema = z42.object({
+  id: z42.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/sharingService/revoke.js
-import { z as z42 } from "zod";
-var revokeSharingSchema = z42.object({
-  id: z42.string(),
-  type: z42.enum(["files", "sessions", "projects"]),
-  userId: z42.string(),
-  projectId: z42.string().optional()
+import { z as z43 } from "zod";
+var revokeSharingSchema = z43.object({
+  id: z43.string(),
+  type: z43.enum(["files", "sessions", "projects"]),
+  userId: z43.string(),
+  projectId: z43.string().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addFiles.js
-import { z as z43 } from "zod";
+import { z as z44 } from "zod";
 import uniq from "lodash/uniq.js";
-var addFilesProjectSchema = z43.object({
-  projectId: z43.string().nonempty(),
-  fileIds: z43.array(z43.string().nonempty())
+var addFilesProjectSchema = z44.object({
+  projectId: z44.string().nonempty(),
+  fileIds: z44.array(z44.string().nonempty())
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/addSessions.js
-var addSessionsProjectSchema = z44.object({
-  projectId: z44.string().nonempty(),
-  sessionIds: z44.array(z44.string().nonempty())
+var addSessionsProjectSchema = z45.object({
+  projectId: z45.string().nonempty(),
+  sessionIds: z45.array(z45.string().nonempty())
 });
 
 // ../../b4m-core/packages/services/dist/src/projectService/get.js
-import { z as z45 } from "zod";
-var getProjectSchema = z45.object({
-  id: z45.string()
-});
-
-// ../../b4m-core/packages/services/dist/src/projectService/update.js
 import { z as z46 } from "zod";
-var updateProjectSchema = z46.object({
-  id: z46.string(),
-  name: z46.string().optional(),
-  description: z46.string().optional()
+var getProjectSchema = z46.object({
+  id: z46.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/delete.js
+// ../../b4m-core/packages/services/dist/src/projectService/update.js
 import { z as z47 } from "zod";
-var deleteProjectSchema = z47.object({
-  id: z47.string()
+var updateProjectSchema = z47.object({
+  id: z47.string(),
+  name: z47.string().optional(),
+  description: z47.string().optional()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/removeFiles.js
+// ../../b4m-core/packages/services/dist/src/projectService/delete.js
 import { z as z48 } from "zod";
-var removeProjectFilesSchema = z48.object({
-  projectId: z48.string(),
-  fileIds: z48.array(z48.string())
+var deleteProjectSchema = z48.object({
+  id: z48.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/removeSessions.js
+// ../../b4m-core/packages/services/dist/src/projectService/removeFiles.js
 import { z as z49 } from "zod";
-var removeProjectSessionsSchema = z49.object({
+var removeProjectFilesSchema = z49.object({
   projectId: z49.string(),
-  sessionIds: z49.array(z49.string())
+  fileIds: z49.array(z49.string())
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/listSessions.js
+// ../../b4m-core/packages/services/dist/src/projectService/removeSessions.js
 import { z as z50 } from "zod";
-var listProjectSessionsSchema = z50.object({
-  projectId: z50.string()
+var removeProjectSessionsSchema = z50.object({
+  projectId: z50.string(),
+  sessionIds: z50.array(z50.string())
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/listFiles.js
+// ../../b4m-core/packages/services/dist/src/projectService/listSessions.js
 import { z as z51 } from "zod";
-var listProjectFilesSchema = z51.object({
+var listProjectSessionsSchema = z51.object({
   projectId: z51.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/listInvites.js
+// ../../b4m-core/packages/services/dist/src/projectService/listFiles.js
 import { z as z52 } from "zod";
-var listProjectInvitesParamsSchema = z52.object({
-  id: z52.string(),
-  statuses: z52.string().optional().default(""),
-  limit: z52.coerce.number().optional().default(10),
-  page: z52.coerce.number().optional().default(1)
+var listProjectFilesSchema = z52.object({
+  projectId: z52.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/addSystemPrompts.js
+// ../../b4m-core/packages/services/dist/src/projectService/listInvites.js
 import { z as z53 } from "zod";
-var addSystemPromptsSchema = z53.object({
-  projectId: z53.string(),
-  fileIds: z53.array(z53.string())
+var listProjectInvitesParamsSchema = z53.object({
+  id: z53.string(),
+  statuses: z53.string().optional().default(""),
+  limit: z53.coerce.number().optional().default(10),
+  page: z53.coerce.number().optional().default(1)
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/toggleSystemPrompt.js
+// ../../b4m-core/packages/services/dist/src/projectService/addSystemPrompts.js
 import { z as z54 } from "zod";
-var toggleSystemPromptSchema = z54.object({
+var addSystemPromptsSchema = z54.object({
   projectId: z54.string(),
-  fileId: z54.string()
+  fileIds: z54.array(z54.string())
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/removeSystemPrompt.js
+// ../../b4m-core/packages/services/dist/src/projectService/toggleSystemPrompt.js
 import { z as z55 } from "zod";
-var removeSystemPromptSchema = z55.object({
+var toggleSystemPromptSchema = z55.object({
   projectId: z55.string(),
   fileId: z55.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/addFavorite.js
-import { z as z58 } from "zod";
-
-// ../../b4m-core/packages/services/dist/src/favoriteService/create.js
+// ../../b4m-core/packages/services/dist/src/projectService/removeSystemPrompt.js
 import { z as z56 } from "zod";
-var createFavoriteParametersSchema = z56.object({
-  documentId: z56.string(),
-  documentType: z56.nativeEnum(FavoriteDocumentType)
+var removeSystemPromptSchema = z56.object({
+  projectId: z56.string(),
+  fileId: z56.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/favoriteService/delete.js
+// ../../b4m-core/packages/services/dist/src/projectService/addFavorite.js
+import { z as z59 } from "zod";
+
+// ../../b4m-core/packages/services/dist/src/favoriteService/create.js
 import { z as z57 } from "zod";
-var deleteFavoriteParametersSchema = z57.object({
+var createFavoriteParametersSchema = z57.object({
   documentId: z57.string(),
   documentType: z57.nativeEnum(FavoriteDocumentType)
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/addFavorite.js
-var addFavoriteParametersSchema = z58.object({
-  projectId: z58.string()
+// ../../b4m-core/packages/services/dist/src/favoriteService/delete.js
+import { z as z58 } from "zod";
+var deleteFavoriteParametersSchema = z58.object({
+  documentId: z58.string(),
+  documentType: z58.nativeEnum(FavoriteDocumentType)
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/deleteFavorite.js
-import { z as z59 } from "zod";
-var deleteFavoriteParametersSchema2 = z59.object({
+// ../../b4m-core/packages/services/dist/src/projectService/addFavorite.js
+var addFavoriteParametersSchema = z59.object({
   projectId: z59.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/removeNonExistentFiles.js
+// ../../b4m-core/packages/services/dist/src/projectService/deleteFavorite.js
 import { z as z60 } from "zod";
-var removeNonExistentFilesSchema = z60.object({
+var deleteFavoriteParametersSchema2 = z60.object({
   projectId: z60.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/projectService/leaveProject.js
+// ../../b4m-core/packages/services/dist/src/projectService/removeNonExistentFiles.js
 import { z as z61 } from "zod";
-var leaveProjectParamsSchema = z61.object({
-  id: z61.string(),
-  userIdToRemove: z61.string().optional()
-  // Optional: if provided, this is a removal by owner
+var removeNonExistentFilesSchema = z61.object({
+  projectId: z61.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/update.js
-import uniq3 from "lodash/uniq.js";
-import isEqual from "lodash/isEqual.js";
+// ../../b4m-core/packages/services/dist/src/projectService/leaveProject.js
 import { z as z62 } from "zod";
-var updateSessionParamtersSchema = z62.object({
+var leaveProjectParamsSchema = z62.object({
   id: z62.string(),
-  name: z62.string().optional(),
-  knowledgeIds: z62.array(z62.string()).optional(),
-  artifactIds: z62.array(z62.string()).optional(),
-  tags: z62.array(z62.object({ name: z62.string(), strength: z62.number() })).optional(),
-  lastUsedModel: z62.string().optional()
+  userIdToRemove: z62.string().optional()
+  // Optional: if provided, this is a removal by owner
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/clone.js
+// ../../b4m-core/packages/services/dist/src/sessionService/update.js
+import uniq3 from "lodash/uniq.js";
+import isEqual from "lodash/isEqual.js";
 import { z as z63 } from "zod";
-var cloneSessionSchema = z63.object({
-  id: z63.string()
+var updateSessionParamtersSchema = z63.object({
+  id: z63.string(),
+  name: z63.string().optional(),
+  knowledgeIds: z63.array(z63.string()).optional(),
+  artifactIds: z63.array(z63.string()).optional(),
+  tags: z63.array(z63.object({ name: z63.string(), strength: z63.number() })).optional(),
+  lastUsedModel: z63.string().optional()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/fork.js
+// ../../b4m-core/packages/services/dist/src/sessionService/clone.js
 import { z as z64 } from "zod";
-var forkSessionSchema = z64.object({
-  sessionId: z64.string(),
-  messageId: z64.string()
+var cloneSessionSchema = z64.object({
+  id: z64.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/snip.js
+// ../../b4m-core/packages/services/dist/src/sessionService/fork.js
 import { z as z65 } from "zod";
-var snipSessionSchema = z65.object({
+var forkSessionSchema = z65.object({
   sessionId: z65.string(),
   messageId: z65.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/get.js
+// ../../b4m-core/packages/services/dist/src/sessionService/snip.js
 import { z as z66 } from "zod";
-var getSessionSchema = z66.object({
-  id: z66.string()
+var snipSessionSchema = z66.object({
+  sessionId: z66.string(),
+  messageId: z66.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/deleteMessage.js
+// ../../b4m-core/packages/services/dist/src/sessionService/get.js
 import { z as z67 } from "zod";
-var deleteSessionMessageSchema = z67.object({
-  sessionId: z67.string(),
-  messageId: z67.string()
+var getSessionSchema = z67.object({
+  id: z67.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/addFavorite.js
+// ../../b4m-core/packages/services/dist/src/sessionService/deleteMessage.js
 import { z as z68 } from "zod";
-var addFavoriteParametersSchema2 = z68.object({
-  sessionId: z68.string()
+var deleteSessionMessageSchema = z68.object({
+  sessionId: z68.string(),
+  messageId: z68.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/deleteFavorite.js
+// ../../b4m-core/packages/services/dist/src/sessionService/addFavorite.js
 import { z as z69 } from "zod";
-var deleteFavoriteParametersSchema3 = z69.object({
+var addFavoriteParametersSchema2 = z69.object({
   sessionId: z69.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/sessionService/autoName.js
+// ../../b4m-core/packages/services/dist/src/sessionService/deleteFavorite.js
 import { z as z70 } from "zod";
-var autoNameParameterSchema = z70.object({
-  sessionId: z70.string(),
+var deleteFavoriteParametersSchema3 = z70.object({
+  sessionId: z70.string()
+});
+
+// ../../b4m-core/packages/services/dist/src/sessionService/autoName.js
+import { z as z71 } from "zod";
+var autoNameParameterSchema = z71.object({
+  sessionId: z71.string(),
   /** The maximum number of words to include in the title */
-  maxWords: z70.number().optional()
+  maxWords: z71.number().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/search.js
-import { z as z71 } from "zod";
-var searchSchema2 = z71.object({
+import { z as z72 } from "zod";
+var searchSchema2 = z72.object({
   /**
    * Text search query (searches in name and description)
    */
-  query: z71.string().optional(),
+  query: z72.string().optional(),
   /**
    * Filter by personal organizations
    */
-  filters: z71.object({
-    personal: z71.union([z71.enum(["true", "false"]).transform((val) => val === "true"), z71.boolean()]).optional(),
-    userId: z71.string().optional()
+  filters: z72.object({
+    personal: z72.union([z72.enum(["true", "false"]).transform((val) => val === "true"), z72.boolean()]).optional(),
+    userId: z72.string().optional()
   }).default({}),
-  pagination: z71.object({
-    page: z71.coerce.number().int().positive().default(1),
-    limit: z71.coerce.number().int().positive().max(100).default(10)
+  pagination: z72.object({
+    page: z72.coerce.number().int().positive().default(1),
+    limit: z72.coerce.number().int().positive().max(100).default(10)
   }).default({
     page: 1,
     limit: 10
   }),
-  orderBy: z71.object({
-    field: z71.enum(["name", "createdAt", "updatedAt"]).default("name"),
-    direction: z71.enum(["asc", "desc"]).default("asc")
+  orderBy: z72.object({
+    field: z72.enum(["name", "createdAt", "updatedAt"]).default("name"),
+    direction: z72.enum(["asc", "desc"]).default("asc")
   }).default({
     field: "name",
     direction: "asc"
@@ -4460,357 +4707,357 @@ var searchSchema2 = z71.object({
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/get.js
-import { z as z72 } from "zod";
-var getSchema = z72.object({
+import { z as z73 } from "zod";
+var getSchema = z73.object({
   /**
    * Organization ID
    */
-  id: z72.string().min(1)
+  id: z73.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/addMember.js
-import { z as z73 } from "zod";
-var addMemberSchema = z73.object({
-  userId: z73.string().optional(),
-  email: z73.string().optional(),
-  organizationId: z73.string(),
-  force: z73.boolean().optional()
+import { z as z74 } from "zod";
+var addMemberSchema = z74.object({
+  userId: z74.string().optional(),
+  email: z74.string().optional(),
+  organizationId: z74.string(),
+  force: z74.boolean().optional()
   // If true, add the user to the organization even if it's at full capacity
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/getUsers.js
-import { z as z74 } from "zod";
-var getUsersSchema = z74.object({
-  id: z74.string()
+import { z as z75 } from "zod";
+var getUsersSchema = z75.object({
+  id: z75.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/create.js
-import { z as z75 } from "zod";
-var createSchema = z75.object({
-  name: z75.string(),
-  personal: z75.boolean().default(false),
-  seats: z75.number().default(1),
-  stripeCustomerId: z75.string().nullable(),
-  billingOwnerId: z75.string().optional(),
+import { z as z76 } from "zod";
+var createSchema = z76.object({
+  name: z76.string(),
+  personal: z76.boolean().default(false),
+  seats: z76.number().default(1),
+  stripeCustomerId: z76.string().nullable(),
+  billingOwnerId: z76.string().optional(),
   // Optional billing owner (defaults to user if not provided)
-  managerId: z75.string().optional()
+  managerId: z76.string().optional()
   // Optional team manager
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/update.js
-import { z as z76 } from "zod";
-var updateSchema = z76.object({
-  id: z76.string(),
-  name: z76.string().optional(),
-  description: z76.string().optional(),
-  billingContact: z76.string().optional(),
-  currentCredits: z76.coerce.number().optional(),
-  systemPrompt: z76.string().max(1e4).optional()
+import { z as z77 } from "zod";
+var updateSchema = z77.object({
+  id: z77.string(),
+  name: z77.string().optional(),
+  description: z77.string().optional(),
+  billingContact: z77.string().optional(),
+  currentCredits: z77.coerce.number().optional(),
+  systemPrompt: z77.string().max(1e4).optional()
   // ~2500 tokens
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/delete.js
-import { z as z77 } from "zod";
-var deleteSchema = z77.object({
+import { z as z78 } from "zod";
+var deleteSchema = z78.object({
   /**
    * Organization ID
    */
-  id: z77.string().min(1)
+  id: z78.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/listPendingUsers.js
-import { z as z78 } from "zod";
-var listPendingUsersSchema = z78.object({
-  organizationId: z78.string()
+import { z as z79 } from "zod";
+var listPendingUsersSchema = z79.object({
+  organizationId: z79.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/revokeAccess.js
-import { z as z79 } from "zod";
-var revokeAccessSchema = z79.object({
-  id: z79.string(),
-  userId: z79.string()
+import { z as z80 } from "zod";
+var revokeAccessSchema = z80.object({
+  id: z80.string(),
+  userId: z80.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/organizationService/leave.js
-import { z as z80 } from "zod";
-var organizationLeaveSchema = z80.object({
-  id: z80.string()
+import { z as z81 } from "zod";
+var organizationLeaveSchema = z81.object({
+  id: z81.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/create.js
-import { z as z81 } from "zod";
-var createApiKeySchema = z81.object({
-  apiKey: z81.string().min(6),
-  description: z81.string().optional().default(""),
-  isActive: z81.boolean().optional().default(true),
-  type: z81.nativeEnum(ApiKeyType),
-  expireDays: z81.number().min(1).max(365).default(90)
+import { z as z82 } from "zod";
+var createApiKeySchema = z82.object({
+  apiKey: z82.string().min(6),
+  description: z82.string().optional().default(""),
+  isActive: z82.boolean().optional().default(true),
+  type: z82.nativeEnum(ApiKeyType),
+  expireDays: z82.number().min(1).max(365).default(90)
   // Default 90-day expiration
 });
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/set.js
-import { z as z82 } from "zod";
-var setApiKeySchema = z82.object({
-  id: z82.string(),
-  type: z82.nativeEnum(ApiKeyType)
+import { z as z83 } from "zod";
+var setApiKeySchema = z83.object({
+  id: z83.string(),
+  type: z83.nativeEnum(ApiKeyType)
 });
 
 // ../../b4m-core/packages/services/dist/src/apiKeyService/delete.js
-import { z as z83 } from "zod";
-var deleteApiKeySchema = z83.object({
-  id: z83.string()
+import { z as z84 } from "zod";
+var deleteApiKeySchema = z84.object({
+  id: z84.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/get.js
-import { z as z84 } from "zod";
-var getFabFileSchema = z84.object({
-  id: z84.string()
+import { z as z85 } from "zod";
+var getFabFileSchema = z85.object({
+  id: z85.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/list.js
-import { z as z85 } from "zod";
-var listFabFilesSchema = z85.object({
-  ids: z85.array(z85.string()).optional()
+import { z as z86 } from "zod";
+var listFabFilesSchema = z86.object({
+  ids: z86.array(z86.string()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/update.js
 import mime from "mime-types";
 import { v4 as uuidv42 } from "uuid";
-import { z as z86 } from "zod";
-var updateFabFileSchema = z86.object({
-  id: z86.string(),
-  fileName: z86.string().optional(),
-  mimeType: z86.string().optional(),
-  fileContent: z86.string().optional(),
-  type: z86.nativeEnum(KnowledgeType).optional(),
-  system: z86.boolean().optional(),
-  systemPriority: z86.number().min(0).max(999).optional(),
-  sessionId: z86.string().optional(),
-  notes: z86.string().optional(),
-  primaryTag: z86.string().optional(),
-  tags: z86.array(z86.object({
-    name: z86.string(),
-    strength: z86.number()
+import { z as z87 } from "zod";
+var updateFabFileSchema = z87.object({
+  id: z87.string(),
+  fileName: z87.string().optional(),
+  mimeType: z87.string().optional(),
+  fileContent: z87.string().optional(),
+  type: z87.nativeEnum(KnowledgeType).optional(),
+  system: z87.boolean().optional(),
+  systemPriority: z87.number().min(0).max(999).optional(),
+  sessionId: z87.string().optional(),
+  notes: z87.string().optional(),
+  primaryTag: z87.string().optional(),
+  tags: z87.array(z87.object({
+    name: z87.string(),
+    strength: z87.number()
   })).optional(),
-  error: z86.string().nullable().optional()
+  error: z87.string().nullable().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/delete.js
-import { z as z87 } from "zod";
-var deleteFabFileSchema = z87.object({
-  id: z87.string()
+import { z as z88 } from "zod";
+var deleteFabFileSchema = z88.object({
+  id: z88.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/chunk.js
-import { z as z88 } from "zod";
-var chunkFileSchema = z88.object({
-  fabFileId: z88.string(),
-  embeddingModel: z88.string()
+import { z as z89 } from "zod";
+var chunkFileSchema = z89.object({
+  fabFileId: z89.string(),
+  embeddingModel: z89.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/vectorize.js
-import { z as z89 } from "zod";
-var vectorizeFabFileChunkSchema = z89.object({
-  fabFileId: z89.string(),
-  chunkId: z89.string()
+import { z as z90 } from "zod";
+var vectorizeFabFileChunkSchema = z90.object({
+  fabFileId: z90.string(),
+  chunkId: z90.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/listBySession.js
-import { z as z90 } from "zod";
-var listFabFilesBySessionSchema = z90.object({
-  sessionId: z90.string()
+import { z as z91 } from "zod";
+var listFabFilesBySessionSchema = z91.object({
+  sessionId: z91.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/listByQuest.js
-import { z as z91 } from "zod";
-var listFabFilesByQuestSchema = z91.object({
-  questId: z91.string()
+import { z as z92 } from "zod";
+var listFabFilesByQuestSchema = z92.object({
+  questId: z92.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/createByUrl.js
-import { z as z92 } from "zod";
-var createFabFileByUrlSchema = z92.object({
-  url: z92.string().regex(/^(?!https?:\/\/(drive|docs)\.google\.com\/(?:file\/d\/|open\?id=|uc\?id=|document\/d\/|spreadsheets\/d\/|presentation\/d\/|forms\/d\/|drive\/folders\/)([a-zA-Z0-9_-]{10,})).+/)
+import { z as z93 } from "zod";
+var createFabFileByUrlSchema = z93.object({
+  url: z93.string().regex(/^(?!https?:\/\/(drive|docs)\.google\.com\/(?:file\/d\/|open\?id=|uc\?id=|document\/d\/|spreadsheets\/d\/|presentation\/d\/|forms\/d\/|drive\/folders\/)([a-zA-Z0-9_-]{10,})).+/)
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/search.js
-import { z as z93 } from "zod";
-var searchFabFilesSchema = z93.object({
-  search: z93.string().optional(),
-  filters: z93.object({
-    tags: z93.array(z93.string()).optional(),
-    type: z93.enum(["text", "pdf", "url", "image", "excel", "word", "json", "csv", "markdown", "code"]).optional(),
-    shared: z93.coerce.boolean().optional(),
+import { z as z94 } from "zod";
+var searchFabFilesSchema = z94.object({
+  search: z94.string().optional(),
+  filters: z94.object({
+    tags: z94.array(z94.string()).optional(),
+    type: z94.enum(["text", "pdf", "url", "image", "excel", "word", "json", "csv", "markdown", "code"]).optional(),
+    shared: z94.coerce.boolean().optional(),
     // Indicates if the user is searching for shared files
-    curated: z93.coerce.boolean().optional(),
+    curated: z94.coerce.boolean().optional(),
     // Indicates if the user is searching for curated notebook files
-    projectId: z93.string().optional(),
-    ids: z93.array(z93.string()).optional()
+    projectId: z94.string().optional(),
+    ids: z94.array(z94.string()).optional()
     // Add support for filtering by IDs
   }).optional(),
-  pagination: z93.object({
-    page: z93.coerce.number(),
-    limit: z93.coerce.number()
+  pagination: z94.object({
+    page: z94.coerce.number(),
+    limit: z94.coerce.number()
   }).optional(),
-  order: z93.object({
-    by: z93.enum(["createdAt", "fileName", "fileSize"]),
-    direction: z93.enum(["asc", "desc"])
+  order: z94.object({
+    by: z94.enum(["createdAt", "fileName", "fileSize"]),
+    direction: z94.enum(["asc", "desc"])
   }).optional(),
-  options: z93.object({
-    includeShared: z93.coerce.boolean().optional()
+  options: z94.object({
+    includeShared: z94.coerce.boolean().optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/addFavorite.js
-import { z as z94 } from "zod";
-var addFavoriteParametersSchema3 = z94.object({
-  fileId: z94.string()
+import { z as z95 } from "zod";
+var addFavoriteParametersSchema3 = z95.object({
+  fileId: z95.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/deleteFavorite.js
-import { z as z95 } from "zod";
-var deleteFavoriteParametersSchema4 = z95.object({
-  fileId: z95.string()
+import { z as z96 } from "zod";
+var deleteFavoriteParametersSchema4 = z96.object({
+  fileId: z96.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/toggleTags.js
-import { z as z96 } from "zod";
-var fabFileToggleTagsSchema = z96.object({
-  ids: z96.array(z96.string()),
-  tags: z96.array(z96.string())
+import { z as z97 } from "zod";
+var fabFileToggleTagsSchema = z97.object({
+  ids: z97.array(z97.string()),
+  tags: z97.array(z97.string())
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/edit.js
-import { z as z97 } from "zod";
+import { z as z98 } from "zod";
 import { diffLines } from "diff";
-var editFabFileSchema = z97.object({
-  id: z97.string(),
-  instruction: z97.string(),
-  selection: z97.object({
-    start: z97.number(),
-    end: z97.number()
+var editFabFileSchema = z98.object({
+  id: z98.string(),
+  instruction: z98.string(),
+  selection: z98.object({
+    start: z98.number(),
+    end: z98.number()
   }).optional(),
-  preserveFormatting: z97.boolean().optional().default(true),
-  applyImmediately: z97.boolean().optional().default(false)
+  preserveFormatting: z98.boolean().optional().default(true),
+  applyImmediately: z98.boolean().optional().default(false)
 });
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/applyEdit.js
 import mime2 from "mime-types";
 import { v4 as uuidv43 } from "uuid";
-import { z as z98 } from "zod";
-var applyEditSchema = z98.object({
-  id: z98.string(),
-  modifiedContent: z98.string(),
-  createBackup: z98.boolean().optional().default(true)
+import { z as z99 } from "zod";
+var applyEditSchema = z99.object({
+  id: z99.string(),
+  modifiedContent: z99.string(),
+  createBackup: z99.boolean().optional().default(true)
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/respondToFriendRequest.js
-import { z as z99 } from "zod";
-var respondToFriendRequestSchema = z99.object({
-  id: z99.string(),
+import { z as z100 } from "zod";
+var respondToFriendRequestSchema = z100.object({
+  id: z100.string(),
   /** The user ID of the recipient of the friend request */
-  userId: z99.string(),
-  accept: z99.boolean()
+  userId: z100.string(),
+  accept: z100.boolean()
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/unfriend.js
-import { z as z100 } from "zod";
-var unfriendSchema = z100.object({
-  friendshipId: z100.string(),
+import { z as z101 } from "zod";
+var unfriendSchema = z101.object({
+  friendshipId: z101.string(),
   /** The user ID of the user who wants to unfriend the other user */
-  userId: z100.string()
+  userId: z101.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/friendshipService/list.js
-import { z as z101 } from "zod";
-var listFriendsSchema = z101.object({
-  userId: z101.string()
+import { z as z102 } from "zod";
+var listFriendsSchema = z102.object({
+  userId: z102.string()
 });
-var listPendingFriendRequestsSchema = z101.object({
-  userId: z101.string()
+var listPendingFriendRequestsSchema = z102.object({
+  userId: z102.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/adminService/loginAs.js
-import { z as z102 } from "zod";
-var loginAsSchema = z102.object({
-  targetUserId: z102.string()
+import { z as z103 } from "zod";
+var loginAsSchema = z103.object({
+  targetUserId: z103.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/get.js
-import { z as z103 } from "zod";
-var getParamsSchema = z103.object({
-  key: z103.string()
+import { z as z104 } from "zod";
+var getParamsSchema = z104.object({
+  key: z104.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/set.js
-import { z as z104 } from "zod";
-var setParamsSchema = z104.object({
-  key: z104.string(),
-  value: z104.any(),
+import { z as z105 } from "zod";
+var setParamsSchema = z105.object({
+  key: z105.string(),
+  value: z105.any(),
   /**
    * Time to live in milliseconds
    */
-  ttl: z104.number(),
-  recache: z104.boolean().optional()
+  ttl: z105.number(),
+  recache: z105.boolean().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/ttl.js
-import { z as z105 } from "zod";
-var ttlParamsSchema = z105.object({
-  key: z105.string()
+import { z as z106 } from "zod";
+var ttlParamsSchema = z106.object({
+  key: z106.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/cacheService/weeklyReports.js
-import { z as z106 } from "zod";
+import { z as z107 } from "zod";
 import dayjs3 from "dayjs";
-var weeklyReportSchema = z106.object({
-  startDate: z106.string(),
-  endDate: z106.string(),
-  report: z106.string(),
-  aiInsights: z106.string().nullable()
+var weeklyReportSchema = z107.object({
+  startDate: z107.string(),
+  endDate: z107.string(),
+  report: z107.string(),
+  aiInsights: z107.string().nullable()
 });
 
 // ../../b4m-core/packages/services/dist/src/embeddingCacheService/generateCacheKey.js
 import crypto2 from "crypto";
 
 // ../../b4m-core/packages/services/dist/src/researchAgentService/create.js
-import { z as z107 } from "zod";
-var researchAgentCreateSchema = z107.object({
-  name: z107.string().min(1),
-  description: z107.string().min(1)
-});
-
-// ../../b4m-core/packages/services/dist/src/researchAgentService/update.js
 import { z as z108 } from "zod";
-var researchAgentUpdateSchema = z108.object({
-  id: z108.string(),
+var researchAgentCreateSchema = z108.object({
   name: z108.string().min(1),
   description: z108.string().min(1)
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/remove.js
+// ../../b4m-core/packages/services/dist/src/researchAgentService/update.js
 import { z as z109 } from "zod";
-var researchAgentRemoveSchema = z109.object({
-  id: z109.string()
+var researchAgentUpdateSchema = z109.object({
+  id: z109.string(),
+  name: z109.string().min(1),
+  description: z109.string().min(1)
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/get.js
+// ../../b4m-core/packages/services/dist/src/researchAgentService/remove.js
 import { z as z110 } from "zod";
-var researchAgentGetSchema = z110.object({
+var researchAgentRemoveSchema = z110.object({
   id: z110.string()
 });
 
-// ../../b4m-core/packages/services/dist/src/researchAgentService/listFiles.js
+// ../../b4m-core/packages/services/dist/src/researchAgentService/get.js
 import { z as z111 } from "zod";
-var researchAgentListFilesSchema = z111.object({
+var researchAgentGetSchema = z111.object({
+  id: z111.string()
+});
+
+// ../../b4m-core/packages/services/dist/src/researchAgentService/listFiles.js
+import { z as z112 } from "zod";
+var researchAgentListFilesSchema = z112.object({
   /**
    * The ID of the research agent
    */
-  id: z111.string()
+  id: z112.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/process.js
-import { z as z112 } from "zod";
+import { z as z113 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/lib/turndown.js
 import turndown from "turndown";
@@ -5201,316 +5448,316 @@ var deepResearchTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/process.js
-var ResearchTaskProcessSchema = z112.object({
-  id: z112.string()
+var ResearchTaskProcessSchema = z113.object({
+  id: z113.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/create.js
-import { z as z113 } from "zod";
-var researchTaskCreateSchema = z113.object({
-  researchAgentId: z113.string(),
-  title: z113.string().max(100),
-  description: z113.string().max(500),
-  prompt: z113.string().max(500).optional(),
-  type: z113.nativeEnum(ResearchTaskType),
-  executionType: z113.nativeEnum(ResearchTaskExecutionType).default(ResearchTaskExecutionType.ON_DEMAND),
-  fileTagId: z113.string().optional(),
-  autoGeneratedTag: z113.object({
-    name: z113.string(),
-    icon: z113.string(),
-    color: z113.string()
+import { z as z114 } from "zod";
+var researchTaskCreateSchema = z114.object({
+  researchAgentId: z114.string(),
+  title: z114.string().max(100),
+  description: z114.string().max(500),
+  prompt: z114.string().max(500).optional(),
+  type: z114.nativeEnum(ResearchTaskType),
+  executionType: z114.nativeEnum(ResearchTaskExecutionType).default(ResearchTaskExecutionType.ON_DEMAND),
+  fileTagId: z114.string().optional(),
+  autoGeneratedTag: z114.object({
+    name: z114.string(),
+    icon: z114.string(),
+    color: z114.string()
   }).optional()
 });
 var researchTaskScrapeCreateSchema = researchTaskCreateSchema.extend({
-  urls: z113.array(z113.string().url()).min(1),
-  canDiscoverLinks: z113.boolean()
+  urls: z114.array(z114.string().url()).min(1),
+  canDiscoverLinks: z114.boolean()
 });
 var researchTaskPeriodicCreateSchema = researchTaskCreateSchema.extend({
-  executionPeriodicStartAt: z113.coerce.date(),
-  executionPeriodicEndAt: z113.coerce.date(),
-  executionPeriodicFrequency: z113.nativeEnum(ResearchTaskPeriodicFrequencyType)
+  executionPeriodicStartAt: z114.coerce.date(),
+  executionPeriodicEndAt: z114.coerce.date(),
+  executionPeriodicFrequency: z114.nativeEnum(ResearchTaskPeriodicFrequencyType)
 });
 var researchTaskScheduledCreateSchema = researchTaskCreateSchema.extend({
-  executionScheduledAt: z113.coerce.date()
+  executionScheduledAt: z114.coerce.date()
 });
 var researchTaskDeepResearchCreateSchema = researchTaskCreateSchema.extend({
-  maxDepth: z113.number().min(1).max(10).optional()
+  maxDepth: z114.number().min(1).max(10).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/search.js
-import { z as z114 } from "zod";
-var searchResearchTasksSchema = z114.object({
-  search: z114.string().optional(),
+import { z as z115 } from "zod";
+var searchResearchTasksSchema = z115.object({
+  search: z115.string().optional(),
   // ADD FILTERS SCHEMA HERE
   // filters: z
   //   .object({
   //     userId: z.string().optional(),
   //   })
   //   .optional(),
-  pagination: z114.object({
-    page: z114.coerce.number().optional(),
-    limit: z114.coerce.number().optional()
+  pagination: z115.object({
+    page: z115.coerce.number().optional(),
+    limit: z115.coerce.number().optional()
   }).optional(),
-  orderBy: z114.object({
-    by: z114.enum(["createdAt", "updatedAt"]).optional(),
-    direction: z114.enum(["asc", "desc"]).optional()
+  orderBy: z115.object({
+    by: z115.enum(["createdAt", "updatedAt"]).optional(),
+    direction: z115.enum(["asc", "desc"]).optional()
   }).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/get.js
-import { z as z115 } from "zod";
-var getResearchTaskSchema = z115.object({
-  id: z115.string().min(1)
+import { z as z116 } from "zod";
+var getResearchTaskSchema = z116.object({
+  id: z116.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/update.js
-import { z as z116 } from "zod";
-var updateResearchTaskSchema = z116.object({
-  id: z116.string(),
-  title: z116.string(),
-  description: z116.string(),
-  type: z116.nativeEnum(ResearchTaskType)
+import { z as z117 } from "zod";
+var updateResearchTaskSchema = z117.object({
+  id: z117.string(),
+  title: z117.string(),
+  description: z117.string(),
+  type: z117.nativeEnum(ResearchTaskType)
 });
 var researchTaskScrapeUpdateSchema = updateResearchTaskSchema.extend({
-  urls: z116.array(z116.string().url()).min(1),
-  canDiscoverLinks: z116.boolean()
+  urls: z117.array(z117.string().url()).min(1),
+  canDiscoverLinks: z117.boolean()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/listByAgentId.js
-import { z as z117 } from "zod";
-var listByAgentIdSchema = z117.object({
-  researchAgentId: z117.string()
+import { z as z118 } from "zod";
+var listByAgentIdSchema = z118.object({
+  researchAgentId: z118.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/remove.js
-import { z as z118 } from "zod";
-var researchTaskRemoveSchema = z118.object({
-  id: z118.string().min(1)
+import { z as z119 } from "zod";
+var researchTaskRemoveSchema = z119.object({
+  id: z119.string().min(1)
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/retry.js
-import { z as z119 } from "zod";
-var researchTaskRetrySchema = z119.object({
-  id: z119.string(),
-  userId: z119.string()
+import { z as z120 } from "zod";
+var researchTaskRetrySchema = z120.object({
+  id: z120.string(),
+  userId: z120.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/processDiscoveredLinks.js
 import axios4 from "axios";
-import { z as z120 } from "zod";
+import { z as z121 } from "zod";
 import plimit from "p-limit";
 import pLimit2 from "p-limit";
-var researchTaskProcessDiscoveredLinksSchema = z120.object({
-  id: z120.string()
+var researchTaskProcessDiscoveredLinksSchema = z121.object({
+  id: z121.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchTaskService/downloadRelevantLinks.js
-import { z as z121 } from "zod";
+import { z as z122 } from "zod";
 import plimit2 from "p-limit";
 import axios5 from "axios";
 import { fileTypeFromBuffer } from "file-type";
-var researchTaskDownloadRelevantLinksSchema = z121.object({
-  id: z121.string()
+var researchTaskDownloadRelevantLinksSchema = z122.object({
+  id: z122.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/researchData/remove.js
-import { z as z122 } from "zod";
-var researchDataRemoveSchema = z122.object({
-  id: z122.string(),
-  researchAgentId: z122.string()
+import { z as z123 } from "zod";
+var researchDataRemoveSchema = z123.object({
+  id: z123.string(),
+  researchAgentId: z123.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/taskSchedulerService/create.js
-import { z as z123 } from "zod";
-var researchTaskPayload = z123.object({
-  id: z123.string(),
-  userId: z123.string()
+import { z as z124 } from "zod";
+var researchTaskPayload = z124.object({
+  id: z124.string(),
+  userId: z124.string()
 });
-var customTaskPayload = z123.object({
-  test: z123.string()
+var customTaskPayload = z124.object({
+  test: z124.string()
 });
-var taskSchedulerCreate = z123.discriminatedUnion("handler", [
-  z123.object({
-    handler: z123.literal(TaskScheduleHandler.RESEARCH_TASK_PROCESS),
+var taskSchedulerCreate = z124.discriminatedUnion("handler", [
+  z124.object({
+    handler: z124.literal(TaskScheduleHandler.RESEARCH_TASK_PROCESS),
     payload: researchTaskPayload,
-    processDate: z123.date()
+    processDate: z124.date()
   }),
-  z123.object({
-    handler: z123.literal(TaskScheduleHandler.CUSTOM_TASK_PROCESS),
+  z124.object({
+    handler: z124.literal(TaskScheduleHandler.CUSTOM_TASK_PROCESS),
     payload: customTaskPayload,
-    processDate: z123.date()
+    processDate: z124.date()
   })
 ]);
 
 // ../../b4m-core/packages/services/dist/src/tagService/createFileTag.js
-import { z as z124 } from "zod";
-var tagCreateFileTagSchema = z124.object({
-  name: z124.string(),
-  icon: z124.string().optional(),
-  color: z124.string().optional(),
-  description: z124.string().optional()
-});
-
-// ../../b4m-core/packages/services/dist/src/tagService/create.js
 import { z as z125 } from "zod";
-var tagCreateSchema = z125.object({
+var tagCreateFileTagSchema = z125.object({
   name: z125.string(),
   icon: z125.string().optional(),
-  description: z125.string().optional(),
   color: z125.string().optional(),
-  type: z125.nativeEnum(TagType)
+  description: z125.string().optional()
 });
 
-// ../../b4m-core/packages/services/dist/src/tagService/update.js
+// ../../b4m-core/packages/services/dist/src/tagService/create.js
 import { z as z126 } from "zod";
-var tagUpdateSchema = z126.object({
-  id: z126.string(),
-  name: z126.string().optional(),
+var tagCreateSchema = z126.object({
+  name: z126.string(),
   icon: z126.string().optional(),
   description: z126.string().optional(),
-  color: z126.string().optional()
+  color: z126.string().optional(),
+  type: z126.nativeEnum(TagType)
 });
 
-// ../../b4m-core/packages/services/dist/src/tagService/remove.js
+// ../../b4m-core/packages/services/dist/src/tagService/update.js
 import { z as z127 } from "zod";
-var tagRemoveSchema = z127.object({
-  id: z127.string()
+var tagUpdateSchema = z127.object({
+  id: z127.string(),
+  name: z127.string().optional(),
+  icon: z127.string().optional(),
+  description: z127.string().optional(),
+  color: z127.string().optional()
 });
 
-// ../../b4m-core/packages/services/dist/src/artifactService/create.js
+// ../../b4m-core/packages/services/dist/src/tagService/remove.js
 import { z as z128 } from "zod";
-var createArtifactSchema = z128.object({
-  id: z128.string().optional(),
+var tagRemoveSchema = z128.object({
+  id: z128.string()
+});
+
+// ../../b4m-core/packages/services/dist/src/artifactService/create.js
+import { z as z129 } from "zod";
+var createArtifactSchema = z129.object({
+  id: z129.string().optional(),
   // Allow custom ID for AI-generated artifacts
-  type: z128.enum(["mermaid", "recharts", "python", "react", "html", "svg", "code", "quest", "file", "questmaster"]),
-  title: z128.string().min(1).max(255),
-  description: z128.string().max(1e3).optional(),
-  content: z128.string().min(1),
-  projectId: z128.string().optional(),
-  organizationId: z128.string().optional(),
-  visibility: z128.enum(["private", "project", "organization", "public"]).default("private"),
-  tags: z128.array(z128.string().max(50)).max(20).default([]),
-  versionTag: z128.string().max(100).optional(),
-  sourceQuestId: z128.string().optional(),
-  sessionId: z128.string().optional(),
-  parentArtifactId: z128.string().optional(),
-  permissions: z128.object({
-    canRead: z128.array(z128.string()).default([]),
-    canWrite: z128.array(z128.string()).default([]),
-    canDelete: z128.array(z128.string()).default([]),
-    isPublic: z128.boolean().default(false),
-    inheritFromProject: z128.boolean().default(true)
+  type: z129.enum(["mermaid", "recharts", "python", "react", "html", "svg", "code", "quest", "file", "questmaster"]),
+  title: z129.string().min(1).max(255),
+  description: z129.string().max(1e3).optional(),
+  content: z129.string().min(1),
+  projectId: z129.string().optional(),
+  organizationId: z129.string().optional(),
+  visibility: z129.enum(["private", "project", "organization", "public"]).default("private"),
+  tags: z129.array(z129.string().max(50)).max(20).default([]),
+  versionTag: z129.string().max(100).optional(),
+  sourceQuestId: z129.string().optional(),
+  sessionId: z129.string().optional(),
+  parentArtifactId: z129.string().optional(),
+  permissions: z129.object({
+    canRead: z129.array(z129.string()).default([]),
+    canWrite: z129.array(z129.string()).default([]),
+    canDelete: z129.array(z129.string()).default([]),
+    isPublic: z129.boolean().default(false),
+    inheritFromProject: z129.boolean().default(true)
   }).optional(),
-  metadata: z128.record(z128.unknown()).default({})
+  metadata: z129.record(z129.unknown()).default({})
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/get.js
-import { z as z129 } from "zod";
-var getArtifactSchema = z129.object({
-  id: z129.string(),
-  includeContent: z129.boolean().default(false),
-  includeVersions: z129.boolean().default(false),
-  version: z129.number().optional()
+import { z as z130 } from "zod";
+var getArtifactSchema = z130.object({
+  id: z130.string(),
+  includeContent: z130.boolean().default(false),
+  includeVersions: z130.boolean().default(false),
+  version: z130.number().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/list.js
-import { z as z130 } from "zod";
-var listArtifactsSchema = z130.object({
-  type: z130.string().optional(),
-  status: z130.enum(["draft", "review", "published", "archived"]).optional(),
-  visibility: z130.enum(["private", "project", "organization", "public"]).optional(),
-  projectId: z130.string().optional(),
-  sessionId: z130.string().optional(),
-  tags: z130.array(z130.string()).optional(),
-  search: z130.string().optional(),
-  limit: z130.number().min(1).max(100).default(20),
-  offset: z130.number().min(0).default(0),
-  sortBy: z130.enum(["createdAt", "updatedAt", "title", "type"]).default("updatedAt"),
-  sortOrder: z130.enum(["asc", "desc"]).default("desc"),
-  includeDeleted: z130.boolean().default(false)
+import { z as z131 } from "zod";
+var listArtifactsSchema = z131.object({
+  type: z131.string().optional(),
+  status: z131.enum(["draft", "review", "published", "archived"]).optional(),
+  visibility: z131.enum(["private", "project", "organization", "public"]).optional(),
+  projectId: z131.string().optional(),
+  sessionId: z131.string().optional(),
+  tags: z131.array(z131.string()).optional(),
+  search: z131.string().optional(),
+  limit: z131.number().min(1).max(100).default(20),
+  offset: z131.number().min(0).default(0),
+  sortBy: z131.enum(["createdAt", "updatedAt", "title", "type"]).default("updatedAt"),
+  sortOrder: z131.enum(["asc", "desc"]).default("desc"),
+  includeDeleted: z131.boolean().default(false)
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/update.js
-import { z as z131 } from "zod";
-var updateArtifactSchema = z131.object({
-  id: z131.string(),
-  title: z131.string().min(1).max(255).optional(),
-  description: z131.string().max(1e3).optional(),
-  content: z131.string().optional(),
-  visibility: z131.enum(["private", "project", "organization", "public"]).optional(),
-  status: z131.enum(["draft", "review", "published", "archived"]).optional(),
-  tags: z131.array(z131.string().max(50)).max(20).optional(),
-  versionTag: z131.string().max(100).optional(),
-  permissions: z131.object({
-    canRead: z131.array(z131.string()).optional(),
-    canWrite: z131.array(z131.string()).optional(),
-    canDelete: z131.array(z131.string()).optional(),
-    isPublic: z131.boolean().optional(),
-    inheritFromProject: z131.boolean().optional()
+import { z as z132 } from "zod";
+var updateArtifactSchema = z132.object({
+  id: z132.string(),
+  title: z132.string().min(1).max(255).optional(),
+  description: z132.string().max(1e3).optional(),
+  content: z132.string().optional(),
+  visibility: z132.enum(["private", "project", "organization", "public"]).optional(),
+  status: z132.enum(["draft", "review", "published", "archived"]).optional(),
+  tags: z132.array(z132.string().max(50)).max(20).optional(),
+  versionTag: z132.string().max(100).optional(),
+  permissions: z132.object({
+    canRead: z132.array(z132.string()).optional(),
+    canWrite: z132.array(z132.string()).optional(),
+    canDelete: z132.array(z132.string()).optional(),
+    isPublic: z132.boolean().optional(),
+    inheritFromProject: z132.boolean().optional()
   }).optional(),
-  metadata: z131.record(z131.unknown()).optional(),
-  changes: z131.array(z131.string()).optional(),
-  changeDescription: z131.string().max(1e3).optional(),
-  createNewVersion: z131.boolean().optional(),
-  versionMessage: z131.string().max(500).optional()
+  metadata: z132.record(z132.unknown()).optional(),
+  changes: z132.array(z132.string()).optional(),
+  changeDescription: z132.string().max(1e3).optional(),
+  createNewVersion: z132.boolean().optional(),
+  versionMessage: z132.string().max(500).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/artifactService/delete.js
-import { z as z132 } from "zod";
-var deleteArtifactSchema = z132.object({
-  id: z132.string(),
-  hardDelete: z132.boolean().default(false)
+import { z as z133 } from "zod";
+var deleteArtifactSchema = z133.object({
+  id: z133.string(),
+  hardDelete: z133.boolean().default(false)
   // For future implementation
 });
 
 // ../../b4m-core/packages/services/dist/src/questMasterService/create.js
-import { z as z133 } from "zod";
-var questSchema = z133.object({
-  id: z133.string(),
-  title: z133.string().min(1).max(255),
-  description: z133.string().max(MAX_DESCRIPTION_LENGTH),
-  status: z133.enum(["not_started", "in_progress", "completed", "blocked"]).default("not_started"),
-  order: z133.number().min(0),
-  dependencies: z133.array(z133.string()).default([]),
-  estimatedTime: z133.string().optional()
-});
-var questResourceSchema = z133.object({
-  title: z133.string().min(1).max(255),
-  url: z133.string().url(),
-  type: z133.enum(["documentation", "tutorial", "reference", "example"])
-});
-var createQuestMasterSchema = z133.object({
-  title: z133.string().min(1).max(255),
-  description: z133.string().max(MAX_DESCRIPTION_LENGTH).optional(),
-  goal: z133.string().min(1).max(MAX_GOAL_LENGTH),
-  complexity: z133.enum(["beginner", "intermediate", "advanced", "expert"]),
-  estimatedTotalTime: z133.string().optional(),
-  prerequisites: z133.array(z133.string().max(200)).default([]),
-  quests: z133.array(questSchema).min(1),
-  resources: z133.array(questResourceSchema).default([]),
-  projectId: z133.string().optional(),
-  organizationId: z133.string().optional(),
-  visibility: z133.enum(["private", "project", "organization", "public"]).default("private"),
-  tags: z133.array(z133.string().max(MAX_TAG_LENGTH)).max(20).default([]),
-  permissions: z133.object({
-    canRead: z133.array(z133.string()).default([]),
-    canWrite: z133.array(z133.string()).default([]),
-    canDelete: z133.array(z133.string()).default([]),
-    isPublic: z133.boolean().default(false),
-    inheritFromProject: z133.boolean().default(true)
+import { z as z134 } from "zod";
+var questSchema = z134.object({
+  id: z134.string(),
+  title: z134.string().min(1).max(255),
+  description: z134.string().max(MAX_DESCRIPTION_LENGTH),
+  status: z134.enum(["not_started", "in_progress", "completed", "blocked"]).default("not_started"),
+  order: z134.number().min(0),
+  dependencies: z134.array(z134.string()).default([]),
+  estimatedTime: z134.string().optional()
+});
+var questResourceSchema = z134.object({
+  title: z134.string().min(1).max(255),
+  url: z134.string().url(),
+  type: z134.enum(["documentation", "tutorial", "reference", "example"])
+});
+var createQuestMasterSchema = z134.object({
+  title: z134.string().min(1).max(255),
+  description: z134.string().max(MAX_DESCRIPTION_LENGTH).optional(),
+  goal: z134.string().min(1).max(MAX_GOAL_LENGTH),
+  complexity: z134.enum(["beginner", "intermediate", "advanced", "expert"]),
+  estimatedTotalTime: z134.string().optional(),
+  prerequisites: z134.array(z134.string().max(200)).default([]),
+  quests: z134.array(questSchema).min(1),
+  resources: z134.array(questResourceSchema).default([]),
+  projectId: z134.string().optional(),
+  organizationId: z134.string().optional(),
+  visibility: z134.enum(["private", "project", "organization", "public"]).default("private"),
+  tags: z134.array(z134.string().max(MAX_TAG_LENGTH)).max(20).default([]),
+  permissions: z134.object({
+    canRead: z134.array(z134.string()).default([]),
+    canWrite: z134.array(z134.string()).default([]),
+    canDelete: z134.array(z134.string()).default([]),
+    isPublic: z134.boolean().default(false),
+    inheritFromProject: z134.boolean().default(true)
   }).optional(),
-  sourceQuestId: z133.string().optional(),
-  sessionId: z133.string().optional(),
-  metadata: z133.record(z133.unknown()).default({})
+  sourceQuestId: z134.string().optional(),
+  sessionId: z134.string().optional(),
+  metadata: z134.record(z134.unknown()).default({})
 });
 
 // ../../b4m-core/packages/services/dist/src/questMasterService/updateQuestStatus.js
-import { z as z134 } from "zod";
-var updateQuestStatusSchema = z134.object({
-  artifactId: z134.string(),
-  questId: z134.string(),
-  status: z134.enum(["not_started", "in_progress", "completed", "blocked"]),
-  completionNote: z134.string().max(500).optional()
+import { z as z135 } from "zod";
+var updateQuestStatusSchema = z135.object({
+  artifactId: z135.string(),
+  questId: z135.string(),
+  status: z135.enum(["not_started", "in_progress", "completed", "blocked"]),
+  completionNote: z135.string().max(500).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/dataLakeService/opensearchClient.js
@@ -5530,61 +5777,70 @@ import { v4 as uuidv44 } from "uuid";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // ../../b4m-core/packages/services/dist/src/emailIngestionService/types.js
-import { z as z135 } from "zod";
-var processIngestedEmailOptionsSchema = z135.object({
-  platformDomain: z135.string().optional(),
-  isNewsletter: z135.boolean().optional()
+import { z as z136 } from "zod";
+var processIngestedEmailOptionsSchema = z136.object({
+  platformDomain: z136.string().optional(),
+  isNewsletter: z136.boolean().optional()
 }).optional();
-var emailAttachmentSchema = z135.object({
-  filename: z135.string().optional(),
-  contentType: z135.string().optional(),
-  contentDisposition: z135.string().optional(),
-  size: z135.number().min(0),
-  content: z135.instanceof(Buffer),
-  related: z135.boolean().optional()
-});
-var parsedEmailObjectSchema = z135.object({
-  messageId: z135.string().optional(),
-  inReplyTo: z135.string().optional(),
-  references: z135.union([z135.string(), z135.array(z135.string())]).optional(),
-  from: z135.any().optional(),
+var emailAttachmentSchema = z136.object({
+  filename: z136.string().optional(),
+  contentType: z136.string().optional(),
+  contentDisposition: z136.string().optional(),
+  size: z136.number().min(0),
+  content: z136.instanceof(Buffer),
+  related: z136.boolean().optional()
+});
+var parsedEmailObjectSchema = z136.object({
+  messageId: z136.string().optional(),
+  inReplyTo: z136.string().optional(),
+  references: z136.union([z136.string(), z136.array(z136.string())]).optional(),
+  from: z136.any().optional(),
   // Complex email address object
-  to: z135.any().optional(),
-  cc: z135.any().optional(),
-  bcc: z135.any().optional(),
-  subject: z135.string().optional(),
-  date: z135.date().optional(),
-  text: z135.string().optional(),
-  html: z135.string().optional(),
-  attachments: z135.array(emailAttachmentSchema).optional()
-});
-var processIngestedEmailSchema = z135.object({
+  to: z136.any().optional(),
+  cc: z136.any().optional(),
+  bcc: z136.any().optional(),
+  subject: z136.string().optional(),
+  date: z136.date().optional(),
+  text: z136.string().optional(),
+  html: z136.string().optional(),
+  attachments: z136.array(emailAttachmentSchema).optional()
+});
+var processIngestedEmailSchema = z136.object({
   parsedEmail: parsedEmailObjectSchema,
-  rawEmailS3Key: z135.string().min(1, "rawEmailS3Key cannot be empty"),
+  rawEmailS3Key: z136.string().min(1, "rawEmailS3Key cannot be empty"),
   options: processIngestedEmailOptionsSchema
 });
 
 // ../../b4m-core/packages/services/dist/src/emailAnalysisService/types.js
-import { z as z136 } from "zod";
-var llmAnalysisResponseSchema = z136.object({
-  summary: z136.string().min(1, "Summary cannot be empty"),
-  entities: z136.object({
-    companies: z136.array(z136.string()).default([]),
-    people: z136.array(z136.string()).default([]),
-    products: z136.array(z136.string()).default([]),
-    technologies: z136.array(z136.string()).default([])
+import { z as z137 } from "zod";
+var llmAnalysisResponseSchema = z137.object({
+  summary: z137.string().min(1, "Summary cannot be empty"),
+  entities: z137.object({
+    companies: z137.array(z137.string()).default([]),
+    people: z137.array(z137.string()).default([]),
+    products: z137.array(z137.string()).default([]),
+    technologies: z137.array(z137.string()).default([])
   }),
-  sentiment: z136.enum(["positive", "neutral", "negative", "urgent"]),
-  actionItems: z136.array(z136.object({
-    description: z136.string(),
-    deadline: z136.string().optional()
+  sentiment: z137.enum(["positive", "neutral", "negative", "urgent"]),
+  actionItems: z137.array(z137.object({
+    description: z137.string(),
+    deadline: z137.string().optional()
     // ISO date string from LLM
   })).default([]),
-  privacyRecommendation: z136.enum(["public", "team", "private"]),
-  embargoDetected: z136.boolean().default(false),
-  suggestedTags: z136.array(z136.string()).default([])
+  privacyRecommendation: z137.enum(["public", "team", "private"]),
+  embargoDetected: z137.boolean().default(false),
+  suggestedTags: z137.array(z137.string()).default([])
 });
 
+// ../../b4m-core/packages/services/dist/src/llm/ChatCompletion.js
+import { z as z139 } from "zod";
+
+// ../../b4m-core/packages/services/dist/src/llm/ChatCompletionInvoke.js
+import { fromZodError } from "zod-validation-error";
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/toolManager.js
+var BUILT_IN_TOOL_SET = new Set(b4mLLMTools.options);
+
 // ../../b4m-core/packages/services/dist/src/llm/tools/ToolCacheManager.js
 var DEFAULT_CONFIG = {
   ttl: 5 * 60 * 1e3,
@@ -6768,17 +7024,17 @@ var rechartsTool = {
 };
 
 // ../../b4m-core/packages/services/dist/src/llm/tools/implementation/editFile/index.js
-import { z as z137 } from "zod";
+import { z as z138 } from "zod";
 import { diffLines as diffLines2 } from "diff";
-var editFileSchema = z137.object({
-  fileId: z137.string().describe("The ID of the file to edit"),
-  instruction: z137.string().describe("Natural language instruction describing the changes to make"),
-  selection: z137.object({
-    start: z137.number().describe("Starting character position of the selection"),
-    end: z137.number().describe("Ending character position of the selection")
+var editFileSchema = z138.object({
+  fileId: z138.string().describe("The ID of the file to edit"),
+  instruction: z138.string().describe("Natural language instruction describing the changes to make"),
+  selection: z138.object({
+    start: z138.number().describe("Starting character position of the selection"),
+    end: z138.number().describe("Ending character position of the selection")
   }).optional().describe("Optional selection range to edit within the file"),
-  preserveFormatting: z137.boolean().optional().default(true).describe("Whether to preserve the original formatting style"),
-  returnDiff: z137.boolean().optional().default(true).describe("Whether to return a diff of the changes")
+  preserveFormatting: z138.boolean().optional().default(true).describe("Whether to preserve the original formatting style"),
+  returnDiff: z138.boolean().optional().default(true).describe("Whether to return a diff of the changes")
 });
 function generateSimpleDiff(original, modified) {
   const differences = diffLines2(original, modified);
@@ -10088,149 +10344,144 @@ var generateMcpTools = async (mcpData) => {
 import throttle2 from "lodash/throttle.js";
 
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionFeatures.js
-import { z as z138 } from "zod";
 import uniq4 from "lodash/uniq.js";
-var QuestStartBodySchema = z138.object({
-  userId: z138.string(),
-  sessionId: z138.string(),
-  questId: z138.string(),
-  message: z138.string(),
-  messageFileIds: z138.array(z138.string()),
-  historyCount: z138.number(),
-  fabFileIds: z138.array(z138.string()),
+
+// ../../b4m-core/packages/services/dist/src/llm/StatusManager.js
+import throttle from "lodash/throttle.js";
+
+// ../../b4m-core/packages/services/dist/src/llm/ChatCompletionProcess.js
+var DISABLE_SERVER_THROTTLING = process.env.DISABLE_SERVER_THROTTLING === "true";
+var questSaveMutex = new Mutex();
+
+// ../../b4m-core/packages/services/dist/src/llm/ChatCompletion.js
+var QuestStartBodySchema = z139.object({
+  userId: z139.string(),
+  sessionId: z139.string(),
+  questId: z139.string(),
+  message: z139.string(),
+  messageFileIds: z139.array(z139.string()),
+  historyCount: z139.number(),
+  fabFileIds: z139.array(z139.string()),
   params: ChatCompletionCreateInputSchema,
   dashboardParams: DashboardParamsSchema.optional(),
-  enableQuestMaster: z138.boolean().optional(),
-  enableMementos: z138.boolean().optional(),
-  enableArtifacts: z138.boolean().optional(),
-  enableAgents: z138.boolean().optional(),
+  enableQuestMaster: z139.boolean().optional(),
+  enableMementos: z139.boolean().optional(),
+  enableArtifacts: z139.boolean().optional(),
+  enableAgents: z139.boolean().optional(),
   promptMeta: PromptMetaZodSchema,
-  tools: z138.array(z138.union([b4mLLMTools, z138.string()])).optional(),
-  mcpServers: z138.array(z138.string()).optional(),
-  projectId: z138.string().optional(),
-  organizationId: z138.string().nullable().optional(),
+  tools: z139.array(z139.union([b4mLLMTools, z139.string()])).optional(),
+  mcpServers: z139.array(z139.string()).optional(),
+  projectId: z139.string().optional(),
+  organizationId: z139.string().nullable().optional(),
   questMaster: QuestMasterParamsSchema.optional(),
-  toolPromptId: z138.string().optional(),
+  toolPromptId: z139.string().optional(),
   researchMode: ResearchModeParamsSchema.optional(),
-  fallbackModel: z138.string().optional(),
-  embeddingModel: z138.string().optional(),
-  queryComplexity: z138.string(),
+  fallbackModel: z139.string().optional(),
+  embeddingModel: z139.string().optional(),
+  queryComplexity: z139.string(),
   imageConfig: GenerateImageToolCallSchema.optional(),
-  deepResearchConfig: z138.object({
-    maxDepth: z138.number().optional(),
-    duration: z138.number().optional(),
+  deepResearchConfig: z139.object({
+    maxDepth: z139.number().optional(),
+    duration: z139.number().optional(),
     // Note: searchers are passed via ToolContext and not through this API schema
-    searchers: z138.array(z138.any()).optional()
+    searchers: z139.array(z139.any()).optional()
   }).optional(),
-  extraContextMessages: z138.array(z138.object({
-    role: z138.enum(["user", "assistant", "system", "function", "tool"]),
-    content: z138.union([z138.string(), z138.array(z138.any())]),
-    fabFileIds: z138.array(z138.string()).optional()
+  extraContextMessages: z139.array(z139.object({
+    role: z139.enum(["user", "assistant", "system", "function", "tool"]),
+    content: z139.union([z139.string(), z139.array(z139.any())]),
+    fabFileIds: z139.array(z139.string()).optional()
   })).optional(),
   /** User's timezone (IANA format, e.g., "America/New_York") */
-  timezone: z138.string().optional()
+  timezone: z139.string().optional()
 });
 
-// ../../b4m-core/packages/services/dist/src/llm/StatusManager.js
-import throttle from "lodash/throttle.js";
-
-// ../../b4m-core/packages/services/dist/src/llm/ChatCompletionProcess.js
-var DISABLE_SERVER_THROTTLING = process.env.DISABLE_SERVER_THROTTLING === "true";
-var questSaveMutex = new Mutex();
-
-// ../../b4m-core/packages/services/dist/src/llm/ChatCompletionInvoke.js
-import { fromZodError } from "zod-validation-error";
-
-// ../../b4m-core/packages/services/dist/src/llm/tools/toolManager.js
-var BUILT_IN_TOOL_SET = new Set(b4mLLMTools.options);
-
 // ../../b4m-core/packages/services/dist/src/llm/ImageGeneration.js
 import axios8 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer4 } from "file-type";
 import { v4 as uuidv47 } from "uuid";
-import { z as z139 } from "zod";
+import { z as z140 } from "zod";
 import { fromZodError as fromZodError2 } from "zod-validation-error";
 var ImageGenerationBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z139.string(),
-  questId: z139.string(),
-  userId: z139.string(),
-  prompt: z139.string(),
-  organizationId: z139.string().nullable().optional(),
-  safety_tolerance: z139.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
-  prompt_upsampling: z139.boolean().optional().default(false),
-  seed: z139.number().nullable().optional(),
-  output_format: z139.enum(["jpeg", "png"]).nullable().optional().default("png"),
-  width: z139.number().optional(),
-  height: z139.number().optional(),
-  aspect_ratio: z139.string().optional(),
-  fabFileIds: z139.array(z139.string()).optional()
+  sessionId: z140.string(),
+  questId: z140.string(),
+  userId: z140.string(),
+  prompt: z140.string(),
+  organizationId: z140.string().nullable().optional(),
+  safety_tolerance: z140.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
+  prompt_upsampling: z140.boolean().optional().default(false),
+  seed: z140.number().nullable().optional(),
+  output_format: z140.enum(["jpeg", "png"]).nullable().optional().default("png"),
+  width: z140.number().optional(),
+  height: z140.number().optional(),
+  aspect_ratio: z140.string().optional(),
+  fabFileIds: z140.array(z140.string()).optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/VideoGeneration.js
 import axios9 from "axios";
 import { v4 as uuidv48 } from "uuid";
-import { z as z140 } from "zod";
+import { z as z141 } from "zod";
 import { fromZodError as fromZodError3 } from "zod-validation-error";
-var VideoGenerationBodySchema = z140.object({
-  sessionId: z140.string(),
-  questId: z140.string(),
-  userId: z140.string(),
-  prompt: z140.string(),
-  model: z140.nativeEnum(VideoModels).default(VideoModels.SORA_2),
-  seconds: z140.union([z140.literal(4), z140.literal(8), z140.literal(12)]).default(4),
-  size: z140.enum(["720x1280", "1280x720", "1024x1792", "1792x1024"]).default(VIDEO_SIZE_CONSTRAINTS.SORA.defaultSize),
-  organizationId: z140.string().nullable().optional()
+var VideoGenerationBodySchema = z141.object({
+  sessionId: z141.string(),
+  questId: z141.string(),
+  userId: z141.string(),
+  prompt: z141.string(),
+  model: z141.nativeEnum(VideoModels).default(VideoModels.SORA_2),
+  seconds: z141.union([z141.literal(4), z141.literal(8), z141.literal(12)]).default(4),
+  size: z141.enum(["720x1280", "1280x720", "1024x1792", "1792x1024"]).default(VIDEO_SIZE_CONSTRAINTS.SORA.defaultSize),
+  organizationId: z141.string().nullable().optional()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/ImageEdit.js
 import axios10 from "axios";
 import { fileTypeFromBuffer as fileTypeFromBuffer5 } from "file-type";
 import { v4 as uuidv49 } from "uuid";
-import { z as z141 } from "zod";
+import { z as z142 } from "zod";
 import { fromZodError as fromZodError4 } from "zod-validation-error";
 var ImageEditBodySchema = OpenAIImageGenerationInput.extend({
-  sessionId: z141.string(),
-  questId: z141.string(),
-  userId: z141.string(),
-  prompt: z141.string(),
-  organizationId: z141.string().nullable().optional(),
-  safety_tolerance: z141.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
-  prompt_upsampling: z141.boolean().optional().default(false),
-  seed: z141.number().nullable().optional(),
-  output_format: z141.enum(["jpeg", "png"]).optional().default("png"),
-  width: z141.number().optional(),
-  height: z141.number().optional(),
-  aspect_ratio: z141.string().optional(),
-  size: z141.string().optional(),
-  fabFileIds: z141.array(z141.string()).optional(),
-  image: z141.string()
+  sessionId: z142.string(),
+  questId: z142.string(),
+  userId: z142.string(),
+  prompt: z142.string(),
+  organizationId: z142.string().nullable().optional(),
+  safety_tolerance: z142.number().min(BFL_SAFETY_TOLERANCE.MIN).max(BFL_SAFETY_TOLERANCE.MAX).optional().default(BFL_SAFETY_TOLERANCE.DEFAULT),
+  prompt_upsampling: z142.boolean().optional().default(false),
+  seed: z142.number().nullable().optional(),
+  output_format: z142.enum(["jpeg", "png"]).optional().default("png"),
+  width: z142.number().optional(),
+  height: z142.number().optional(),
+  aspect_ratio: z142.string().optional(),
+  size: z142.string().optional(),
+  fabFileIds: z142.array(z142.string()).optional(),
+  image: z142.string()
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/refineText.js
-import { z as z142 } from "zod";
-var refineTextLLMSchema = z142.object({
-  text: z142.string(),
-  context: z142.string().optional()
+import { z as z143 } from "zod";
+var refineTextLLMSchema = z143.object({
+  text: z143.string(),
+  context: z143.string().optional()
   // tone: z.enum(['formal', 'informal', 'neutral']).optional(),
   // style: z.enum(['technical', 'creative', 'academic', 'business', 'narrative']).optional(),
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/MementoEvaluationService.js
-import { z as z143 } from "zod";
-var SingleMementoEvalSchema = z143.object({
-  importance: z143.number().min(1).max(10),
+import { z as z144 } from "zod";
+var SingleMementoEvalSchema = z144.object({
+  importance: z144.number().min(1).max(10),
   // 1-10 scale for personal info importance
-  summary: z143.string(),
-  tags: z143.array(z143.string()).optional()
+  summary: z144.string(),
+  tags: z144.array(z144.string()).optional()
 });
-var MementoEvalResponseSchema = z143.object({
-  isPersonal: z143.boolean(),
-  mementos: z143.array(SingleMementoEvalSchema).optional()
+var MementoEvalResponseSchema = z144.object({
+  isPersonal: z144.boolean(),
+  mementos: z144.array(SingleMementoEvalSchema).optional()
   // Array of distinct personal information
 });
 
 // ../../b4m-core/packages/services/dist/src/llm/SmallLLMService.js
-import { z as z144 } from "zod";
+import { z as z145 } from "zod";
 
 // ../../b4m-core/packages/services/dist/src/auth/AccessTokenGeneratorService.js
 import jwt2 from "jsonwebtoken";
@@ -10522,7 +10773,7 @@ function buildHookContext(params) {
 }
 
 // src/agents/types.ts
-import { z as z145 } from "zod";
+import { z as z146 } from "zod";
 var HookBlockedError = class extends Error {
   constructor(toolName, reason) {
     super(`Hook blocked execution of ${toolName}: ${reason || "No reason provided"}`);
@@ -10534,39 +10785,39 @@ var ALWAYS_DENIED_FOR_AGENTS = [
   "agent_delegate"
   // No agent chaining
 ];
-var CommandHookSchema = z145.object({
-  type: z145.literal("command"),
-  command: z145.string().min(1, "Command is required for command hooks"),
-  timeout: z145.number().optional()
-});
-var PromptHookSchema = z145.object({
-  type: z145.literal("prompt"),
-  prompt: z145.string().min(1, "Prompt is required for prompt hooks"),
-  timeout: z145.number().optional()
-});
-var HookDefinitionSchema = z145.discriminatedUnion("type", [CommandHookSchema, PromptHookSchema]);
-var HookMatcherSchema = z145.object({
-  matcher: z145.string().optional(),
-  hooks: z145.array(HookDefinitionSchema)
-});
-var AgentHooksSchema = z145.object({
-  PreToolUse: z145.array(HookMatcherSchema).optional(),
-  PostToolUse: z145.array(HookMatcherSchema).optional(),
-  PostToolUseFailure: z145.array(HookMatcherSchema).optional(),
-  Stop: z145.array(HookMatcherSchema).optional()
+var CommandHookSchema = z146.object({
+  type: z146.literal("command"),
+  command: z146.string().min(1, "Command is required for command hooks"),
+  timeout: z146.number().optional()
+});
+var PromptHookSchema = z146.object({
+  type: z146.literal("prompt"),
+  prompt: z146.string().min(1, "Prompt is required for prompt hooks"),
+  timeout: z146.number().optional()
+});
+var HookDefinitionSchema = z146.discriminatedUnion("type", [CommandHookSchema, PromptHookSchema]);
+var HookMatcherSchema = z146.object({
+  matcher: z146.string().optional(),
+  hooks: z146.array(HookDefinitionSchema)
+});
+var AgentHooksSchema = z146.object({
+  PreToolUse: z146.array(HookMatcherSchema).optional(),
+  PostToolUse: z146.array(HookMatcherSchema).optional(),
+  PostToolUseFailure: z146.array(HookMatcherSchema).optional(),
+  Stop: z146.array(HookMatcherSchema).optional()
 }).optional();
-var AgentFrontmatterSchema = z145.object({
-  description: z145.string().min(1, "Agent description is required"),
-  model: z145.string().optional(),
-  "allowed-tools": z145.array(z145.string()).optional(),
-  "denied-tools": z145.array(z145.string()).optional(),
-  "max-iterations": z145.object({
-    quick: z145.number().int().positive().optional(),
-    medium: z145.number().int().positive().optional(),
-    very_thorough: z145.number().int().positive().optional()
+var AgentFrontmatterSchema = z146.object({
+  description: z146.string().min(1, "Agent description is required"),
+  model: z146.string().optional(),
+  "allowed-tools": z146.array(z146.string()).optional(),
+  "denied-tools": z146.array(z146.string()).optional(),
+  "max-iterations": z146.object({
+    quick: z146.number().int().positive().optional(),
+    medium: z146.number().int().positive().optional(),
+    very_thorough: z146.number().int().positive().optional()
   }).optional(),
-  "default-thoroughness": z145.enum(["quick", "medium", "very_thorough"]).optional(),
-  variables: z145.record(z145.string()).optional(),
+  "default-thoroughness": z146.enum(["quick", "medium", "very_thorough"]).optional(),
+  variables: z146.record(z146.string()).optional(),
   hooks: AgentHooksSchema
 });
 var DEFAULT_MAX_ITERATIONS = {
@@ -10877,67 +11128,6 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
   return { tools: tools2, agentContext };
 }
 
-// src/config/toolSafety.ts
-import { z as z146 } from "zod";
-var ToolCategorySchema = z146.enum([
-  "auto_approve",
-  // Safe tools that run automatically without permission
-  "prompt_always",
-  // Dangerous tools that ALWAYS require permission (cannot be trusted)
-  "prompt_default"
-  // Tools that prompt by default but can be trusted
-]);
-var ToolSafetyConfigSchema = z146.object({
-  categories: z146.record(z146.string(), ToolCategorySchema),
-  trustedTools: z146.array(z146.string())
-});
-var DEFAULT_TOOL_CATEGORIES = {
-  // ===== AUTO APPROVE (Safe tools) =====
-  // These tools have no side effects and are always safe to execute
-  math_evaluate: "auto_approve",
-  current_datetime: "auto_approve",
-  dice_roll: "auto_approve",
-  prompt_enhancement: "auto_approve",
-  weather_info: "prompt_default",
-  // ===== PROMPT ALWAYS (Dangerous tools) =====
-  // These tools can modify files, execute code, or have other dangerous side effects
-  // They ALWAYS require permission and cannot be trusted automatically
-  edit_file: "prompt_always",
-  edit_local_file: "prompt_always",
-  create_file: "prompt_always",
-  delete_file: "prompt_always",
-  shell_execute: "prompt_always",
-  bash_execute: "prompt_always",
-  git_commit: "prompt_always",
-  git_push: "prompt_always",
-  // ===== PROMPT DEFAULT (Repository read tools) =====
-  // These tools read from the repository but don't modify anything
-  // Users can trust them if they want to avoid prompts
-  web_search: "prompt_default",
-  deep_research: "prompt_default",
-  file_read: "prompt_default",
-  grep_search: "prompt_default",
-  glob_files: "prompt_default",
-  get_file_tree: "prompt_default",
-  git_status: "prompt_default",
-  git_diff: "prompt_default",
-  git_log: "prompt_default",
-  git_branch: "prompt_default"
-};
-function getToolCategory(toolName, customCategories) {
-  if (customCategories && toolName in customCategories) {
-    return customCategories[toolName];
-  }
-  if (toolName in DEFAULT_TOOL_CATEGORIES) {
-    return DEFAULT_TOOL_CATEGORIES[toolName];
-  }
-  return "prompt_default";
-}
-function canTrustTool(toolName, customCategories) {
-  const category = getToolCategory(toolName, customCategories);
-  return category !== "prompt_always";
-}
-
 // src/utils/PermissionManager.ts
 var PermissionManager = class {
   constructor(trustedTools = [], customCategories, deniedTools) {
@@ -12509,7 +12699,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.24-feat-pr-files-diff-tools.18476+a439e5cc8",
+  version: "0.2.24-feat-parallel-tool-execution.18470+d8da60d93",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -12617,10 +12807,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.47.1-feat-pr-files-diff-tools.18476+a439e5cc8",
-    "@bike4mind/mcp": "1.27.1-feat-pr-files-diff-tools.18476+a439e5cc8",
-    "@bike4mind/services": "2.45.1-feat-pr-files-diff-tools.18476+a439e5cc8",
-    "@bike4mind/utils": "2.3.3-feat-pr-files-diff-tools.18476+a439e5cc8",
+    "@bike4mind/common": "2.47.1-feat-parallel-tool-execution.18470+d8da60d93",
+    "@bike4mind/mcp": "1.27.1-feat-parallel-tool-execution.18470+d8da60d93",
+    "@bike4mind/services": "2.45.1-feat-parallel-tool-execution.18470+d8da60d93",
+    "@bike4mind/utils": "2.3.3-feat-parallel-tool-execution.18470+d8da60d93",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -12637,7 +12827,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "a439e5cc8e3193b0aa90c0a58da1b5ca6e3ea539"
+  gitHead: "d8da60d93ecc5623c4d068a78b391a1f19352cdb"
 };
 
 // src/config/constants.ts
@@ -12756,7 +12946,9 @@ var SubagentOrchestrator = class {
     let result;
     try {
       result = await agent.run(task, {
-        maxIterations
+        maxIterations,
+        parallelExecution: this.deps.enableParallelToolExecution === true,
+        isReadOnlyTool
       });
     } catch (error) {
       if (error instanceof HookBlockedError) {
@@ -13956,7 +14148,8 @@ function CliApp() {
         showPermissionPrompt: promptFn,
         configStore: state.configStore,
         apiClient,
-        agentStore
+        agentStore,
+        enableParallelToolExecution: config.preferences.enableParallelToolExecution === true
       });
       const agentDelegateTool = createAgentDelegateTool(orchestrator, agentStore, newSession.id);
       const todoStore = createTodoStore();
@@ -14156,9 +14349,12 @@ ${contextResult.mergedContent}` : "";
         role: msg.role,
         content: msg.content
       }));
+      const cliConfig = await state.configStore.get();
       const result = await state.agent.run(messageContent, {
         previousMessages: previousMessages.length > 0 ? previousMessages : void 0,
-        signal: abortController.signal
+        signal: abortController.signal,
+        parallelExecution: cliConfig.preferences.enableParallelToolExecution === true,
+        isReadOnlyTool
       });
       const permissionDenied = result.finalAnswer.startsWith("Permission denied for tool");
       if (permissionDenied) {
@@ -14359,9 +14555,12 @@ ${contextResult.mergedContent}` : "";
         role: msg.role,
         content: msg.content
       }));
+      const cliConfig = await state.configStore.get();
       const result = await state.agent.run(messageContent, {
         previousMessages: previousMessages.length > 0 ? previousMessages : void 0,
-        signal: abortController.signal
+        signal: abortController.signal,
+        parallelExecution: cliConfig.preferences.enableParallelToolExecution === true,
+        isReadOnlyTool
       });
       const permissionDenied = result.finalAnswer.startsWith("Permission denied for tool");
       if (permissionDenied) {