@bike4mind/cli 0.2.1-quest-file-uploads.17007 → 0.2.3-feat-questmaster-gpt5-function-calling.17055

package/dist/{chunk-QXGU6KYI.js → chunk-44WCHZA2.js}

@@ -6,7 +6,7 @@ import {
   getSettingsByNames,
   obfuscateApiKey,
   secureParameters
-} from "./chunk-U3GPYBTD.js";
+} from "./chunk-NH74I6GX.js";
 import {
   ApiKeyType,
   MementoTier,

package/dist/{chunk-F3ETXO5N.js → chunk-KDBSH6HC.js}

@@ -7,7 +7,7 @@ import {
   getSettingsMap,
   getSettingsValue,
   secureParameters
-} from "./chunk-U3GPYBTD.js";
+} from "./chunk-NH74I6GX.js";
 import {
   KnowledgeType,
   SupportedFabFileMimeTypes

package/dist/{chunk-U3GPYBTD.js → chunk-NH74I6GX.js}

@@ -610,6 +610,10 @@ var AnthropicBackend = class {
                   }
                   if (collectedContent[event.index] && collectedContent[event.index].type === "tool_use") {
                   }
+                } else if ("delta" in event && event.delta.type === "signature_delta") {
+                  if (collectedContent[event.index] && collectedContent[event.index].type === "thinking") {
+                    collectedContent[event.index].signature = event.delta.signature;
+                  }
                 }
               } else if (event.type === "content_block_stop") {
                 if (isInThinkingBlock) {
@@ -792,14 +796,11 @@ var AnthropicBackend = class {
   }
   pushToolMessages(messages, tool, result, previousMessage) {
     if (this.isThinkingEnabled && this.lastAssistantContent.length > 0) {
-      const contentWithoutThinking = this.lastAssistantContent.filter((block) => {
-        return block.type !== "thinking";
-      });
       messages.push({
         role: "assistant",
-        content: contentWithoutThinking
+        content: this.lastAssistantContent
       });
-      this.logger.debug(`[AnthropicBackend] Filtered thinking blocks from assistant content. Original: ${this.lastAssistantContent.length} blocks, Filtered: ${contentWithoutThinking.length} blocks`);
+      this.logger.debug(`[AnthropicBackend] Including ${this.lastAssistantContent.length} content blocks (thinking + tool_use) in assistant message`);
     } else {
       messages.push({
         role: "assistant",
@@ -1118,8 +1119,12 @@ var BaseBedrockBackend = class {
         await callback(streamedText, { inputTokens, outputTokens, toolsUsed });
       }
     } catch (error) {
-      console.error(`[BaseBedrockBackend] Error invoking model ${model}:`, error);
       if (error instanceof Error) {
+        if (error.message.includes("aborted")) {
+          console.log("[BaseBedrockBackend] Request aborted, skipping error logging");
+          throw error;
+        }
+        console.error(`[BaseBedrockBackend] Error invoking model ${model}:`, error);
         console.error(`[BaseBedrockBackend] Error details:`, {
           name: error.name,
           message: error.message,
@@ -4107,6 +4112,12 @@ var OpenAIBackend = class {
     }
     if (options.tools?.length) {
       parameters.tools = this.formatTools(options.tools);
+      if (options.tool_choice) {
+        parameters.tool_choice = options.tool_choice;
+      }
+      if (options.parallel_tool_calls !== void 0) {
+        parameters.parallel_tool_calls = options.parallel_tool_calls;
+      }
     }
     const response = await this._api.chat.completions.create(parameters, {
       signal: options.abortSignal
@@ -7973,6 +7984,147 @@ function extractQuestMasterData(reply, options = {}) {
   return questMasterData;
 }
 
+// ../../b4m-core/packages/utils/dist/src/questMasterToolSchema.js
+var GPT5_MODELS_WITH_TOOL_SUPPORT = [
+  ChatModels.GPT5,
+  ChatModels.GPT5_MINI,
+  ChatModels.GPT5_NANO,
+  ChatModels.GPT5_1,
+  ChatModels.GPT5_2
+];
+function isGPT5ModelWithToolSupport(model) {
+  return GPT5_MODELS_WITH_TOOL_SUPPORT.includes(model);
+}
+var createQuestPlanToolSchema = {
+  name: "create_quest_plan",
+  description: `Break down a user request into a structured quest plan with actionable tasks.
+
+GUIDELINES:
+- Analyze the user's request and create 3-7 main quests
+- Each quest must have 2-5 specific, actionable subquests
+- Quest titles should be clear and action-oriented (e.g., "Set up database schema" not "Step 1")
+- Provide detailed descriptions for each quest
+- Assess complexity accurately: Easy (< 1 hour), Medium (1-4 hours), Hard (> 4 hours)
+- Generate 2-5 relevant tags categorizing the work (e.g., "web-development", "database", "api")
+
+ALWAYS call this function to respond. Do NOT respond with plain text.`,
+  parameters: {
+    type: "object",
+    properties: {
+      goal: {
+        type: "string",
+        description: "The overall objective the user wants to achieve"
+      },
+      tags: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Categories for this quest (e.g., "web-development", "api", "database")'
+      },
+      quests: {
+        type: "array",
+        description: "The main quests (3-7) that break down the goal",
+        items: {
+          type: "object",
+          properties: {
+            id: {
+              type: "string",
+              description: 'Unique identifier (e.g., "quest-1", "setup-database")'
+            },
+            title: {
+              type: "string",
+              description: 'Clear, action-oriented title (e.g., "Configure authentication middleware")'
+            },
+            description: {
+              type: "string",
+              description: "Detailed explanation of what needs to be done and why"
+            },
+            complexity: {
+              type: "string",
+              enum: ["Easy", "Medium", "Hard"],
+              description: "Difficulty assessment based on effort required"
+            },
+            subQuests: {
+              type: "array",
+              description: "Concrete subtasks (2-5) within this quest",
+              items: {
+                type: "object",
+                properties: {
+                  id: {
+                    type: "string",
+                    description: "Unique identifier for the subquest"
+                  },
+                  title: {
+                    type: "string",
+                    description: "Specific, actionable subtask title"
+                  }
+                },
+                required: ["id", "title"]
+              }
+            }
+          },
+          required: ["id", "title", "description", "complexity", "subQuests"]
+        }
+      }
+    },
+    required: ["goal", "quests"]
+  }
+};
+function parseQuestPlanFunctionCall(args) {
+  let parsed;
+  try {
+    parsed = JSON.parse(args);
+  } catch (e) {
+    throw new Error(`Failed to parse function call arguments as JSON: ${e}`);
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Function call arguments must be an object");
+  }
+  const result = parsed;
+  if (!result.goal || typeof result.goal !== "string") {
+    throw new Error("Function call missing required field: goal");
+  }
+  if (!Array.isArray(result.quests)) {
+    throw new Error("Function call missing required field: quests (must be an array)");
+  }
+  if (result.quests.length === 0) {
+    throw new Error("Function call returned empty quests array");
+  }
+  for (let i = 0; i < result.quests.length; i++) {
+    const quest = result.quests[i];
+    if (!quest.id || typeof quest.id !== "string") {
+      throw new Error(`Quest ${i} missing required field: id`);
+    }
+    if (!quest.title || typeof quest.title !== "string") {
+      throw new Error(`Quest ${i} missing required field: title`);
+    }
+    if (!quest.description || typeof quest.description !== "string") {
+      throw new Error(`Quest ${i} missing required field: description`);
+    }
+    if (!quest.complexity || !["Easy", "Medium", "Hard"].includes(quest.complexity)) {
+      throw new Error(`Quest ${i} has invalid complexity: ${quest.complexity} (must be Easy, Medium, or Hard)`);
+    }
+    if (!Array.isArray(quest.subQuests)) {
+      throw new Error(`Quest "${quest.id}" missing required field: subQuests (must be an array)`);
+    }
+    if (quest.subQuests.length === 0) {
+      throw new Error(`Quest "${quest.id}" has no subQuests (minimum 2 required)`);
+    }
+    for (let j = 0; j < quest.subQuests.length; j++) {
+      const subQuest = quest.subQuests[j];
+      if (!subQuest.id || typeof subQuest.id !== "string") {
+        throw new Error(`Quest "${quest.id}" subQuest ${j} missing required field: id`);
+      }
+      if (!subQuest.title || typeof subQuest.title !== "string") {
+        throw new Error(`Quest "${quest.id}" subQuest ${j} missing required field: title`);
+      }
+    }
+  }
+  if (result.tags !== void 0 && !Array.isArray(result.tags)) {
+    throw new Error("Function call field tags must be an array if provided");
+  }
+  return result;
+}
+
 // ../../b4m-core/packages/utils/dist/src/questMaster.js
 var sanitizeId = (id) => {
   return id.replace(/\s+/g, "-").replace(/[^a-zA-Z0-9_.-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
@@ -8003,10 +8155,9 @@ var QuestMaster = class {
     }
     return "Easy";
   }
-  async processQuestPlan(questPlanText) {
+  async processQuestPlan(input) {
     try {
       await this.onStatusUpdate(this.quest, "Processing quest plan...");
-      this.logger.log("Processing quest plan:", questPlanText);
       const defaultResponse = {
         type: "narrative",
         meta: {
@@ -8023,135 +8174,161 @@ var QuestMaster = class {
           }
         ]
       };
-      if (!questPlanText || typeof questPlanText !== "string") {
-        this.logger.warn("Invalid questPlanText received:", questPlanText);
-        if (this.quest) {
-          this.quest.questMasterReply = JSON.stringify(defaultResponse);
-          await this.db.quests.update({
-            id: this.quest.id,
-            questMasterReply: this.quest.questMasterReply,
-            reply: null,
-            replies: [],
-            status: "done",
-            type: "message"
-          });
-        }
-        return;
-      }
       if (!this.quest) {
         throw new Error("No quest context available");
       }
-      const extracted = extractQuestMasterData(questPlanText, { logger: this.logger });
-      const metaStartTag = "<!--QuestMasterMeta";
-      const metaEndTag = "-->";
-      const metaStartIndex = questPlanText.indexOf(metaStartTag);
-      let goal = "Quest Plan";
-      let tags = [];
       let questResponse;
-      if (metaStartIndex !== -1) {
-        const metaEndIndex = questPlanText.indexOf(metaEndTag, metaStartIndex);
-        if (metaEndIndex !== -1) {
-          const metaContent = questPlanText.slice(metaStartIndex + metaStartTag.length, metaEndIndex).trim();
-          try {
-            const jsonStartIndex = metaContent.indexOf("{");
-            if (jsonStartIndex !== -1) {
-              const metaData = JSON.parse(metaContent.slice(jsonStartIndex));
-              goal = metaData.goal || goal;
-              tags = Array.isArray(metaData.tags) ? metaData.tags : [];
-            }
-          } catch (err) {
-            this.logger.error("Error parsing meta data:", err);
-          }
-        }
-      }
-      if (extracted.length > 0) {
-        this.logger.log("Successfully extracted QuestMaster data:", extracted);
-        await this.onStatusUpdate(this.quest, "Extracted QuestMaster data");
-        const validQuests = extracted.filter((quest) => quest !== null && typeof quest === "object" && quest.id && quest.title && quest.title !== "Step 1" && // Explicitly filter out generic Step 1
-        quest.description && quest.description !== "No description available");
-        if (validQuests.length === 0) {
-          throw new Error("No valid quests found after filtering");
-        }
+      if (typeof input === "object") {
+        this.logger.log("Processing quest plan from function calling result");
         questResponse = {
           type: "quest_plan",
           meta: {
-            goal,
-            totalSteps: validQuests.length,
-            tags
+            goal: input.goal,
+            totalSteps: input.quests.length,
+            tags: input.tags
           },
-          quests: validQuests.map((quest) => ({
+          quests: input.quests.map((quest) => ({
             id: quest.id,
-            // No fallback - we filtered for valid IDs
             title: quest.title,
-            // No fallback - we filtered for valid titles
             description: quest.description,
-            // No fallback - we filtered for valid descriptions
-            complexity: quest.complexity || "Medium",
+            complexity: quest.complexity,
             status: "not_started",
-            subQuests: Array.isArray(quest.subQuests) ? quest.subQuests.filter((sub) => sub && sub.id && sub.title && !sub.title.startsWith("Subtask")).map((sub) => ({
+            subQuests: quest.subQuests.map((sub) => ({
               id: sub.id,
               title: sub.title,
               status: "not_started"
-            })) : []
+            }))
           }))
         };
-        if (questResponse.quests.some((quest) => quest.subQuests.length === 0)) {
-          throw new Error("Some quests have no valid subquests after filtering");
-        }
       } else {
-        try {
-          const questPlan = JSON.parse(questPlanText);
-          if (questPlan && questPlan.questChain && Array.isArray(questPlan.questChain)) {
-            const validQuestChain = questPlan.questChain.filter((item) => item && item.quest && item.quest !== "Step 1" && item.details && item.details !== "No description available");
-            if (validQuestChain.length === 0) {
-              throw new Error("No valid quests found in quest chain");
+        const questPlanText = input;
+        this.logger.log("Processing quest plan:", questPlanText);
+        if (!questPlanText || typeof questPlanText !== "string") {
+          this.logger.warn("Invalid questPlanText received:", questPlanText);
+          if (this.quest) {
+            this.quest.questMasterReply = JSON.stringify(defaultResponse);
+            await this.db.quests.update({
+              id: this.quest.id,
+              questMasterReply: this.quest.questMasterReply,
+              reply: null,
+              replies: [],
+              status: "done",
+              type: "message"
+            });
+          }
+          return;
+        }
+        const extracted = extractQuestMasterData(questPlanText, { logger: this.logger });
+        const metaStartTag = "<!--QuestMasterMeta";
+        const metaEndTag = "-->";
+        const metaStartIndex = questPlanText.indexOf(metaStartTag);
+        let goal = "Quest Plan";
+        let tags = [];
+        if (metaStartIndex !== -1) {
+          const metaEndIndex = questPlanText.indexOf(metaEndTag, metaStartIndex);
+          if (metaEndIndex !== -1) {
+            const metaContent = questPlanText.slice(metaStartIndex + metaStartTag.length, metaEndIndex).trim();
+            try {
+              const jsonStartIndex = metaContent.indexOf("{");
+              if (jsonStartIndex !== -1) {
+                const metaData = JSON.parse(metaContent.slice(jsonStartIndex));
+                goal = metaData.goal || goal;
+                tags = Array.isArray(metaData.tags) ? metaData.tags : [];
+              }
+            } catch (err) {
+              this.logger.error("Error parsing meta data:", err);
             }
-            questResponse = {
-              type: "quest_plan",
-              meta: {
-                goal: questPlan.abstractObjective || "Process Request",
-                totalSteps: validQuestChain.length
-              },
-              quests: validQuestChain.map((item, index) => ({
-                id: `quest-${index + 1}`,
-                title: item.quest,
-                description: item.details,
-                complexity: this.determineComplexity(item.details),
-                status: "Not Started",
-                subQuests: []
-                // This will trigger a retry since we require subquests
-              }))
-            };
-          } else {
-            if (!questPlanText.trim() || questPlanText.trim() === "Step 1") {
-              throw new Error("Empty or invalid response received");
+          }
+        }
+        if (extracted.length > 0) {
+          this.logger.log("Successfully extracted QuestMaster data:", extracted);
+          await this.onStatusUpdate(this.quest, "Extracted QuestMaster data");
+          const validQuests = extracted.filter((quest) => quest !== null && typeof quest === "object" && quest.id && quest.title && quest.title !== "Step 1" && // Explicitly filter out generic Step 1
+          quest.description && quest.description !== "No description available");
+          if (validQuests.length === 0) {
+            throw new Error("No valid quests found after filtering");
+          }
+          questResponse = {
+            type: "quest_plan",
+            meta: {
+              goal,
+              totalSteps: validQuests.length,
+              tags
+            },
+            quests: validQuests.map((quest) => ({
+              id: quest.id,
+              // No fallback - we filtered for valid IDs
+              title: quest.title,
+              // No fallback - we filtered for valid titles
+              description: quest.description,
+              // No fallback - we filtered for valid descriptions
+              complexity: quest.complexity || "Medium",
+              status: "not_started",
+              subQuests: Array.isArray(quest.subQuests) ? quest.subQuests.filter((sub) => sub && sub.id && sub.title && !sub.title.startsWith("Subtask")).map((sub) => ({
+                id: sub.id,
+                title: sub.title,
+                status: "not_started"
+              })) : []
+            }))
+          };
+          if (questResponse.quests.some((quest) => quest.subQuests.length === 0)) {
+            throw new Error("Some quests have no valid subquests after filtering");
+          }
+        } else {
+          try {
+            const questPlan = JSON.parse(questPlanText);
+            if (questPlan && questPlan.questChain && Array.isArray(questPlan.questChain)) {
+              const validQuestChain = questPlan.questChain.filter((item) => item && item.quest && item.quest !== "Step 1" && item.details && item.details !== "No description available");
+              if (validQuestChain.length === 0) {
+                throw new Error("No valid quests found in quest chain");
+              }
+              questResponse = {
+                type: "quest_plan",
+                meta: {
+                  goal: questPlan.abstractObjective || "Process Request",
+                  totalSteps: validQuestChain.length
+                },
+                quests: validQuestChain.map((item, index) => ({
+                  id: `quest-${index + 1}`,
+                  title: item.quest,
+                  description: item.details,
+                  complexity: this.determineComplexity(item.details),
+                  status: "Not Started",
+                  subQuests: []
+                  // This will trigger a retry since we require subquests
+                }))
+              };
+            } else {
+              if (!questPlanText.trim() || questPlanText.trim() === "Step 1") {
+                throw new Error("Empty or invalid response received");
+              }
+              questResponse = {
+                type: "narrative",
+                meta: {
+                  goal: "Direct Response",
+                  totalSteps: 1
+                },
+                quests: [
+                  {
+                    id: "narrative-1",
+                    title: "Process Response",
+                    description: questPlanText.trim(),
+                    complexity: "Medium",
+                    subQuests: [
+                      {
+                        id: "narrative-1-1",
+                        title: "Review Response",
+                        status: "not_started"
+                      }
+                    ]
+                  }
+                ]
+              };
             }
-            questResponse = {
-              type: "narrative",
-              meta: {
-                goal: "Direct Response",
-                totalSteps: 1
-              },
-              quests: [
-                {
-                  id: "narrative-1",
-                  title: "Process Response",
-                  description: questPlanText.trim(),
-                  complexity: "Medium",
-                  subQuests: [
-                    {
-                      id: "narrative-1-1",
-                      title: "Review Response",
-                      status: "not_started"
-                    }
-                  ]
-                }
-              ]
-            };
+          } catch (parseError) {
+            this.logger.error("Error parsing quest plan JSON:", parseError);
+            questResponse = defaultResponse;
           }
-        } catch (parseError) {
-          this.logger.error("Error parsing quest plan JSON:", parseError);
-          questResponse = defaultResponse;
         }
       }
       if (!this.validateQuestResponse(questResponse)) {
@@ -8351,9 +8528,102 @@ var QuestMaster = class {
 }
 -->`;
   }
+  /**
+   * Create a quest plan using GPT-5's function calling feature.
+   * This method is used when the model is a GPT-5 variant that supports tools
+   * but doesn't reliably follow HTML comment formatting.
+   *
+   * @param model - The GPT-5 model to use
+   * @param prompt - The user's request to break down into quests
+   * @returns The parsed quest plan result
+   */
+  async createQuestPlanWithFunctionCalling(model, prompt, retryCount = 0) {
+    const MAX_RETRIES = 2;
+    const messages = [
+      {
+        role: "system",
+        content: `You are the QuestMaster, an AI agent that breaks down complex tasks into manageable quests.
+
+When given a user request, you MUST call the create_quest_plan function to structure your response.
+Do NOT respond with plain text - ALWAYS use the function call.
+
+Guidelines:
+- Break down complex tasks into 3-7 main quests
+- Each quest needs 2-5 specific, actionable subquests
+- Make titles clear and action-oriented (e.g., "Set up database schema" not "Step 1")
+- Provide detailed descriptions explaining what needs to be done
+- Assess complexity accurately: Easy (< 1 hour), Medium (1-4 hours), Hard (> 4 hours)
+- Generate 2-5 relevant tags categorizing the work`
+      },
+      { role: "user", content: prompt }
+    ];
+    const toolDef = {
+      toolFn: async (params) => JSON.stringify(params),
+      // Not executed, just captured
+      toolSchema: createQuestPlanToolSchema
+    };
+    const options = {
+      temperature: retryCount > 0 ? 0.7 : 0.9,
+      // Lower temperature on retries
+      n: 1,
+      stream: false,
+      tools: [toolDef],
+      executeTools: false,
+      // Don't execute, just capture the function call
+      tool_choice: { type: "function", function: { name: "create_quest_plan" } },
+      // Force function call
+      parallel_tool_calls: false
+      // Required for structured outputs
+    };
+    let functionResult = null;
+    let lastError = null;
+    try {
+      await this.llm.complete(model, messages, options, async (text, completionInfo) => {
+        if (completionInfo?.toolsUsed?.length) {
+          const toolCall = completionInfo.toolsUsed[0];
+          if (toolCall.name === "create_quest_plan" && toolCall.arguments) {
+            this.logger.log("GPT-5 function call received, parsing arguments...");
+            functionResult = parseQuestPlanFunctionCall(toolCall.arguments);
+          }
+        }
+      });
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      this.logger.error("Error in GPT-5 function calling:", lastError);
+    }
+    if (!functionResult) {
+      if (retryCount < MAX_RETRIES) {
+        this.logger.warn(`GPT-5 did not return function call, retrying (attempt ${retryCount + 1}/${MAX_RETRIES})...`);
+        return this.createQuestPlanWithFunctionCalling(model, prompt, retryCount + 1);
+      }
+      throw lastError || new Error("GPT-5 did not call create_quest_plan function after retries");
+    }
+    const result = functionResult;
+    const questsWithoutSubquests = result.quests.filter((q) => !q.subQuests || q.subQuests.length === 0);
+    if (questsWithoutSubquests.length > 0 && retryCount < MAX_RETRIES) {
+      this.logger.warn(`Some quests missing subquests: ${questsWithoutSubquests.map((q) => q.id).join(", ")}, retrying...`);
+      return this.createQuestPlanWithFunctionCalling(model, prompt, retryCount + 1);
+    }
+    this.logger.log("Successfully received GPT-5 function call result:", {
+      goal: result.goal,
+      questCount: result.quests.length,
+      tags: result.tags
+    });
+    return result;
+  }
   async createQuestPlan(model, prompt) {
     try {
       await this.onStatusUpdate(this.quest, "Creating quest plan...");
+      if (isGPT5ModelWithToolSupport(model)) {
+        this.logger.log(`Using function calling approach for GPT-5 model: ${model}`);
+        try {
+          const result = await this.createQuestPlanWithFunctionCalling(model, prompt);
+          await this.processQuestPlan(result);
+          return;
+        } catch (functionCallError) {
+          this.logger.error("Function calling failed, falling back to HTML approach:", functionCallError);
+        }
+      }
       const messages = [
         {
           role: "system",
@@ -9952,7 +10222,7 @@ function shouldTriggerFallback(error) {
       return true;
     }
   }
-  if ("code" in error && error.code === "ECONNRESET") {
+  if ("code" in error && error.code === "ECONNRESET" && !message.includes("aborted")) {
     return true;
   }
   if (error.name === "TypeError" && message.includes("terminated")) {
@@ -10447,6 +10717,9 @@ export {
   sendToConnection,
   ClientMessageSender,
   OpenaiModerationsService,
+  isGPT5ModelWithToolSupport,
+  createQuestPlanToolSchema,
+  parseQuestPlanFunctionCall,
   QuestMaster,
   OpenAIImageService,
   TestImageService,

package/dist/{chunk-LZMRYJ3B.js → chunk-O2622ACK.js}

@@ -2,7 +2,7 @@
 import {
   BadRequestError,
   secureParameters
-} from "./chunk-U3GPYBTD.js";
+} from "./chunk-NH74I6GX.js";
 import {
   GenericCreditDeductTransaction,
   ImageEditUsageTransaction,
@@ -22,12 +22,20 @@ var SubtractCreditsSchema = z.discriminatedUnion("type", [
   ImageEditUsageTransaction.omit({ createdAt: true, updatedAt: true }),
   TransferCreditTransaction.omit({ createdAt: true, updatedAt: true })
 ]);
-async function subtractCredits(parameters, { db, creditHolderMethods }) {
+async function subtractCredits(parameters, { db, creditHolderMethods, skipBalanceUpdate, currentCreditHolder }) {
   const params = secureParameters(parameters, SubtractCreditsSchema);
   const { ownerId, ownerType, credits, type, description, metadata } = params;
-  const updatedEntity = await creditHolderMethods.incrementCredits(ownerId, -credits);
-  if (!updatedEntity) {
-    throw new BadRequestError("Failed to update credits");
+  let updatedEntity;
+  if (skipBalanceUpdate) {
+    if (!currentCreditHolder) {
+      throw new BadRequestError("currentCreditHolder is required when skipBalanceUpdate is true");
+    }
+    updatedEntity = currentCreditHolder;
+  } else {
+    updatedEntity = await creditHolderMethods.incrementCredits(ownerId, -credits);
+    if (!updatedEntity) {
+      throw new BadRequestError("Failed to update credits");
+    }
   }
   if (type === "generic_deduct") {
     await db.creditTransactions.createTransaction("generic_deduct", {

package/dist/{create-YUYXTEIS.js → create-LKM7JKFD.js}

@@ -2,8 +2,8 @@
 import {
   createFabFile,
   createFabFileSchema
-} from "./chunk-F3ETXO5N.js";
-import "./chunk-U3GPYBTD.js";
+} from "./chunk-KDBSH6HC.js";
+import "./chunk-NH74I6GX.js";
 import "./chunk-AMDXHL6S.js";
 import "./chunk-WR6YZRQV.js";
 import "./chunk-PDX44BCA.js";