@bike4mind/cli 0.2.2 → 0.2.3-feat-questmaster-gpt5-function-calling.17056

package/dist/{chunk-5N4PG5EH.js → chunk-55HUCQWS.js}

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

package/dist/{chunk-NZADYDFG.js → chunk-BSDDDQF4.js}

@@ -4112,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
@@ -7978,6 +7984,165 @@ 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) {
+  if (!args || typeof args !== "string" || args.trim() === "") {
+    throw new Error("Function call arguments are empty or invalid");
+  }
+  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" || result.goal.trim() === "") {
+    throw new Error("Function call missing required field: goal (must be non-empty string)");
+  }
+  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 || typeof quest !== "object") {
+      throw new Error(`Quest ${i} is not a valid object`);
+    }
+    const questObj = quest;
+    if (!questObj.id || typeof questObj.id !== "string" || questObj.id.trim() === "") {
+      throw new Error(`Quest ${i} missing required field: id (must be non-empty string)`);
+    }
+    if (!questObj.title || typeof questObj.title !== "string" || questObj.title.trim() === "") {
+      throw new Error(`Quest ${i} missing required field: title (must be non-empty string)`);
+    }
+    if (!questObj.description || typeof questObj.description !== "string" || questObj.description.trim() === "") {
+      throw new Error(`Quest ${i} missing required field: description (must be non-empty string)`);
+    }
+    if (!questObj.complexity || !["Easy", "Medium", "Hard"].includes(questObj.complexity)) {
+      throw new Error(`Quest ${i} has invalid complexity: ${questObj.complexity} (must be Easy, Medium, or Hard)`);
+    }
+    if (!Array.isArray(questObj.subQuests)) {
+      throw new Error(`Quest "${questObj.id}" missing required field: subQuests (must be an array)`);
+    }
+    if (questObj.subQuests.length === 0) {
+      throw new Error(`Quest "${questObj.id}" has no subQuests (minimum 2 required)`);
+    }
+    for (let j = 0; j < questObj.subQuests.length; j++) {
+      const subQuest = questObj.subQuests[j];
+      if (!subQuest || typeof subQuest !== "object") {
+        throw new Error(`Quest "${questObj.id}" subQuest ${j} is not a valid object`);
+      }
+      const subQuestObj = subQuest;
+      if (!subQuestObj.id || typeof subQuestObj.id !== "string" || subQuestObj.id.trim() === "") {
+        throw new Error(`Quest "${questObj.id}" subQuest ${j} missing required field: id (must be non-empty string)`);
+      }
+      if (!subQuestObj.title || typeof subQuestObj.title !== "string" || subQuestObj.title.trim() === "") {
+        throw new Error(`Quest "${questObj.id}" subQuest ${j} missing required field: title (must be non-empty string)`);
+      }
+    }
+  }
+  if (result.tags !== void 0) {
+    if (!Array.isArray(result.tags)) {
+      throw new Error("Function call field tags must be an array if provided");
+    }
+    for (let i = 0; i < result.tags.length; i++) {
+      if (typeof result.tags[i] !== "string") {
+        throw new Error(`Function call field tags[${i}] must be a string`);
+      }
+    }
+  }
+  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, "");
@@ -8008,10 +8173,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: {
@@ -8028,135 +8192,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 (input !== null && 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)) {
@@ -8356,9 +8546,106 @@ 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.5 : 0.7,
+      // Lower temperature for structured JSON outputs; even lower 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) {
+      if (retryCount < MAX_RETRIES) {
+        this.logger.warn(`Some quests missing subquests: ${questsWithoutSubquests.map((q) => q.id).join(", ")}, retrying...`);
+        return this.createQuestPlanWithFunctionCalling(model, prompt, retryCount + 1);
+      } else {
+        this.logger.warn(`Returning quest plan with ${questsWithoutSubquests.length} quests missing subquests after max retries (${MAX_RETRIES}): ${questsWithoutSubquests.map((q) => q.id).join(", ")}`);
+      }
+    }
+    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",
@@ -10452,6 +10739,9 @@ export {
   sendToConnection,
   ClientMessageSender,
   OpenaiModerationsService,
+  isGPT5ModelWithToolSupport,
+  createQuestPlanToolSchema,
+  parseQuestPlanFunctionCall,
   QuestMaster,
   OpenAIImageService,
   TestImageService,

package/dist/{chunk-Y4HMTEDH.js → chunk-CS24JD7W.js}

@@ -2,7 +2,7 @@
 import {
   BadRequestError,
   secureParameters
-} from "./chunk-NZADYDFG.js";
+} from "./chunk-BSDDDQF4.js";
 import {
   GenericCreditDeductTransaction,
   ImageEditUsageTransaction,

package/dist/{chunk-GZTILMGE.js → chunk-QGLZY6IF.js}

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

package/dist/{create-ZTK4723N.js → create-XI66RQVC.js}

@@ -2,8 +2,8 @@
 import {
   createFabFile,
   createFabFileSchema
-} from "./chunk-5N4PG5EH.js";
-import "./chunk-NZADYDFG.js";
+} from "./chunk-55HUCQWS.js";
+import "./chunk-BSDDDQF4.js";
 import "./chunk-AMDXHL6S.js";
 import "./chunk-WR6YZRQV.js";
 import "./chunk-PDX44BCA.js";

package/dist/index.js

@@ -4,9 +4,9 @@ import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-GZTILMGE.js";
-import "./chunk-Y4HMTEDH.js";
-import "./chunk-5N4PG5EH.js";
+} from "./chunk-QGLZY6IF.js";
+import "./chunk-CS24JD7W.js";
+import "./chunk-55HUCQWS.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -15,7 +15,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-NZADYDFG.js";
+} from "./chunk-BSDDDQF4.js";
 import {
   Logger
 } from "./chunk-AMDXHL6S.js";
@@ -9178,7 +9178,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.2",
+  version: "0.2.3-feat-questmaster-gpt5-function-calling.17056+aaf443bae",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -9279,11 +9279,11 @@ var package_default = {
     zustand: "^4.5.4"
   },
   devDependencies: {
-    "@bike4mind/agents": "workspace:*",
-    "@bike4mind/common": "workspace:*",
-    "@bike4mind/mcp": "workspace:*",
-    "@bike4mind/services": "workspace:*",
-    "@bike4mind/utils": "workspace:*",
+    "@bike4mind/agents": "0.1.0",
+    "@bike4mind/common": "2.37.1-feat-questmaster-gpt5-function-calling.17056+aaf443bae",
+    "@bike4mind/mcp": "1.19.5-feat-questmaster-gpt5-function-calling.17056+aaf443bae",
+    "@bike4mind/services": "2.31.1-feat-questmaster-gpt5-function-calling.17056+aaf443bae",
+    "@bike4mind/utils": "2.0.4-feat-questmaster-gpt5-function-calling.17056+aaf443bae",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -9294,7 +9294,8 @@ var package_default = {
     tsx: "^4.21.0",
     typescript: "^5.9.3",
     vitest: "^3.2.4"
-  }
+  },
+  gitHead: "aaf443baeab1b87a7675e1577cc6535b2042bcdc"
 };
 
 // src/config/constants.ts

package/dist/{mementoService-5XQYECNM.js → mementoService-DCTBFBVO.js}

@@ -2,8 +2,8 @@
 import {
   findMostSimilarMemento,
   getRelevantMementos
-} from "./chunk-GZTILMGE.js";
-import "./chunk-NZADYDFG.js";
+} from "./chunk-QGLZY6IF.js";
+import "./chunk-BSDDDQF4.js";
 import "./chunk-AMDXHL6S.js";
 import "./chunk-WR6YZRQV.js";
 import "./chunk-PDX44BCA.js";

package/dist/{src-DOO3QAO2.js → src-Y26NRIGO.js}

@@ -65,6 +65,7 @@ import {
   cleanMermaidSyntax,
   computeCosineSimilarity,
   convertCodeBlocksToArtifacts,
+  createQuestPlanToolSchema,
   createTokenizer,
   decodeBase64DataUrl,
   detectURLs,
@@ -97,6 +98,7 @@ import {
   includeImagePromptSystemMessage,
   initializeConfig,
   invalidateSettingsCache,
+  isGPT5ModelWithToolSupport,
   isMermaidSyntax,
   isModelAccessible,
   isPlainText,
@@ -105,6 +107,7 @@ import {
   isZodError,
   obfuscateApiKey,
   parseArtifacts,
+  parseQuestPlanFunctionCall,
   processFabFilesServer,
   processUrlsFromPrompt,
   secureParameters,
@@ -117,7 +120,7 @@ import {
   validateMermaidSyntax,
   warmUpSettingsCache,
   withRetry
-} from "./chunk-NZADYDFG.js";
+} from "./chunk-BSDDDQF4.js";
 import {
   Logger,
   NotificationDeduplicator,
@@ -196,6 +199,7 @@ export {
   cleanMermaidSyntax,
   computeCosineSimilarity,
   convertCodeBlocksToArtifacts,
+  createQuestPlanToolSchema,
   createTokenizer,
   decodeBase64DataUrl,
   detectURLs,
@@ -228,6 +232,7 @@ export {
   includeImagePromptSystemMessage,
   initializeConfig,
   invalidateSettingsCache,
+  isGPT5ModelWithToolSupport,
   isMermaidSyntax,
   isModelAccessible,
   isPlainText,
@@ -238,6 +243,7 @@ export {
   notifyEventLogsToSlack,
   obfuscateApiKey,
   parseArtifacts,
+  parseQuestPlanFunctionCall,
   postLowCreditsNotificationToSlack,
   postMessageToSlack,
   processFabFilesServer,

package/dist/{subtractCredits-3QOJA6XF.js → subtractCredits-MPEEX4N7.js}

@@ -2,8 +2,8 @@
 import {
   SubtractCreditsSchema,
   subtractCredits
-} from "./chunk-Y4HMTEDH.js";
-import "./chunk-NZADYDFG.js";
+} from "./chunk-CS24JD7W.js";
+import "./chunk-BSDDDQF4.js";
 import "./chunk-AMDXHL6S.js";
 import "./chunk-WR6YZRQV.js";
 import "./chunk-PDX44BCA.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bike4mind/cli",
-  "version": "0.2.2",
+  "version": "0.2.3-feat-questmaster-gpt5-function-calling.17056+aaf443bae",
   "type": "module",
   "description": "Interactive CLI tool for Bike4Mind with ReAct agents",
   "license": "UNLICENSED",
@@ -30,6 +30,15 @@
     "dist",
     "bin"
   ],
+  "scripts": {
+    "dev": "tsx src/index.tsx",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "start": "node dist/index.js",
+    "prepublishOnly": "pnpm build"
+  },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.22.0",
     "@aws-sdk/client-apigatewaymanagementapi": "3.654.0",
@@ -92,6 +101,11 @@
     "zustand": "^4.5.4"
   },
   "devDependencies": {
+    "@bike4mind/agents": "0.1.0",
+    "@bike4mind/common": "2.37.1-feat-questmaster-gpt5-function-calling.17056+aaf443bae",
+    "@bike4mind/mcp": "1.19.5-feat-questmaster-gpt5-function-calling.17056+aaf443bae",
+    "@bike4mind/services": "2.31.1-feat-questmaster-gpt5-function-calling.17056+aaf443bae",
+    "@bike4mind/utils": "2.0.4-feat-questmaster-gpt5-function-calling.17056+aaf443bae",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -101,19 +115,7 @@
     "tsup": "^8.5.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4",
-    "@bike4mind/common": "2.37.0",
-    "@bike4mind/agents": "0.1.0",
-    "@bike4mind/mcp": "1.19.4",
-    "@bike4mind/services": "2.31.0",
-    "@bike4mind/utils": "2.0.3"
+    "vitest": "^3.2.4"
   },
-  "scripts": {
-    "dev": "tsx src/index.tsx",
-    "build": "tsup",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "start": "node dist/index.js"
-  }
-}
+  "gitHead": "aaf443baeab1b87a7675e1577cc6535b2042bcdc"
+}