@bike4mind/cli 0.2.3-feat-questmaster-gpt5-function-calling.17057 → 0.2.3-feat-cli-interactive-config-editor.17058

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

@@ -4112,12 +4112,6 @@ 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
@@ -7984,200 +7978,9 @@ function extractQuestMasterData(reply, options = {}) {
   return questMasterData;
 }
 
-// ../../b4m-core/packages/utils/dist/src/questMasterToolSchema.js
-var MAX_GOAL_LENGTH = 500;
-var MAX_TITLE_LENGTH = 200;
-var MAX_DESCRIPTION_LENGTH = 2e3;
-var MAX_TAG_LENGTH = 50;
-var MAX_QUESTS = 20;
-var MAX_SUBQUESTS_PER_QUEST = 20;
-var MAX_TAGS = 10;
-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 (result.goal.length > MAX_GOAL_LENGTH) {
-    throw new Error(`Goal exceeds maximum length of ${MAX_GOAL_LENGTH} characters`);
-  }
-  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");
-  }
-  if (result.quests.length > MAX_QUESTS) {
-    throw new Error(`Too many quests: ${result.quests.length} (max ${MAX_QUESTS})`);
-  }
-  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.title.length > MAX_TITLE_LENGTH) {
-      throw new Error(`Quest ${i} title exceeds maximum length of ${MAX_TITLE_LENGTH} characters`);
-    }
-    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.description.length > MAX_DESCRIPTION_LENGTH) {
-      throw new Error(`Quest ${i} description exceeds maximum length of ${MAX_DESCRIPTION_LENGTH} characters`);
-    }
-    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)`);
-    }
-    if (questObj.subQuests.length > MAX_SUBQUESTS_PER_QUEST) {
-      throw new Error(`Quest "${questObj.id}" has too many subQuests: ${questObj.subQuests.length} (max ${MAX_SUBQUESTS_PER_QUEST})`);
-    }
-    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 (subQuestObj.title.length > MAX_TITLE_LENGTH) {
-        throw new Error(`Quest "${questObj.id}" subQuest ${j} title exceeds maximum length of ${MAX_TITLE_LENGTH} characters`);
-      }
-    }
-  }
-  if (result.tags !== void 0) {
-    if (!Array.isArray(result.tags)) {
-      throw new Error("Function call field tags must be an array if provided");
-    }
-    if (result.tags.length > MAX_TAGS) {
-      throw new Error(`Too many tags: ${result.tags.length} (max ${MAX_TAGS})`);
-    }
-    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`);
-      }
-      if (result.tags[i].length > MAX_TAG_LENGTH) {
-        throw new Error(`Tag ${i} exceeds maximum length of ${MAX_TAG_LENGTH} characters`);
-      }
-    }
-  }
-  return result;
-}
-
 // ../../b4m-core/packages/utils/dist/src/questMaster.js
-var sanitizeId = (id, fallback) => {
-  const sanitized = id.replace(/\s+/g, "-").replace(/[^a-zA-Z0-9_.-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
-  return sanitized || fallback;
+var sanitizeId = (id) => {
+  return id.replace(/\s+/g, "-").replace(/[^a-zA-Z0-9_.-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
 };
 var QuestMaster = class {
   llm;
@@ -8205,12 +8008,10 @@ var QuestMaster = class {
     }
     return "Easy";
   }
-  async processQuestPlan(input) {
+  async processQuestPlan(questPlanText) {
     try {
-      if (!this.quest) {
-        throw new Error("No quest context available");
-      }
       await this.onStatusUpdate(this.quest, "Processing quest plan...");
+      this.logger.log("Processing quest plan:", questPlanText);
       const defaultResponse = {
         type: "narrative",
         meta: {
@@ -8227,158 +8028,135 @@ 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 (input !== null && typeof input === "object") {
-        this.logger.log("Processing quest plan from function calling result");
+      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");
+        }
         questResponse = {
           type: "quest_plan",
           meta: {
-            goal: input.goal,
-            totalSteps: input.quests.length,
-            tags: input.tags
+            goal,
+            totalSteps: validQuests.length,
+            tags
           },
-          quests: input.quests.map((quest) => ({
+          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,
-            complexity: quest.complexity,
+            // No fallback - we filtered for valid descriptions
+            complexity: quest.complexity || "Medium",
             status: "not_started",
-            subQuests: quest.subQuests.map((sub) => ({
+            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"
-            }))
+            })) : []
           }))
         };
-      } else {
-        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;
+        if (questResponse.quests.some((quest) => quest.subQuests.length === 0)) {
+          throw new Error("Some quests have no valid subquests after filtering");
         }
-        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);
+      } 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");
             }
-          }
-        }
-        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: "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");
             }
-          } catch (parseError) {
-            this.logger.error("Error parsing quest plan JSON:", parseError);
-            questResponse = defaultResponse;
+            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;
         }
       }
       if (!this.validateQuestResponse(questResponse)) {
@@ -8392,21 +8170,18 @@ var QuestMaster = class {
         goal: questResponse.meta.goal,
         userId: this.userId,
         tags: questResponse.meta.tags || [],
-        quests: questResponse.quests.map((quest, questIndex) => {
-          const questId = sanitizeId(quest.id, `quest-${questIndex + 1}`);
-          return {
-            id: questId,
-            title: quest.title,
-            description: quest.description,
-            complexity: quest.complexity,
-            subQuests: quest.subQuests.map((sub, subIndex) => ({
-              id: sanitizeId(sub.id, `${questId}-sub-${subIndex + 1}`),
-              title: sub.title,
-              status: sub.status
-              // questId intentionally omitted - will be set when task is started and linked to a chat message
-            }))
-          };
-        })
+        quests: questResponse.quests.map((quest) => ({
+          id: sanitizeId(quest.id),
+          title: quest.title,
+          description: quest.description,
+          complexity: quest.complexity,
+          subQuests: quest.subQuests.map((sub) => ({
+            id: sanitizeId(sub.id),
+            title: sub.title,
+            status: sub.status
+            // questId intentionally omitted - will be set when task is started and linked to a chat message
+          }))
+        }))
       });
       this.quest.questMasterPlanId = questMasterPlan.id;
       this.quest.reply = null;
@@ -8457,9 +8232,7 @@ var QuestMaster = class {
       }
       throw error;
     } finally {
-      if (this.quest) {
-        await this.onStatusUpdate(this.quest, null);
-      }
+      await this.onStatusUpdate(this.quest, null);
     }
   }
   validateQuestResponse(response) {
@@ -8583,114 +8356,9 @@ 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...");
-            try {
-              functionResult = parseQuestPlanFunctionCall(toolCall.arguments);
-            } catch (parseError) {
-              lastError = parseError instanceof Error ? parseError : new Error(String(parseError));
-              this.logger.error("Failed to parse function call arguments:", parseError);
-            }
-          }
-        }
-      });
-    } 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 {
-      if (!this.quest) {
-        throw new Error("No quest context available");
-      }
       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",
@@ -10784,9 +10452,6 @@ export {
   sendToConnection,
   ClientMessageSender,
   OpenaiModerationsService,
-  isGPT5ModelWithToolSupport,
-  createQuestPlanToolSchema,
-  parseQuestPlanFunctionCall,
   QuestMaster,
   OpenAIImageService,
   TestImageService,

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

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