openfox 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/{chunk-CEZNMLOO.js → chunk-7TTEGAO6.js}

@@ -1,7 +1,7 @@
 import {
   createServerMessage,
   isClientMessage
-} from "./chunk-FQLK5GL5.js";
+} from "./chunk-BVHFMAVN.js";
 
 // src/server/ws/protocol.ts
 function enrichMessagesWithToolResults(messages) {
@@ -94,8 +94,14 @@ function createChatTodoMessage(todos) {
 function createChatProgressMessage(message, phase) {
   return createServerMessage("chat.progress", { message, ...phase ? { phase } : {} });
 }
-function createChatFormatRetryMessage(attempt, maxAttempts) {
-  return createServerMessage("chat.format_retry", { attempt, maxAttempts });
+function createChatFormatRetryMessage(attempt, maxAttempts, pattern, field, matchedContent) {
+  return createServerMessage("chat.format_retry", {
+    attempt,
+    maxAttempts,
+    ...pattern !== void 0 ? { pattern } : {},
+    ...field !== void 0 ? { field } : {},
+    ...matchedContent !== void 0 ? { matchedContent } : {}
+  });
 }
 function createChatMessageMessage(message) {
   return createServerMessage("chat.message", { message });
@@ -120,9 +126,6 @@ function createChatPathConfirmationMessage(callId, tool, paths, workdir, reason)
 function createChatAskUserMessage(callId, question) {
   return createServerMessage("chat.ask_user", { callId, question });
 }
-function createChatVisionFallbackMessage(payload) {
-  return createServerMessage("chat.vision_fallback", payload);
-}
 function createModeChangedMessage(mode, auto, reason) {
   return createServerMessage("mode.changed", { mode, auto, ...reason ? { reason } : {} });
 }
@@ -198,9 +201,6 @@ function storedEventToServerMessage(event) {
       if (data.stats) {
         updates.stats = data.stats;
       }
-      if (data.promptContext) {
-        updates.promptContext = data.promptContext;
-      }
       return createChatMessageUpdatedMessage(data.messageId, updates);
     }
     case "tool.preparing": {
@@ -283,9 +283,9 @@ function storedEventToServerMessage(event) {
       const data = event.data;
       return createChatAskUserMessage(data.callId, data.question);
     }
-    case "format.retry": {
+    case "pattern.retry": {
       const data = event.data;
-      return createChatFormatRetryMessage(data.attempt, data.maxAttempts);
+      return createChatFormatRetryMessage(data.attempt, data.maxAttempts, data.pattern, data.field, data.matchedContent);
     }
     case "turn.snapshot":
     case "context.compacted":
@@ -320,7 +320,6 @@ export {
   createChatErrorMessage,
   createChatPathConfirmationMessage,
   createChatAskUserMessage,
-  createChatVisionFallbackMessage,
   createModeChangedMessage,
   createPhaseChangedMessage,
   createCriteriaUpdatedMessage,
@@ -334,4 +333,4 @@ export {
   createQueueStateMessage,
   storedEventToServerMessage
 };
-//# sourceMappingURL=chunk-CEZNMLOO.js.map
+//# sourceMappingURL=chunk-7TTEGAO6.js.map

package/dist/chunk-BU56QFHW.js

@@ -0,0 +1,315 @@
+import {
+  PathAccessDeniedError,
+  TurnMetrics,
+  WORKFLOW_KICKOFF_PROMPT,
+  assembleAgentRequest,
+  buildAgentReminder,
+  buildAgentSmallReminder,
+  createAssemblyResult,
+  createChatDoneEvent,
+  createMessageStartEvent,
+  findAgentById,
+  getAllInstructions,
+  getConversationMessages,
+  getEnabledSkillMetadata,
+  getSubAgents,
+  getToolRegistryForAgent,
+  loadAllAgentsDefault,
+  processEventsForConversation,
+  runTopLevelAgentLoop
+} from "./chunk-EQQDA4D3.js";
+import {
+  getCurrentContextWindowId,
+  getCurrentWindowMessageOptions,
+  getEventStore,
+  getRuntimeConfig
+} from "./chunk-NSBYORD5.js";
+import {
+  buildSnapshotFromSessionState
+} from "./chunk-ITWVFGFV.js";
+import {
+  logger
+} from "./chunk-K44MW7JJ.js";
+import {
+  getGlobalConfigDir
+} from "./chunk-CQGTEGKL.js";
+
+// 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
+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();
+  if (options.statsIdentity) {
+    return {
+      ...options.statsIdentity,
+      model
+    };
+  }
+  return {
+    providerId: `provider:${model}`,
+    providerName: "Unknown Provider",
+    backend: "unknown",
+    model
+  };
+}
+async function runChatTurn(options) {
+  const { sessionManager, sessionId } = options;
+  const eventStore = getEventStore();
+  const statsIdentity = resolveStatsIdentity(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 {
+    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);
+    if (deletedCount > 0) {
+      logger.debug("Cleaned up old events after snapshot", { sessionId, deletedCount, snapshotSeq: snapshotEvent.seq });
+    }
+  } catch (error) {
+    if (error instanceof PathAccessDeniedError) {
+      const errorMsgId2 = crypto.randomUUID();
+      const reasonText = error.reason === "sensitive_file" ? "sensitive files that may contain secrets" : error.reason === "both" ? "files outside the project and sensitive files" : "files outside the project directory";
+      eventStore.append(sessionId, {
+        type: "chat.error",
+        data: {
+          error: `User denied access to ${reasonText}.`,
+          recoverable: false
+        }
+      });
+      eventStore.append(
+        sessionId,
+        createMessageStartEvent(
+          errorMsgId2,
+          "user",
+          `Access denied: ${error.paths.join(", ")}. If you need this file, explain why and ask the user for permission.`,
+          {
+            ...getCurrentWindowMessageOptions(sessionId) ?? {},
+            isSystemGenerated: true,
+            messageKind: "correction"
+          }
+        )
+      );
+      eventStore.append(sessionId, createChatDoneEvent(errorMsgId2, "error"));
+      return;
+    }
+    if (error instanceof Error && error.message === "Aborted") {
+      const snapshot = buildSnapshot(sessionManager, sessionId, turnMetrics.buildStats(statsIdentity, mode));
+      eventStore.append(sessionId, { type: "turn.snapshot", data: snapshot });
+      return;
+    }
+    logger.error("Chat turn error", { sessionId, mode, error });
+    const errorMsgId = crypto.randomUUID();
+    eventStore.append(sessionId, {
+      type: "chat.error",
+      data: {
+        error: error instanceof Error ? error.message : "Unknown error",
+        recoverable: false
+      }
+    });
+    eventStore.append(
+      sessionId,
+      createMessageStartEvent(
+        errorMsgId,
+        "user",
+        `Error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        {
+          ...getCurrentWindowMessageOptions(sessionId) ?? {},
+          isSystemGenerated: true,
+          messageKind: "correction"
+        }
+      )
+    );
+    eventStore.append(sessionId, createChatDoneEvent(errorMsgId, "error"));
+  } finally {
+    eventStore.append(sessionId, { type: "running.changed", data: { isRunning: false } });
+  }
+}
+function injectAgentReminder(sessionId, agentDef) {
+  const eventStore = getEventStore();
+  const currentWindowId = getCurrentContextWindowId(sessionId);
+  let latestAgentName;
+  const events = eventStore.getAllEvents(sessionId);
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (event.type === "message.start") {
+      const data = event.data;
+      if (data.isSystemGenerated && data.metadata?.type === "agent" && (data.contextWindowId === currentWindowId || !currentWindowId && !data.contextWindowId)) {
+        latestAgentName = data.metadata.name;
+        break;
+      }
+    }
+  }
+  const currentAgentName = agentDef.metadata.name ?? agentDef.metadata.id;
+  const isSmallReminder = latestAgentName === currentAgentName;
+  const content = isSmallReminder ? buildAgentSmallReminder(currentAgentName) : buildAgentReminder(agentDef);
+  const reminderMsgId = crypto.randomUUID();
+  const currentWindowMessageOptions = currentWindowId ? { contextWindowId: currentWindowId } : void 0;
+  eventStore.append(sessionId, {
+    type: "message.start",
+    data: {
+      messageId: reminderMsgId,
+      role: "user",
+      content,
+      ...currentWindowMessageOptions ?? {},
+      isSystemGenerated: true,
+      messageKind: "auto-prompt",
+      metadata: {
+        type: "agent",
+        name: currentAgentName,
+        color: agentDef.metadata.color ?? "#6b7280",
+        kind: isSmallReminder ? "reminder" : "definition"
+      }
+    }
+  });
+  eventStore.append(sessionId, {
+    type: "message.done",
+    data: { messageId: reminderMsgId }
+  });
+}
+async function runAgentTurn(options, turnMetrics, agentId, append, callbacks) {
+  const statsIdentity = resolveStatsIdentity(options);
+  const allAgents = await loadAllAgentsDefault();
+  const agentDef = findAgentById(agentId, allAgents) ?? findAgentById("planner", allAgents);
+  injectAgentReminder(options.sessionId, agentDef);
+  const subAgentDefs = getSubAgents(allAgents);
+  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) => {
+        const cached = options.sessionManager.getCachedPrompt(options.sessionId);
+        if (cached) {
+          const currentHash = computeDynamicContextHash(instructionContent ?? "", skills);
+          if (cached.hash !== currentHash) {
+            options.sessionManager.setDynamicContextChanged(options.sessionId, true);
+          }
+          return createAssemblyResult({
+            systemPrompt: cached.systemPrompt,
+            messages: input.messages,
+            injectedFiles: input.injectedFiles,
+            requestTools: input.promptTools,
+            toolChoice: input.toolChoice,
+            disableThinking: false
+          });
+        }
+        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;
+      },
+      getToolRegistry: () => getToolRegistryForAgent(agentDef),
+      getConversationMessages: buildGetConversationMessages(options.sessionId, options.llmClient, append),
+      injectAgentReminder: () => injectAgentReminder(options.sessionId, agentDef),
+      ...callbacks?.injectKickoff ? { injectKickoff: callbacks.injectKickoff } : {},
+      ...callbacks?.onToolExecuted ? { onToolExecuted: callbacks.onToolExecuted } : {}
+    },
+    turnMetrics
+  );
+}
+function injectWorkflowKickoffIfNeeded(sessionManager, sessionId, eventStore) {
+  const session = sessionManager.requireSession(sessionId);
+  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");
+  });
+  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();
+  const session = sessionManager.requireSession(sessionId);
+  const events = eventStore.getEvents(sessionId);
+  const latestSeq = eventStore.getLatestSeq(sessionId) ?? 0;
+  const cachedPrompt = sessionManager.getCachedPrompt(sessionId);
+  return buildSnapshotFromSessionState({
+    session,
+    events,
+    latestSeq,
+    ...cachedPrompt ? { cachedSystemPrompt: cachedPrompt.systemPrompt, dynamicContextHash: cachedPrompt.hash } : {}
+  });
+}
+
+export {
+  computeDynamicContextHash,
+  runChatTurn,
+  runAgentTurn,
+  injectWorkflowKickoffIfNeeded
+};
+//# sourceMappingURL=chunk-BU56QFHW.js.map

package/dist/{chunk-FQLK5GL5.js → chunk-BVHFMAVN.js}

@@ -26,4 +26,4 @@ export {
   isClientMessage,
   isServerMessage
 };
-//# sourceMappingURL=chunk-FQLK5GL5.js.map
+//# sourceMappingURL=chunk-BVHFMAVN.js.map

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

@@ -2,11 +2,14 @@ import {
   clearModelCache,
   createLLMClient,
   detectModel
-} from "./chunk-HHAJ3QF6.js";
+} from "./chunk-UKTPL5ZG.js";
 import {
+  buildModelsUrl,
   detectBackend,
-  getModelProfile
-} from "./chunk-HGAMIPFO.js";
+  ensureVersionPrefix,
+  getModelProfile,
+  stripVersionPrefix
+} from "./chunk-VIIRNJDT.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -67,7 +70,7 @@ function mergeModelsWithUserOverrides(backendModels, userModels) {
   return updatedModels;
 }
 async function fetchAvailableModelsFromBackend(baseUrl, apiKey) {
-  const url = baseUrl.includes("/v1") ? `${baseUrl}/models` : `${baseUrl}/v1/models`;
+  const url = buildModelsUrl(baseUrl);
   const models = await fetchModelsFromBackend(url, apiKey);
   return models.map((m) => m.id);
 }
@@ -78,7 +81,7 @@ async function fetchModelsWithContext(baseUrl, apiKey, backend) {
     return fetchOllamaModelsWithContext(baseUrl, apiKey);
   }
   const isOpenCodeGo = baseUrl.includes("opencode.ai/zen/go");
-  const url = isOpenCodeGo ? baseUrl.replace("/zen/go", "/zen").replace(/\/v1$/, "") + "/v1/models" : baseUrl.includes("/v1") ? `${baseUrl}/models` : `${baseUrl}/v1/models`;
+  const url = isOpenCodeGo ? buildModelsUrl(baseUrl.replace("/zen/go", "/zen")) : buildModelsUrl(baseUrl);
   logger.info("Fetching models via /v1/models", { url });
   const models = await fetchModelsFromBackend(url, apiKey);
   if (models.length === 0) return [];
@@ -177,7 +180,7 @@ function createProviderManager(config) {
       ...config,
       llm: {
         ...config.llm,
-        baseUrl: provider.url.includes("/v1") ? provider.url : `${provider.url}/v1`,
+        baseUrl: ensureVersionPrefix(provider.url),
         model,
         backend: provider.backend,
         ...provider.apiKey && { apiKey: provider.apiKey }
@@ -235,7 +238,7 @@ function createProviderManager(config) {
       const providerConfig = createConfigForProvider(provider, targetModel);
       const newClient = createLLMClient(providerConfig);
       try {
-        const url = provider.url.includes("/v1") ? provider.url.replace("/v1", "") : provider.url;
+        const url = stripVersionPrefix(provider.url);
         clearModelCache(url);
         const backend = provider.backend;
         logger.info("activateProvider fetching models", { providerId, providerName: provider.name, url, backend });
@@ -355,7 +358,7 @@ function createProviderManager(config) {
       if (provider.models && provider.models.length > 0) {
         return provider.models;
       }
-      const url = provider.url.includes("/v1") ? provider.url.replace("/v1", "") : provider.url;
+      const url = stripVersionPrefix(provider.url);
       const backend = provider.backend;
       return fetchModelsWithContext(url, provider.apiKey, backend);
     },
@@ -466,7 +469,7 @@ function createProviderManager(config) {
       if (!provider) {
         return { success: false, error: "Provider not found" };
       }
-      const url = provider.url.includes("/v1") ? provider.url.replace("/v1", "") : provider.url;
+      const url = stripVersionPrefix(provider.url);
       const backend = provider.backend;
       logger.info("refreshProviderModels fetching models", { providerId, providerName: provider.name, url, backend });
       const modelsWithContext = await fetchModelsWithContext(url, provider.apiKey, backend);
@@ -511,4 +514,4 @@ export {
   parseDefaultModelSelection,
   createProviderManager
 };
-//# sourceMappingURL=chunk-RF2JGDSS.js.map
+//# sourceMappingURL=chunk-DMH6JVPF.js.map