@bike4mind/cli 0.1.2 → 0.1.4

package/dist/{chunk-B3YFSFVU.js → chunk-EVPT4ARN.js}

@@ -16,7 +16,7 @@ import {
   dayjsConfig_default,
   extractSnippetMeta,
   settingsMap
-} from "./chunk-MKO2KCCS.js";
+} from "./chunk-VVV7WLJ6.js";
 
 // ../../b4m-core/packages/utils/dist/src/storage/S3Storage.js
 import { S3Client, PutObjectCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand } from "@aws-sdk/client-s3";
@@ -1051,19 +1051,29 @@ var BaseBedrockBackend = class {
         }
         if (func.some((f) => f.name)) {
           for await (const tool of func) {
-            const { id, name, parameters } = tool;
-            const toolFn = options.tools?.find((tool2) => tool2.toolSchema.name === name)?.toolFn;
-            if (id && name && parameters && toolFn) {
-              const result = await toolFn(JSON.parse(parameters));
+            const { name, parameters } = tool;
+            if (name && parameters) {
               toolsUsed.push({ name, arguments: parameters });
-              await handleToolResultStreaming(name, result, async (results) => {
-                await callback(results, { inputTokens, outputTokens, toolsUsed });
-              });
-              this.pushToolMessages(messages, { id, name, parameters }, result);
             }
           }
-          await callback(["\n\n"], { inputTokens, outputTokens, toolsUsed });
-          await this.complete(model, messages, { ...options, thinking: { enabled: false, budget_tokens: 0 } }, callback, toolsUsed);
+          if (options.executeTools !== false) {
+            for await (const tool of func) {
+              const { id, name, parameters } = tool;
+              const toolFn = options.tools?.find((tool2) => tool2.toolSchema.name === name)?.toolFn;
+              if (id && name && parameters && toolFn) {
+                const result = await toolFn(JSON.parse(parameters));
+                await handleToolResultStreaming(name, result, async (results) => {
+                  await callback(results, { inputTokens, outputTokens, toolsUsed });
+                });
+                this.pushToolMessages(messages, { id, name, parameters }, result);
+              }
+            }
+            await callback(["\n\n"], { inputTokens, outputTokens, toolsUsed });
+            await this.complete(model, messages, { ...options, thinking: { enabled: false, budget_tokens: 0 } }, callback, toolsUsed);
+          } else {
+            console.log("[BaseBedrockBackend] executeTools=false, passing tool calls to callback");
+            await callback([null], { inputTokens, outputTokens, toolsUsed });
+          }
           return;
         }
       } else {
@@ -1084,16 +1094,24 @@ var BaseBedrockBackend = class {
         const toolChoice = chunk?.choices.find((choice) => choice.statusEndReason === ChoiceEndReason.TOOL_USE);
         if (toolChoice?.tool) {
           const { id, name, parameters } = toolChoice.tool;
-          const toolFn = options.tools?.find((tool) => tool.toolSchema.name === name)?.toolFn;
-          if (id && name && parameters && toolFn) {
-            const result = await toolFn(JSON.parse(parameters));
+          if (name && parameters) {
             toolsUsed.push({ name, arguments: parameters });
-            await handleToolResultStreaming(name, result, async (results) => {
-              await callback(results, { inputTokens, outputTokens, toolsUsed });
-            });
-            this.pushToolMessages(messages, { id, name, parameters }, result);
-            await callback(["\n\n"], { inputTokens, outputTokens, toolsUsed });
-            await this.complete(model, messages, { ...options, thinking: { enabled: false, budget_tokens: 0 } }, callback, toolsUsed);
+          }
+          if (options.executeTools !== false) {
+            const toolFn = options.tools?.find((tool) => tool.toolSchema.name === name)?.toolFn;
+            if (id && name && parameters && toolFn) {
+              const result = await toolFn(JSON.parse(parameters));
+              await handleToolResultStreaming(name, result, async (results) => {
+                await callback(results, { inputTokens, outputTokens, toolsUsed });
+              });
+              this.pushToolMessages(messages, { id, name, parameters }, result);
+              await callback(["\n\n"], { inputTokens, outputTokens, toolsUsed });
+              await this.complete(model, messages, { ...options, thinking: { enabled: false, budget_tokens: 0 } }, callback, toolsUsed);
+              return;
+            }
+          } else {
+            console.log("[BaseBedrockBackend] executeTools=false, passing tool calls to callback");
+            await callback([null], { inputTokens, outputTokens, toolsUsed });
             return;
           }
         }
@@ -3007,58 +3025,63 @@ var GeminiBackend = class {
         }
         if (toolCalls.length > 0 && options.tools?.length) {
           console.log("[DEBUG] Gemini executing tools immediately:", toolCalls.map((tc) => tc.name));
-          const assistantMessage = {
-            role: "assistant",
-            content: toolCalls.map((toolCall, index) => ({
-              type: "tool_use",
-              id: toolCall.id,
-              name: toolCall.name,
-              input: toolCall.parameters,
-              // Only first tool call gets thought_signature (Gemini 3 requirement for parallel calls)
-              thought_signature: index === 0 ? toolCall.thought_signature : void 0
-            }))
-          };
-          messages.push(assistantMessage);
-          for (const toolCall of toolCalls) {
-            const toolFn = options.tools.find((tool) => tool.toolSchema.name === toolCall.name)?.toolFn;
-            if (!toolFn) {
-              console.warn(`[WARN] Tool ${toolCall.name} not found`);
-              continue;
-            }
-            try {
-              const result2 = await toolFn(toolCall.parameters);
-              await handleToolResultStreaming(toolCall.name, result2, async (results) => {
-                await callback(results, { toolsUsed });
-              });
-              messages.push({
-                role: "tool",
-                content: [
-                  {
-                    type: "tool_result",
-                    content: JSON.stringify({ result: result2 }),
-                    tool_use_id: toolCall.id
-                  }
-                ]
-              });
-            } catch (error) {
-              if (error instanceof PermissionDeniedError) {
-                throw error;
+          if (options.executeTools !== false) {
+            const assistantMessage = {
+              role: "assistant",
+              content: toolCalls.map((toolCall, index) => ({
+                type: "tool_use",
+                id: toolCall.id,
+                name: toolCall.name,
+                input: toolCall.parameters,
+                // Only first tool call gets thought_signature (Gemini 3 requirement for parallel calls)
+                thought_signature: index === 0 ? toolCall.thought_signature : void 0
+              }))
+            };
+            messages.push(assistantMessage);
+            for (const toolCall of toolCalls) {
+              const toolFn = options.tools.find((tool) => tool.toolSchema.name === toolCall.name)?.toolFn;
+              if (!toolFn) {
+                console.warn(`[WARN] Tool ${toolCall.name} not found`);
+                continue;
+              }
+              try {
+                const result2 = await toolFn(toolCall.parameters);
+                await handleToolResultStreaming(toolCall.name, result2, async (results) => {
+                  await callback(results, { toolsUsed });
+                });
+                messages.push({
+                  role: "tool",
+                  content: [
+                    {
+                      type: "tool_result",
+                      content: JSON.stringify({ result: result2 }),
+                      tool_use_id: toolCall.id
+                    }
+                  ]
+                });
+              } catch (error) {
+                if (error instanceof PermissionDeniedError) {
+                  throw error;
+                }
+                console.error(`[ERROR] Error executing tool ${toolCall.name}:`, error);
+                messages.push({
+                  role: "tool",
+                  content: [
+                    {
+                      type: "tool_result",
+                      content: JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error" }),
+                      tool_use_id: toolCall.id
+                    }
+                  ]
+                });
               }
-              console.error(`[ERROR] Error executing tool ${toolCall.name}:`, error);
-              messages.push({
-                role: "tool",
-                content: [
-                  {
-                    type: "tool_result",
-                    content: JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error" }),
-                    tool_use_id: toolCall.id
-                  }
-                ]
-              });
             }
+            await callback(["\n\n"], { toolsUsed });
+            await this.complete(modelName, messages, options, callback, toolsUsed);
+          } else {
+            console.log("[DEBUG] Gemini executeTools=false, passing tool calls to callback");
+            await callback([null], { toolsUsed });
           }
-          await callback(["\n\n"], { toolsUsed });
-          await this.complete(modelName, messages, options, callback, toolsUsed);
           return;
         }
       } catch (error) {
@@ -3096,58 +3119,63 @@ var GeminiBackend = class {
     }
     if (!options.stream && toolCalls.length > 0 && options.tools?.length) {
       console.log("[DEBUG] Gemini executing tools (non-streaming mode):", toolCalls.map((tc) => tc.name));
-      const assistantMessage = {
-        role: "assistant",
-        content: toolCalls.map((toolCall, index) => ({
-          type: "tool_use",
-          id: toolCall.id,
-          name: toolCall.name,
-          input: toolCall.parameters,
-          // Only first tool call gets thought_signature (Gemini 3 requirement for parallel calls)
-          thought_signature: index === 0 ? toolCall.thought_signature : void 0
-        }))
-      };
-      messages.push(assistantMessage);
-      for (const toolCall of toolCalls) {
-        const toolFn = options.tools.find((tool) => tool.toolSchema.name === toolCall.name)?.toolFn;
-        if (!toolFn) {
-          console.warn(`[WARN] Tool ${toolCall.name} not found`);
-          continue;
-        }
-        try {
-          const result = await toolFn(toolCall.parameters);
-          await handleToolResultStreaming(toolCall.name, result, async (results) => {
-            await callback(results, { toolsUsed });
-          });
-          messages.push({
-            role: "tool",
-            content: [
-              {
-                type: "tool_result",
-                content: JSON.stringify({ result }),
-                tool_use_id: toolCall.id
-              }
-            ]
-          });
-        } catch (error) {
-          if (error instanceof PermissionDeniedError) {
-            throw error;
+      if (options.executeTools !== false) {
+        const assistantMessage = {
+          role: "assistant",
+          content: toolCalls.map((toolCall, index) => ({
+            type: "tool_use",
+            id: toolCall.id,
+            name: toolCall.name,
+            input: toolCall.parameters,
+            // Only first tool call gets thought_signature (Gemini 3 requirement for parallel calls)
+            thought_signature: index === 0 ? toolCall.thought_signature : void 0
+          }))
+        };
+        messages.push(assistantMessage);
+        for (const toolCall of toolCalls) {
+          const toolFn = options.tools.find((tool) => tool.toolSchema.name === toolCall.name)?.toolFn;
+          if (!toolFn) {
+            console.warn(`[WARN] Tool ${toolCall.name} not found`);
+            continue;
+          }
+          try {
+            const result = await toolFn(toolCall.parameters);
+            await handleToolResultStreaming(toolCall.name, result, async (results) => {
+              await callback(results, { toolsUsed });
+            });
+            messages.push({
+              role: "tool",
+              content: [
+                {
+                  type: "tool_result",
+                  content: JSON.stringify({ result }),
+                  tool_use_id: toolCall.id
+                }
+              ]
+            });
+          } catch (error) {
+            if (error instanceof PermissionDeniedError) {
+              throw error;
+            }
+            console.error(`[ERROR] Error executing tool ${toolCall.name}:`, error);
+            messages.push({
+              role: "tool",
+              content: [
+                {
+                  type: "tool_result",
+                  content: JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error" }),
+                  tool_use_id: toolCall.id
+                }
+              ]
+            });
           }
-          console.error(`[ERROR] Error executing tool ${toolCall.name}:`, error);
-          messages.push({
-            role: "tool",
-            content: [
-              {
-                type: "tool_result",
-                content: JSON.stringify({ error: error instanceof Error ? error.message : "Unknown error" }),
-                tool_use_id: toolCall.id
-              }
-            ]
-          });
         }
+        await callback(["\n\n"], { toolsUsed });
+        await this.complete(modelName, messages, options, callback, toolsUsed);
+      } else {
+        console.log("[DEBUG] Gemini executeTools=false, passing tool calls to callback");
+        await callback([null], { toolsUsed });
       }
-      await callback(["\n\n"], { toolsUsed });
-      await this.complete(modelName, messages, options, callback, toolsUsed);
     }
   }
   formatMessagesIntoGeminiContent(messages) {
@@ -4584,67 +4612,83 @@ var XAIBackend = class {
         }
         if (c.message.tool_calls && c.message.tool_calls.length > 0) {
           for (const toolCall of c.message.tool_calls) {
-            if (toolCall.type !== "function") {
+            if (toolCall.type !== "function")
               continue;
-            }
-            const toolFn = options.tools?.find((tool) => tool.toolSchema.name === toolCall.function.name)?.toolFn;
-            if (toolFn && toolCall.function.arguments) {
+            if (toolCall.function.arguments) {
               toolsUsed.push({
                 name: toolCall.function.name,
                 arguments: toolCall.function.arguments
               });
-              try {
-                const parsedParams = JSON.parse(toolCall.function.arguments);
-                const result = await toolFn(parsedParams);
-                this.pushToolMessages(messages, {
-                  id: toolCall.id,
-                  name: toolCall.function.name,
-                  parameters: toolCall.function.arguments
-                }, result.toString());
-                const isMcpTool = options.tools?.find((t) => t.toolSchema.name === toolCall.function.name)?._isMcpTool;
-                if (isMcpTool) {
-                  await this.complete(model, messages, {
-                    ...options,
-                    _internal: {
-                      toolCallCount: toolCallCount + 1
-                    }
-                  }, callback, toolsUsed);
-                } else {
-                  await this.complete(model, messages, {
-                    ...options,
-                    tools: void 0,
-                    _internal: void 0
-                  }, callback, toolsUsed);
-                }
-                return;
-              } catch (error) {
-                if (error instanceof PermissionDeniedError) {
-                  throw error;
-                }
-                console.warn(`Error processing ${toolCall.function.name} tool:`, error);
-                this.pushToolMessages(messages, {
-                  id: toolCall.id,
-                  name: toolCall.function.name,
-                  parameters: toolCall.function.arguments
-                }, `Error: ${error instanceof Error ? error.message : "Unknown error"}`);
-                const isMcpToolError = options.tools?.find((t) => t.toolSchema.name === toolCall.function.name)?._isMcpTool;
-                if (isMcpToolError) {
-                  await this.complete(model, messages, {
-                    ...options,
-                    _internal: {
-                      toolCallCount: toolCallCount + 1
-                    }
-                  }, callback, toolsUsed);
-                } else {
-                  await this.complete(model, messages, {
-                    ...options,
-                    tools: void 0,
-                    _internal: void 0
-                  }, callback, toolsUsed);
+            }
+          }
+          if (options.executeTools !== false) {
+            for (const toolCall of c.message.tool_calls) {
+              if (toolCall.type !== "function") {
+                continue;
+              }
+              const toolFn = options.tools?.find((tool) => tool.toolSchema.name === toolCall.function.name)?.toolFn;
+              if (toolFn && toolCall.function.arguments) {
+                try {
+                  const parsedParams = JSON.parse(toolCall.function.arguments);
+                  const result = await toolFn(parsedParams);
+                  this.pushToolMessages(messages, {
+                    id: toolCall.id,
+                    name: toolCall.function.name,
+                    parameters: toolCall.function.arguments
+                  }, result.toString());
+                  const isMcpTool = options.tools?.find((t) => t.toolSchema.name === toolCall.function.name)?._isMcpTool;
+                  if (isMcpTool) {
+                    await this.complete(model, messages, {
+                      ...options,
+                      _internal: {
+                        toolCallCount: toolCallCount + 1
+                      }
+                    }, callback, toolsUsed);
+                  } else {
+                    await this.complete(model, messages, {
+                      ...options,
+                      tools: void 0,
+                      _internal: void 0
+                    }, callback, toolsUsed);
+                  }
+                  return;
+                } catch (error) {
+                  if (error instanceof PermissionDeniedError) {
+                    throw error;
+                  }
+                  console.warn(`Error processing ${toolCall.function.name} tool:`, error);
+                  this.pushToolMessages(messages, {
+                    id: toolCall.id,
+                    name: toolCall.function.name,
+                    parameters: toolCall.function.arguments
+                  }, `Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+                  const isMcpToolError = options.tools?.find((t) => t.toolSchema.name === toolCall.function.name)?._isMcpTool;
+                  if (isMcpToolError) {
+                    await this.complete(model, messages, {
+                      ...options,
+                      _internal: {
+                        toolCallCount: toolCallCount + 1
+                      }
+                    }, callback, toolsUsed);
+                  } else {
+                    await this.complete(model, messages, {
+                      ...options,
+                      tools: void 0,
+                      _internal: void 0
+                    }, callback, toolsUsed);
+                  }
+                  return;
                 }
-                return;
               }
             }
+          } else {
+            this.logger.debug(`[Tool Execution] executeTools=false, passing tool calls to callback`);
+            await callback([null], {
+              inputTokens: 0,
+              outputTokens: 0,
+              toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0
+            });
+            return;
           }
         } else {
           streamedText[c.index] = c.message.content || "";
@@ -4700,43 +4744,57 @@ var XAIBackend = class {
     }
     if (func.length > 0) {
       for await (const tool of func) {
-        const { id, name, parameters: parameters2 } = tool;
-        const toolFn = options.tools?.find((tool2) => tool2.toolSchema.name === name)?.toolFn;
-        if (id && name && parameters2 && toolFn) {
-          try {
-            toolsUsed.push({
-              name,
-              arguments: parameters2
-            });
-            const result = await toolFn(JSON.parse(parameters2));
-            this.pushToolMessages(messages, {
-              id,
-              name,
-              parameters: parameters2
-            }, result);
-          } catch (error) {
-            if (error instanceof PermissionDeniedError) {
-              throw error;
-            }
-            this.logger.updateMetadata({
-              tool: name,
-              parameters: parameters2
-            });
-            if (error instanceof SyntaxError && /JSON/.test(error.message)) {
-              this.logger.warn("JSON parse error processing tool parameters:", error);
-            } else {
-              this.logger.error("Error processing tool:", error);
+        const { name, parameters: parameters2 } = tool;
+        if (name && parameters2) {
+          toolsUsed.push({
+            name,
+            arguments: parameters2
+          });
+        }
+      }
+      if (options.executeTools !== false) {
+        for await (const tool of func) {
+          const { id, name, parameters: parameters2 } = tool;
+          const toolFn = options.tools?.find((tool2) => tool2.toolSchema.name === name)?.toolFn;
+          if (id && name && parameters2 && toolFn) {
+            try {
+              const result = await toolFn(JSON.parse(parameters2));
+              this.pushToolMessages(messages, {
+                id,
+                name,
+                parameters: parameters2
+              }, result);
+            } catch (error) {
+              if (error instanceof PermissionDeniedError) {
+                throw error;
+              }
+              this.logger.updateMetadata({
+                tool: name,
+                parameters: parameters2
+              });
+              if (error instanceof SyntaxError && /JSON/.test(error.message)) {
+                this.logger.warn("JSON parse error processing tool parameters:", error);
+              } else {
+                this.logger.error("Error processing tool:", error);
+              }
+              this.pushToolMessages(messages, {
+                id,
+                name,
+                parameters: parameters2
+              }, `Error: ${error instanceof Error ? error.message : "Unknown error"}`);
+              continue;
             }
-            this.pushToolMessages(messages, {
-              id,
-              name,
-              parameters: parameters2
-            }, `Error: ${error instanceof Error ? error.message : "Unknown error"}`);
-            continue;
           }
         }
+        await this.complete(model, messages, { ...options, tools: options.tools }, callback, toolsUsed);
+      } else {
+        this.logger.debug(`[Tool Execution] executeTools=false, passing tool calls to callback`);
+        await callback([null], {
+          inputTokens,
+          outputTokens,
+          toolsUsed: toolsUsed.length > 0 ? toolsUsed : void 0
+        });
       }
-      await this.complete(model, messages, { ...options, tools: options.tools }, callback, toolsUsed);
     }
   }
   formatMessages(messages) {

package/dist/{chunk-TPSQ5MIR.js → chunk-FNZZAMET.js}

@@ -2,7 +2,7 @@
 import {
   BadRequestError,
   secureParameters
-} from "./chunk-B3YFSFVU.js";
+} from "./chunk-EVPT4ARN.js";
 import {
   GenericCreditDeductTransaction,
   ImageEditUsageTransaction,
@@ -10,7 +10,7 @@ import {
   RealtimeVoiceUsageTransaction,
   TextGenerationUsageTransaction,
   TransferCreditTransaction
-} from "./chunk-MKO2KCCS.js";
+} from "./chunk-VVV7WLJ6.js";
 
 // ../../b4m-core/packages/services/dist/src/creditService/subtractCredits.js
 import { z } from "zod";

package/dist/{chunk-MKO2KCCS.js → chunk-VVV7WLJ6.js}

@@ -3770,6 +3770,7 @@ var AuthEvents;
   AuthEvents2["RESET_LAND_PASSWORD"] = "Password Reset Landed";
   AuthEvents2["RESET_PASSWORD_TOKEN_EXPIRED"] = "Password Reset Token Expired";
   AuthEvents2["CHANGE_PASSWORD"] = "Password Changed";
+  AuthEvents2["FORCE_CHANGE_PASSWORD"] = "Forced Password Changed";
   AuthEvents2["ADMIN_RESET_PASSWORD"] = "Admin Password Reset";
   AuthEvents2["FAILED_LOGIN"] = "Failed Login Attempt";
   AuthEvents2["EMAIL_VERIFIED"] = "Email Verified";

package/dist/{chunk-KZGZGNHL.js → chunk-ZT7Z4QVD.js}

@@ -7,11 +7,11 @@ import {
   getSettingsMap,
   getSettingsValue,
   secureParameters
-} from "./chunk-B3YFSFVU.js";
+} from "./chunk-EVPT4ARN.js";
 import {
   KnowledgeType,
   SupportedFabFileMimeTypes
-} from "./chunk-MKO2KCCS.js";
+} from "./chunk-VVV7WLJ6.js";
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/create.js
 import { z } from "zod";

package/dist/{create-DGRMWHIN.js → create-42PUCFSO.js}

@@ -2,10 +2,10 @@
 import {
   createFabFile,
   createFabFileSchema
-} from "./chunk-KZGZGNHL.js";
-import "./chunk-B3YFSFVU.js";
+} from "./chunk-ZT7Z4QVD.js";
+import "./chunk-EVPT4ARN.js";
 import "./chunk-CC67R4RB.js";
-import "./chunk-MKO2KCCS.js";
+import "./chunk-VVV7WLJ6.js";
 import "./chunk-PDX44BCA.js";
 export {
   createFabFile,