openfox 2.0.0-beta.5 → 2.0.0-beta.7

package/dist/{chunk-X36JIWSF.js → chunk-DFITQ75T.js}

@@ -1,57 +1,78 @@
 import {
-  BUILDER_KICKOFF_PROMPT,
   PathAccessDeniedError,
   TurnMetrics,
-  VERIFIER_KICKOFF_PROMPT,
+  WORKFLOW_KICKOFF_PROMPT,
   assembleAgentRequest,
   buildAgentReminder,
+  createAssemblyResult,
   createChatDoneEvent,
   createMessageStartEvent,
-  executeSubAgent,
   findAgentById,
+  getAllInstructions,
+  getConversationMessages,
+  getEnabledSkillMetadata,
   getSubAgents,
   getToolRegistryForAgent,
   loadAllAgentsDefault,
+  processEventsForConversation,
   runTopLevelAgentLoop
-} from "./chunk-DFWGWULB.js";
+} from "./chunk-QN5ST54E.js";
 import {
   getCurrentContextWindowId,
-  getEventStore
-} from "./chunk-UH27FDT7.js";
+  getCurrentWindowMessageOptions,
+  getEventStore,
+  getRuntimeConfig
+} from "./chunk-NPHYEUYE.js";
 import {
   buildSnapshotFromSessionState
-} from "./chunk-XL7SW5B4.js";
+} from "./chunk-XJEOP6XU.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
+import {
+  getGlobalConfigDir
+} from "./chunk-CQGTEGKL.js";
 
-// src/server/sub-agents/verifier-helpers.ts
-var MAX_CONSECUTIVE_VERIFIER_NUDGES = 10;
-var VERIFIER_STALL_REASON = "Verifier stopped repeatedly before terminalizing verification after repeated nudges.";
-function getCriteriaAwaitingVerification(criteria) {
-  return criteria.filter((criterion) => criterion.status.type === "completed");
-}
-function buildVerifierNudgeContent(criteria) {
-  const ids = criteria.map((criterion) => criterion.id).join(", ");
-  return `You stopped before finalizing verification. ${criteria.length} criteria still need a terminal verification result. Use criterion with action "pass" or "fail" for each remaining criterion: ${ids}.`;
-}
-function buildVerifierRestartContent(criteria) {
-  const ids = criteria.map((criterion) => criterion.id).join(", ");
-  return `${VERIFIER_STALL_REASON} Leaving remaining criteria unchanged so verification can restart in a fresh window: ${ids}.`;
-}
-function createVerifierNudgeConfig() {
-  return {
-    maxConsecutiveNudges: MAX_CONSECUTIVE_VERIFIER_NUDGES,
-    getCriteriaAwaiting: getCriteriaAwaitingVerification,
-    buildNudgeContent: buildVerifierNudgeContent,
-    buildRestartContent: buildVerifierRestartContent
-  };
+// src/server/chat/dynamic-context.ts
+import { createHash } from "crypto";
+function computeDynamicContextHash(instructionContent, skills) {
+  const dynamicInputs = JSON.stringify({
+    instructions: instructionContent,
+    skills: skills.map((s) => s.id).sort()
+  });
+  return createHash("sha256").update(dynamicInputs).digest("hex");
 }
 
 // src/server/chat/orchestrator.ts
-function getCurrentWindowMessageOptions(sessionId) {
-  const contextWindowId = getCurrentContextWindowId(sessionId);
-  return contextWindowId ? { contextWindowId } : void 0;
+async function buildRetryPatterns() {
+  const { getSetting, SETTINGS_KEYS } = await import("./settings-6XX56F3F.js");
+  const raw = getSetting(SETTINGS_KEYS.RETRY_PATTERNS);
+  if (!raw) {
+    const oldXmlProtection = getSetting("llm.disableXmlProtection");
+    if (oldXmlProtection !== null) {
+      const disabled = oldXmlProtection === "true";
+      return {
+        retryPatterns: disabled ? [] : [{ field: "both", pattern: "<(tool_call|function=|/tool_call|parameter=)", action: "retry", active: true }],
+        maxRetriesPerTurn: 10
+      };
+    }
+    return { retryPatterns: [], maxRetriesPerTurn: 10 };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      retryPatterns: Array.isArray(parsed.patterns) ? parsed.patterns : [],
+      maxRetriesPerTurn: typeof parsed.maxRetriesPerTurn === "number" ? parsed.maxRetriesPerTurn : 10
+    };
+  } catch {
+    return { retryPatterns: [], maxRetriesPerTurn: 10 };
+  }
+}
+function buildGetConversationMessages(sessionId, llmClient, append) {
+  return async () => {
+    const processedEvents = await processEventsForConversation(sessionId, llmClient, (event) => append(event));
+    return getConversationMessages({ type: "toplevel", sessionId }, { events: processedEvents });
+  };
 }
 function resolveStatsIdentity(options) {
   const model = options.llmClient.getModel();
@@ -75,13 +96,11 @@ async function runChatTurn(options) {
   const session = sessionManager.requireSession(sessionId);
   const mode = session.mode;
   logger.debug("Starting chat turn", { sessionId, mode });
+  sessionManager.setRunning(sessionId, true);
+  const append = (event) => eventStore.append(sessionId, event);
   const turnMetrics = new TurnMetrics();
   try {
-    if (mode === "builder") {
-      await runBuilderTurn(options, turnMetrics);
-    } else {
-      await runGenericAgentTurn(options, turnMetrics, mode);
-    }
+    await runAgentTurn(options, turnMetrics, mode, append);
     const snapshot = buildSnapshot(sessionManager, sessionId, turnMetrics.buildStats(statsIdentity, mode));
     const snapshotEvent = eventStore.append(sessionId, { type: "turn.snapshot", data: snapshot });
     const deletedCount = eventStore.cleanupOldEvents(sessionId);
@@ -147,18 +166,30 @@ async function runChatTurn(options) {
     eventStore.append(sessionId, { type: "running.changed", data: { isRunning: false } });
   }
 }
+function windowHasReminder(sessionId, windowId) {
+  const eventStore = getEventStore();
+  const events = eventStore.getEvents(sessionId);
+  return events.some((event) => {
+    if (event.type !== "message.start") return false;
+    const data = event.data;
+    return data.contextWindowId === windowId && data.messageKind === "auto-prompt" && typeof data.content === "string" && data.content.includes("<system-reminder>");
+  });
+}
 function injectModeReminderIfNeeded(sessionManager, sessionId, agentId, allAgents, _onMessage) {
   const eventStore = getEventStore();
   const session = sessionManager.requireSession(sessionId);
+  const currentWindowId = getCurrentContextWindowId(sessionId);
   const lastModeReminder = session.executionState?.lastModeWithReminder;
   if (lastModeReminder === agentId) {
-    return;
+    if (!currentWindowId || windowHasReminder(sessionId, currentWindowId)) {
+      return;
+    }
   }
   const agentDef = findAgentById(agentId, allAgents);
   if (!agentDef) return;
   const reminderContent = buildAgentReminder(agentDef);
   const reminderMsgId = crypto.randomUUID();
-  const currentWindowMessageOptions = getCurrentContextWindowId(sessionId) ? { contextWindowId: getCurrentContextWindowId(sessionId) } : void 0;
+  const currentWindowMessageOptions = currentWindowId ? { contextWindowId: currentWindowId } : void 0;
   eventStore.append(sessionId, {
     type: "message.start",
     data: {
@@ -183,130 +214,88 @@ function injectModeReminderIfNeeded(sessionManager, sessionId, agentId, allAgent
     lastModeWithReminder: agentId
   });
 }
-async function runGenericAgentTurn(options, turnMetrics, agentId) {
+async function runAgentTurn(options, turnMetrics, agentId, append, callbacks) {
   const statsIdentity = resolveStatsIdentity(options);
   const allAgents = await loadAllAgentsDefault();
   injectModeReminderIfNeeded(options.sessionManager, options.sessionId, agentId, allAgents, options.onMessage);
   const agentDef = findAgentById(agentId, allAgents) ?? findAgentById("planner", allAgents);
   const subAgentDefs = getSubAgents(allAgents);
-  await runTopLevelAgentLoop(
+  const { content: instructionContent } = await getAllInstructions(
+    options.sessionManager.requireSession(options.sessionId).workdir,
+    options.sessionManager.requireSession(options.sessionId).projectId
+  );
+  const runtimeConfig = getRuntimeConfig();
+  const configDir = getGlobalConfigDir(runtimeConfig.mode ?? "production");
+  const skills = await getEnabledSkillMetadata(configDir, runtimeConfig.workdir);
+  return runTopLevelAgentLoop(
     {
       mode: agentId,
+      append,
+      ...await buildRetryPatterns(),
       sessionManager: options.sessionManager,
       sessionId: options.sessionId,
       llmClient: options.llmClient,
       statsIdentity,
       signal: options.signal,
       onMessage: options.onMessage,
-      assembleRequest: (input) => assembleAgentRequest({ ...input, agentDef, subAgentDefs, modelName: options.llmClient.getModel() }),
-      getToolRegistry: () => getToolRegistryForAgent(agentDef)
-    },
-    turnMetrics
-  );
-}
-function filterToolRegistryForStepDone(baseRegistry, _injectStepDone) {
-  return baseRegistry;
-}
-async function runBuilderTurn(options, turnMetrics) {
-  const { sessionManager, sessionId } = options;
-  const statsIdentity = resolveStatsIdentity(options);
-  const eventStore = getEventStore();
-  const allAgents = await loadAllAgentsDefault();
-  injectModeReminderIfNeeded(options.sessionManager, options.sessionId, "builder", allAgents, options.onMessage);
-  const builderDef = findAgentById("builder", allAgents);
-  const subAgentDefs = getSubAgents(allAgents);
-  let stepDoneCalled = false;
-  return {
-    ...await runTopLevelAgentLoop(
-      {
-        mode: "builder",
-        sessionManager,
-        sessionId,
-        llmClient: options.llmClient,
-        statsIdentity,
-        signal: options.signal,
-        onMessage: options.onMessage,
-        assembleRequest: (input) => assembleAgentRequest({
-          ...input,
-          agentDef: builderDef,
-          subAgentDefs,
-          modelName: options.llmClient.getModel()
-        }),
-        getToolRegistry: () => {
-          const baseRegistry = getToolRegistryForAgent(builderDef);
-          return filterToolRegistryForStepDone(baseRegistry, options.injectStepDone === true);
-        },
-        onToolExecuted: (toolCall, toolResult) => {
-          if (toolCall.name === "step_done" && toolResult.success) {
-            stepDoneCalled = true;
-          }
-          if (toolResult.success && ["write_file", "edit_file"].includes(toolCall.name)) {
-            const path = toolCall.arguments["path"];
-            sessionManager.addModifiedFile(sessionId, path);
+      assembleRequest: (input) => {
+        const cached = options.sessionManager.getCachedPrompt(options.sessionId);
+        if (cached) {
+          const currentHash = computeDynamicContextHash(instructionContent ?? "", skills);
+          if (cached.hash !== currentHash) {
+            options.sessionManager.setDynamicContextChanged(options.sessionId, true);
           }
-        },
-        injectKickoff: () => {
-          if (options.injectBuilderKickoff !== true) return;
-          const session = sessionManager.requireSession(sessionId);
-          const currentWindowMessageOptions = getCurrentContextWindowId(sessionId) ? { contextWindowId: getCurrentContextWindowId(sessionId) } : void 0;
-          const events = eventStore.getEvents(sessionId);
-          const hasBuilderKickoff = events.some((e) => {
-            if (e.type !== "message.start") return false;
-            const data = e.data;
-            return data.messageKind === "auto-prompt" && data.content?.includes("fulfil the");
+          return createAssemblyResult({
+            systemPrompt: cached.systemPrompt,
+            messages: input.messages,
+            injectedFiles: input.injectedFiles,
+            requestTools: input.promptTools,
+            toolChoice: input.toolChoice,
+            disableThinking: false
           });
-          if (!hasBuilderKickoff) {
-            const kickoffMsgId = crypto.randomUUID();
-            const kickoffContent = BUILDER_KICKOFF_PROMPT(session.criteria.length);
-            const msgMetadata = { type: "workflow", name: "Workflow", color: "#f59e0b" };
-            eventStore.append(
-              sessionId,
-              createMessageStartEvent(kickoffMsgId, "user", kickoffContent, {
-                ...currentWindowMessageOptions ?? {},
-                isSystemGenerated: true,
-                messageKind: "auto-prompt",
-                metadata: msgMetadata
-              })
-            );
-            eventStore.append(sessionId, { type: "message.done", data: { messageId: kickoffMsgId } });
-          }
         }
+        const result = assembleAgentRequest({
+          ...input,
+          agentDef,
+          subAgentDefs,
+          modelName: options.llmClient.getModel()
+        });
+        const hash = computeDynamicContextHash(instructionContent ?? "", skills);
+        options.sessionManager.setCachedPrompt(options.sessionId, result.systemPrompt, hash);
+        return result;
       },
-      turnMetrics
-    ),
-    stepDoneCalled
-  };
+      getToolRegistry: () => getToolRegistryForAgent(agentDef),
+      getConversationMessages: buildGetConversationMessages(options.sessionId, options.llmClient, append),
+      injectModeReminder: () => injectModeReminderIfNeeded(options.sessionManager, options.sessionId, agentId, allAgents, options.onMessage),
+      ...callbacks?.injectKickoff ? { injectKickoff: callbacks.injectKickoff } : {},
+      ...callbacks?.onToolExecuted ? { onToolExecuted: callbacks.onToolExecuted } : {}
+    },
+    turnMetrics
+  );
 }
-async function runVerifierTurn(options, turnMetrics) {
-  const { sessionManager, sessionId, llmClient, signal, onMessage } = options;
-  const statsIdentity = resolveStatsIdentity(options);
+function injectWorkflowKickoffIfNeeded(sessionManager, sessionId, eventStore) {
   const session = sessionManager.requireSession(sessionId);
-  const toVerify = session.criteria.filter((c) => c.status.type === "completed");
-  if (toVerify.length === 0) {
-    logger.debug("Nothing to verify", { sessionId });
-    return { allPassed: true, failed: [] };
-  }
-  const allAgents = await loadAllAgentsDefault();
-  const verifierDef = findAgentById("verifier", allAgents);
-  const toolRegistry = getToolRegistryForAgent(verifierDef);
-  const result = await executeSubAgent({
-    subAgentType: "verifier",
-    prompt: VERIFIER_KICKOFF_PROMPT,
-    sessionManager,
-    sessionId,
-    llmClient,
-    toolRegistry,
-    turnMetrics,
-    statsIdentity,
-    signal,
-    onMessage,
-    nudgeConfig: createVerifierNudgeConfig()
+  const currentWindowMessageOptions = getCurrentContextWindowId(sessionId) ? { contextWindowId: getCurrentContextWindowId(sessionId) } : void 0;
+  const events = eventStore.getEvents(sessionId);
+  const hasKickoff = events.some((e) => {
+    if (e.type !== "message.start") return false;
+    const data = e.data;
+    return data.messageKind === "auto-prompt" && data.content?.includes("fulfil the");
   });
-  return {
-    allPassed: result.allPassed ?? true,
-    failed: result.failed ?? [],
-    content: result.content
-  };
+  if (!hasKickoff) {
+    const kickoffMsgId = crypto.randomUUID();
+    const kickoffContent = WORKFLOW_KICKOFF_PROMPT(session.criteria.length);
+    eventStore.append(
+      sessionId,
+      createMessageStartEvent(kickoffMsgId, "user", kickoffContent, {
+        ...currentWindowMessageOptions ?? {},
+        isSystemGenerated: true,
+        messageKind: "auto-prompt",
+        metadata: { type: "workflow", name: "Workflow", color: "#f59e0b" }
+      })
+    );
+    eventStore.append(sessionId, { type: "message.done", data: { messageId: kickoffMsgId } });
+  }
 }
 function buildSnapshot(sessionManager, sessionId, _lastStats) {
   const eventStore = getEventStore();
@@ -323,10 +312,9 @@ function buildSnapshot(sessionManager, sessionId, _lastStats) {
 }
 
 export {
-  createVerifierNudgeConfig,
+  computeDynamicContextHash,
   runChatTurn,
-  filterToolRegistryForStepDone,
-  runBuilderTurn,
-  runVerifierTurn
+  runAgentTurn,
+  injectWorkflowKickoffIfNeeded
 };
-//# sourceMappingURL=chunk-X36JIWSF.js.map
+//# sourceMappingURL=chunk-DFITQ75T.js.map

package/dist/{chunk-HHAJ3QF6.js → chunk-EMJGF3A7.js}

@@ -5,10 +5,7 @@ import {
   getBackendCapabilities,
   getModelProfile,
   mapFinishReason
-} from "./chunk-HGAMIPFO.js";
-import {
-  ensureVisionFallbackConfigLoaded
-} from "./chunk-SZKEGZIB.js";
+} from "./chunk-7FDY3EOH.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -187,23 +184,13 @@ function createLLMClient(config, initialBackend = "unknown") {
       });
       try {
         const shouldDisableThinking = disableThinking || request.disableThinking === true;
-        await ensureVisionFallbackConfigLoaded();
-        const { isVisionFallbackEnabled } = await import("./vision-fallback-3MIZZ6NQ.js");
-        const paramsOptions = {
+        const { params: createParams } = await buildNonStreamingCreateParams({
           model,
           request,
           profile,
           capabilities,
-          disableThinking: shouldDisableThinking,
-          visionFallbackEnabled: isVisionFallbackEnabled()
-        };
-        if (request.onVisionFallbackStart) {
-          paramsOptions.onVisionFallbackStart = request.onVisionFallbackStart;
-        }
-        if (request.onVisionFallbackDone) {
-          paramsOptions.onVisionFallbackDone = request.onVisionFallbackDone;
-        }
-        const { params: createParams } = await buildNonStreamingCreateParams(paramsOptions);
+          disableThinking: shouldDisableThinking
+        });
         const response = await openai.chat.completions.create(createParams, {
           signal: request.signal
         });
@@ -264,18 +251,13 @@ function createLLMClient(config, initialBackend = "unknown") {
         idleTimeout
       });
       try {
-        await ensureVisionFallbackConfigLoaded();
-        const { isVisionFallbackEnabled } = await import("./vision-fallback-3MIZZ6NQ.js");
         const shouldDisableThinking = disableThinking || request.disableThinking === true;
         const createParams = await buildStreamingCreateParams({
           model,
           request,
           profile,
           capabilities,
-          disableThinking: shouldDisableThinking,
-          visionFallbackEnabled: isVisionFallbackEnabled(),
-          onVisionFallbackStart: request.onVisionFallbackStart,
-          onVisionFallbackDone: request.onVisionFallbackDone
+          disableThinking: shouldDisableThinking
         });
         const { params: streamingParams } = createParams;
         const stream = await openai.chat.completions.create(streamingParams, {
@@ -298,6 +280,8 @@ function createLLMClient(config, initialBackend = "unknown") {
             idleTimeoutController.abort();
           }
         }, 100);
+        const onAbort = () => clearInterval(idleTimer);
+        request.signal?.addEventListener("abort", onAbort, { once: true });
         try {
           for await (const chunk of stream) {
             if (idleTimeoutController.signal.aborted) {
@@ -412,6 +396,7 @@ function createLLMClient(config, initialBackend = "unknown") {
           }
         } finally {
           clearInterval(idleTimer);
+          request.signal?.removeEventListener("abort", onAbort);
         }
         if (tagBuffer) {
           if (inThinking) {
@@ -478,4 +463,4 @@ export {
   getLlmStatus,
   clearModelCache
 };
-//# sourceMappingURL=chunk-HHAJ3QF6.js.map
+//# sourceMappingURL=chunk-EMJGF3A7.js.map

package/dist/{chunk-RF2JGDSS.js → chunk-IGSZUXQP.js}

@@ -2,11 +2,11 @@ import {
   clearModelCache,
   createLLMClient,
   detectModel
-} from "./chunk-HHAJ3QF6.js";
+} from "./chunk-EMJGF3A7.js";
 import {
   detectBackend,
   getModelProfile
-} from "./chunk-HGAMIPFO.js";
+} from "./chunk-7FDY3EOH.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -511,4 +511,4 @@ export {
   parseDefaultModelSelection,
   createProviderManager
 };
-//# sourceMappingURL=chunk-RF2JGDSS.js.map
+//# sourceMappingURL=chunk-IGSZUXQP.js.map

package/dist/{chunk-I67T2E5K.js → chunk-KAYUPVHQ.js}

@@ -33,7 +33,7 @@ Options:
 }
 async function runNetworkSetup(mode) {
   const { loadAuthConfig, saveAuthConfig, encryptPassword } = await import("./auth-56SIRACI.js");
-  const { saveGlobalConfig } = await import("./config-YU7NYZYG.js");
+  const { saveGlobalConfig } = await import("./config-QUT7YZQ7.js");
   const { getAuthKeyPath } = await import("./paths-X46PPOI2.js");
   const existingAuth = await loadAuthConfig(mode);
   if (existingAuth) {
@@ -94,7 +94,7 @@ async function runNetworkSetup(mode) {
   console.log("\u2713 Configuration saved!\n");
 }
 async function runConfig(mode) {
-  const { loadGlobalConfig, getActiveProvider, getDefaultModel } = await import("./config-YU7NYZYG.js");
+  const { loadGlobalConfig, getActiveProvider, getDefaultModel } = await import("./config-QUT7YZQ7.js");
   const { getGlobalConfigPath } = await import("./paths-X46PPOI2.js");
   const config = await loadGlobalConfig(mode);
   const configPath = getGlobalConfigPath(mode);
@@ -151,7 +151,7 @@ async function runCli(options) {
       break;
     }
     case "provider": {
-      const { runProviderCommand } = await import("./provider-HTJEB3ON.js");
+      const { runProviderCommand } = await import("./provider-4T6BVPMD.js");
       const [, subcommand] = positionals;
       await runProviderCommand(mode, subcommand);
       break;
@@ -188,12 +188,12 @@ async function runCli(options) {
       break;
     }
     default: {
-      const { configFileExists } = await import("./config-YU7NYZYG.js");
+      const { configFileExists } = await import("./config-QUT7YZQ7.js");
       const configExists = await configFileExists(mode);
       if (!configExists) {
         await runNetworkSetup(mode);
       }
-      const { runServe } = await import("./serve-EUEQ6ERI.js");
+      const { runServe } = await import("./serve-W3ETJJP3.js");
       const serveOptions = { mode };
       if (values.port) serveOptions.port = parseInt(values.port);
       if (values["no-browser"] === true) serveOptions.openBrowser = false;
@@ -205,4 +205,4 @@ async function runCli(options) {
 export {
   runCli
 };
-//# sourceMappingURL=chunk-I67T2E5K.js.map
+//# sourceMappingURL=chunk-KAYUPVHQ.js.map