openfox 0.2.4 → 1.0.1

package/dist/chunk-M2C5GEQR.js

@@ -0,0 +1,137 @@
+import {
+  logger
+} from "./chunk-PNBH3RAX.js";
+
+// src/server/llm/vision-fallback.ts
+var DEFAULT_CONFIG = {
+  enabled: false,
+  url: "http://localhost:11434",
+  model: "qwen3-vl:2b",
+  timeout: 12e4
+};
+var config = { ...DEFAULT_CONFIG };
+var configLoaded = false;
+var descriptionCache = /* @__PURE__ */ new Map();
+function clearDescriptionCache() {
+  descriptionCache.clear();
+}
+function setVisionFallbackConfig(newConfig) {
+  config = { ...config, ...newConfig };
+  configLoaded = true;
+  logger.debug("Vision fallback config updated", { config });
+}
+function getVisionFallbackConfig() {
+  return { ...config };
+}
+function isVisionFallbackEnabled() {
+  return config.enabled;
+}
+async function ensureVisionFallbackConfigLoaded() {
+  if (configLoaded) return;
+  try {
+    const { loadGlobalConfig, getVisionFallback } = await import("./config-GIFCEJDU.js");
+    const { getRuntimeConfig } = await import("./runtime-config-2XJJIMSC.js");
+    const runtimeConfig = getRuntimeConfig();
+    const mode = runtimeConfig.mode ?? "production";
+    const globalConfig = await loadGlobalConfig(mode);
+    const fallback = getVisionFallback(globalConfig);
+    config = {
+      enabled: fallback.enabled ?? false,
+      url: fallback.url ?? "http://localhost:11434",
+      model: fallback.model ?? "qwen3-vl:2b",
+      timeout: (fallback.timeout ?? 120) * 1e3
+    };
+    configLoaded = true;
+    logger.debug("Vision fallback config loaded from global config", { config });
+  } catch (error) {
+    logger.warn("Failed to load vision fallback config from global config", { error: error instanceof Error ? error.message : String(error) });
+  }
+}
+var IMAGE_PROMPT = `Describe this image in detail. Focus on:
+- What the image shows (UI, diagram, photo, etc.)
+- Any text visible in the image
+- Layout and visual structure
+- Key elements and their relationships
+
+Provide a concise but comprehensive description.`;
+async function describeImage(base64Data, options) {
+  await ensureVisionFallbackConfigLoaded();
+  if (!config.enabled) {
+    return "[Image - vision fallback not enabled]";
+  }
+  const cacheKey = `${base64Data.slice(0, 100)}:${options?.context ?? ""}`;
+  const cached = descriptionCache.get(cacheKey);
+  if (cached) {
+    logger.debug("Using cached image description");
+    return cached;
+  }
+  const timeout = options?.timeout ?? config.timeout;
+  try {
+    const url = `${config.url}/api/chat`;
+    const requestBody = {
+      model: config.model,
+      messages: [
+        {
+          role: "user",
+          content: options?.context ? `${IMAGE_PROMPT}
+
+Context: ${options.context}` : IMAGE_PROMPT,
+          images: [base64Data]
+        }
+      ],
+      stream: false,
+      think: false
+    };
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      logger.error("Vision fallback API error", { status: response.status, error: errorText });
+      return `[Image description failed: HTTP ${response.status}]`;
+    }
+    const data = await response.json();
+    const description = data.message?.content?.trim();
+    if (!description) {
+      logger.warn("Vision fallback returned empty description");
+      return "[Image - could not describe]";
+    }
+    descriptionCache.set(cacheKey, description);
+    logger.debug("Cached image description", { cacheKey: cacheKey.slice(0, 20) });
+    return description;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    logger.error("Vision fallback error", { error: message });
+    if (message.includes("abort")) {
+      return "[Image description timed out]";
+    }
+    return `[Image description failed: ${message}]`;
+  }
+}
+async function describeImageFromDataUrl(dataUrl, options) {
+  const base64Match = dataUrl.match(/^data:image\/[^;]+;base64,(.+)$/);
+  if (!base64Match || !base64Match[1]) {
+    return "[Invalid image data URL]";
+  }
+  return describeImage(base64Match[1], options);
+}
+
+export {
+  descriptionCache,
+  clearDescriptionCache,
+  setVisionFallbackConfig,
+  getVisionFallbackConfig,
+  isVisionFallbackEnabled,
+  ensureVisionFallbackConfigLoaded,
+  describeImage,
+  describeImageFromDataUrl
+};
+//# sourceMappingURL=chunk-M2C5GEQR.js.map

package/dist/chunk-OWDPT3M6.js

@@ -0,0 +1,314 @@
+import {
+  BUILDER_KICKOFF_PROMPT,
+  PathAccessDeniedError,
+  TurnMetrics,
+  VERIFIER_KICKOFF_PROMPT,
+  assembleAgentRequest,
+  buildAgentReminder,
+  createChatDoneEvent,
+  createMessageStartEvent,
+  executeSubAgent,
+  findAgentById,
+  getSubAgents,
+  getToolRegistryForAgent,
+  loadAllAgentsDefault,
+  runTopLevelAgentLoop
+} from "./chunk-ARKA56ZM.js";
+import {
+  getCurrentContextWindowId,
+  getEventStore
+} from "./chunk-BU2ZYOEA.js";
+import {
+  buildSnapshotFromSessionState
+} from "./chunk-2KSCZSXQ.js";
+import {
+  createChatMessageMessage
+} from "./chunk-S4QKTRGJ.js";
+import {
+  logger
+} from "./chunk-PNBH3RAX.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/orchestrator.ts
+function getCurrentWindowMessageOptions(sessionId) {
+  const contextWindowId = getCurrentContextWindowId(sessionId);
+  return contextWindowId ? { contextWindowId } : void 0;
+}
+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 });
+  const turnMetrics = new TurnMetrics();
+  try {
+    if (mode === "builder") {
+      await runBuilderTurn(options, turnMetrics);
+    } else {
+      await runGenericAgentTurn(options, turnMetrics, mode);
+    }
+    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") {
+      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 injectModeReminderIfNeeded(sessionManager, sessionId, agentId, allAgents, onMessage) {
+  const eventStore = getEventStore();
+  const session = sessionManager.requireSession(sessionId);
+  const lastModeReminder = session.executionState?.lastModeWithReminder;
+  if (lastModeReminder === agentId) {
+    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;
+  eventStore.append(sessionId, {
+    type: "message.start",
+    data: {
+      messageId: reminderMsgId,
+      role: "user",
+      content: reminderContent,
+      ...currentWindowMessageOptions ?? {},
+      isSystemGenerated: true,
+      messageKind: "auto-prompt",
+      metadata: {
+        type: "agent",
+        name: agentDef.metadata.name ?? agentDef.metadata.id,
+        color: agentDef.metadata.color ?? "#6b7280"
+      }
+    }
+  });
+  eventStore.append(sessionId, {
+    type: "message.done",
+    data: { messageId: reminderMsgId }
+  });
+  if (onMessage) {
+    onMessage(createChatMessageMessage({
+      id: reminderMsgId,
+      role: "user",
+      content: reminderContent,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      isSystemGenerated: true,
+      messageKind: "auto-prompt",
+      metadata: {
+        type: "agent",
+        name: agentDef.metadata.name ?? agentDef.metadata.id,
+        color: agentDef.metadata.color ?? "#6b7280"
+      }
+    }));
+  }
+  sessionManager.updateExecutionState(sessionId, {
+    lastModeWithReminder: agentId
+  });
+}
+async function runGenericAgentTurn(options, turnMetrics, agentId) {
+  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({
+    mode: agentId,
+    sessionManager: options.sessionManager,
+    sessionId: options.sessionId,
+    llmClient: options.llmClient,
+    statsIdentity,
+    signal: options.signal,
+    onMessage: options.onMessage,
+    assembleRequest: (input) => assembleAgentRequest({ ...input, agentDef, subAgentDefs }),
+    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 }),
+      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);
+        }
+      },
+      injectKickoff: () => {
+        if (options.injectBuilderKickoff !== true) return;
+        const session = sessionManager.requireSession(sessionId);
+        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");
+        });
+        if (!hasBuilderKickoff) {
+          const kickoffMsgId = crypto.randomUUID();
+          const kickoffContent = BUILDER_KICKOFF_PROMPT(session.criteria.length);
+          eventStore.append(sessionId, createMessageStartEvent(kickoffMsgId, "user", kickoffContent, {
+            ...getCurrentWindowMessageOptions(sessionId) ?? {},
+            isSystemGenerated: true,
+            messageKind: "auto-prompt",
+            metadata: { type: "agent", name: "Builder", color: "#22c55e" }
+          }));
+          eventStore.append(sessionId, { type: "message.done", data: { messageId: kickoffMsgId } });
+        }
+      }
+    }, turnMetrics),
+    stepDoneCalled
+  };
+}
+async function runVerifierTurn(options, turnMetrics) {
+  const { sessionManager, sessionId, llmClient, signal, onMessage } = options;
+  const statsIdentity = resolveStatsIdentity(options);
+  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()
+  });
+  return {
+    allPassed: result.allPassed ?? true,
+    failed: result.failed ?? [],
+    content: result.content
+  };
+}
+function buildSnapshot(sessionManager, sessionId, lastStats) {
+  const eventStore = getEventStore();
+  const session = sessionManager.requireSession(sessionId);
+  const events = eventStore.getEvents(sessionId);
+  const latestSeq = eventStore.getLatestSeq(sessionId) ?? 0;
+  return buildSnapshotFromSessionState({
+    session,
+    events,
+    latestSeq
+  });
+}
+
+export {
+  createVerifierNudgeConfig,
+  runChatTurn,
+  filterToolRegistryForStepDone,
+  runBuilderTurn,
+  runVerifierTurn
+};
+//# sourceMappingURL=chunk-OWDPT3M6.js.map

package/dist/{chunk-U62ZECSQ.js → chunk-PNBH3RAX.js}

@@ -8,7 +8,7 @@ var LEVELS = {
 var currentLevel = "info";
 function setLogLevel(level, mode) {
   if (mode && !level) {
-    currentLevel = mode === "development" ? "debug" : "warn";
+    currentLevel = mode === "development" ? "debug" : mode === "test" ? "error" : "warn";
   } else {
     currentLevel = level ?? "info";
   }
@@ -51,4 +51,4 @@ export {
   setLogLevel,
   logger
 };
-//# sourceMappingURL=chunk-U62ZECSQ.js.map
+//# sourceMappingURL=chunk-PNBH3RAX.js.map

package/dist/chunk-QDEKU5RL.js

@@ -0,0 +1,75 @@
+import {
+  logger
+} from "./chunk-PNBH3RAX.js";
+
+// src/server/session/name-generator.ts
+var SESSION_NAME_PROMPT = `Generate a concise, descriptive session name (max 50 characters) based on the user's message.
+Return ONLY the name, nothing else.
+
+Example inputs and outputs:
+- "How do I set up React?" \u2192 "React setup"
+- "Fix the authentication bug" \u2192 "Fix authentication bug"
+- "Add unit tests for the API" \u2192 "Add API unit tests"
+
+User message: {message}`;
+async function generateSessionName(options) {
+  const { userMessage, llmClient, signal } = options;
+  try {
+    logger.debug("Generating session name", { messagePreview: userMessage.slice(0, 50) });
+    const prompt = SESSION_NAME_PROMPT.replace("{message}", userMessage);
+    const messages = [
+      {
+        role: "user",
+        content: prompt
+      }
+    ];
+    const timeoutSignal = AbortSignal.timeout(6e4);
+    const composedSignal = signal ? AbortSignal.any([timeoutSignal, signal]) : timeoutSignal;
+    const response = await llmClient.complete({
+      messages,
+      tools: [],
+      signal: composedSignal,
+      disableThinking: true
+    });
+    let name = response.content.trim();
+    if (name.length > 50) {
+      name = name.substring(0, 47) + "...";
+    }
+    if (!name || name.length < 3) {
+      return {
+        success: false,
+        error: "Generated name is too short or empty"
+      };
+    }
+    logger.debug("Session name generated successfully", { name });
+    return {
+      success: true,
+      name
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error generating session name";
+    logger.debug("Session name generation error", { error: errorMessage });
+    return {
+      success: false,
+      error: errorMessage
+    };
+  }
+}
+function needsNameGeneration(sessionTitle, messageCount) {
+  if (messageCount > 1) {
+    return false;
+  }
+  if (!sessionTitle || sessionTitle.trim() === "") {
+    return true;
+  }
+  if (/^Session \d+$/.test(sessionTitle)) {
+    return true;
+  }
+  return false;
+}
+
+export {
+  generateSessionName,
+  needsNameGeneration
+};
+//# sourceMappingURL=chunk-QDEKU5RL.js.map