openfox 0.2.4 → 1.0.0

package/dist/chunk-S4QKTRGJ.js

@@ -0,0 +1,343 @@
+import {
+  createServerMessage,
+  isClientMessage
+} from "./chunk-TPT6HP4H.js";
+
+// src/server/ws/protocol.ts
+function enrichMessagesWithToolResults(messages) {
+  const resultMap = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    if (msg.role === "tool" && msg.toolCallId && msg.toolResult) {
+      resultMap.set(msg.toolCallId, msg.toolResult);
+    }
+  }
+  if (resultMap.size === 0) return messages;
+  return messages.map((msg) => {
+    if (msg.role !== "assistant" || !msg.toolCalls?.length) return msg;
+    const needsEnrichment = msg.toolCalls.some((tc) => !tc.result && resultMap.has(tc.id));
+    if (!needsEnrichment) return msg;
+    return {
+      ...msg,
+      toolCalls: msg.toolCalls.map((tc) => {
+        if (tc.result) return tc;
+        const result = resultMap.get(tc.id);
+        return result ? { ...tc, result } : tc;
+      })
+    };
+  });
+}
+function parseClientMessage(data) {
+  try {
+    const parsed = JSON.parse(data);
+    if (isClientMessage(parsed)) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function serializeServerMessage(message) {
+  return JSON.stringify(message);
+}
+function createErrorMessage(code, message, correlationId) {
+  return createServerMessage("error", { code, message }, correlationId);
+}
+function createSessionStateMessage(session, messages, pendingConfirmations = [], correlationId) {
+  const enrichedMessages = enrichMessagesWithToolResults(messages);
+  return createServerMessage("session.state", { session, messages: enrichedMessages, pendingConfirmations }, correlationId);
+}
+function createSessionListMessage(sessions, correlationId) {
+  return createServerMessage("session.list", { sessions }, correlationId);
+}
+function createSessionRunningMessage(isRunning) {
+  return createServerMessage("session.running", { isRunning });
+}
+function createProjectStateMessage(project, correlationId) {
+  return createServerMessage("project.state", { project }, correlationId);
+}
+function createProjectListMessage(projects, correlationId) {
+  return createServerMessage("project.list", { projects }, correlationId);
+}
+function createChatDeltaMessage(messageId, content) {
+  return createServerMessage("chat.delta", { messageId, content });
+}
+function createChatThinkingMessage(messageId, content) {
+  return createServerMessage("chat.thinking", { messageId, content });
+}
+function createChatToolPreparingMessage(messageId, index, name) {
+  return createServerMessage("chat.tool_preparing", { messageId, index, name });
+}
+function createChatToolCallMessage(messageId, callId, tool, args) {
+  return createServerMessage("chat.tool_call", { messageId, callId, tool, args });
+}
+function createChatToolResultMessage(messageId, callId, tool, result) {
+  return createServerMessage("chat.tool_result", { messageId, callId, tool, result });
+}
+function createChatToolOutputMessage(messageId, callId, output, stream) {
+  return createServerMessage("chat.tool_output", { messageId, callId, output, stream });
+}
+function createChatTodoMessage(todos) {
+  return createServerMessage("chat.todo", { todos });
+}
+function createChatSummaryMessage(summary) {
+  return createServerMessage("chat.summary", { summary });
+}
+function createChatProgressMessage(message, phase) {
+  return createServerMessage("chat.progress", { message, ...phase ? { phase } : {} });
+}
+function createChatFormatRetryMessage(attempt, maxAttempts) {
+  return createServerMessage("chat.format_retry", { attempt, maxAttempts });
+}
+function createChatMessageMessage(message) {
+  return createServerMessage("chat.message", { message });
+}
+function createChatMessageUpdatedMessage(messageId, updates) {
+  return createServerMessage("chat.message_updated", { messageId, updates });
+}
+function createChatDoneMessage(messageId, reason, stats) {
+  return createServerMessage("chat.done", { messageId, reason, ...stats ? { stats } : {} });
+}
+function createChatErrorMessage(error, recoverable) {
+  return createServerMessage("chat.error", { error, recoverable });
+}
+function createChatPathConfirmationMessage(callId, tool, paths, workdir, reason) {
+  return createServerMessage("chat.path_confirmation", { 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 } : {} });
+}
+function createPhaseChangedMessage(phase) {
+  return createServerMessage("phase.changed", { phase });
+}
+function createCriteriaUpdatedMessage(criteria, changedId) {
+  return createServerMessage("criteria.updated", { criteria, ...changedId ? { changedId } : {} });
+}
+function createContextStateMessage(context) {
+  return createServerMessage("context.state", { context });
+}
+function createSessionNameGeneratedMessage(name, sessionId) {
+  const msg = {
+    type: "session.name_generated",
+    payload: { name }
+  };
+  if (sessionId) {
+    msg.sessionId = sessionId;
+  }
+  return msg;
+}
+function isSessionLoadPayload(payload) {
+  return typeof payload === "object" && payload !== null && "sessionId" in payload;
+}
+function isChatSendPayload(payload) {
+  return typeof payload === "object" && payload !== null && "content" in payload;
+}
+function isModeSwitchPayload(payload) {
+  return typeof payload === "object" && payload !== null && "mode" in payload;
+}
+function isCriteriaEditPayload(payload) {
+  return typeof payload === "object" && payload !== null && "criteria" in payload;
+}
+function isPathConfirmPayload(payload) {
+  return typeof payload === "object" && payload !== null && "callId" in payload && "approved" in payload;
+}
+function isAskAnswerPayload(payload) {
+  return typeof payload === "object" && payload !== null && "callId" in payload && "answer" in payload;
+}
+function createQueueStateMessage(messages) {
+  return createServerMessage("queue.state", { messages });
+}
+function isQueueAsapPayload(payload) {
+  return typeof payload === "object" && payload !== null && "content" in payload && typeof payload.content === "string";
+}
+function isQueueCompletionPayload(payload) {
+  return typeof payload === "object" && payload !== null && "content" in payload && typeof payload.content === "string";
+}
+function isQueueCancelPayload(payload) {
+  return typeof payload === "object" && payload !== null && "queueId" in payload && typeof payload.queueId === "string";
+}
+function storedEventToServerMessage(event) {
+  switch (event.type) {
+    case "message.start": {
+      const data = event.data;
+      const isUserOrSystem = data.role === "user" || data.role === "system";
+      const message = {
+        id: data.messageId,
+        role: data.role,
+        content: data.content ?? "",
+        timestamp: new Date(event.timestamp).toISOString(),
+        tokenCount: 0,
+        isStreaming: !isUserOrSystem,
+        // Only assistant messages stream
+        ...data.contextWindowId ? { contextWindowId: data.contextWindowId } : {},
+        ...data.subAgentId ? { subAgentId: data.subAgentId } : {},
+        ...data.subAgentType ? { subAgentType: data.subAgentType } : {},
+        ...data.isSystemGenerated ? { isSystemGenerated: data.isSystemGenerated } : {},
+        ...data.messageKind ? { messageKind: data.messageKind } : {},
+        ...data.isCompactionSummary ? { isCompactionSummary: data.isCompactionSummary } : {},
+        ...data.attachments ? { attachments: data.attachments } : {}
+      };
+      return createChatMessageMessage(message);
+    }
+    case "message.delta": {
+      const data = event.data;
+      return createChatDeltaMessage(data.messageId, data.content);
+    }
+    case "message.thinking": {
+      const data = event.data;
+      return createChatThinkingMessage(data.messageId, data.content);
+    }
+    case "message.done": {
+      const data = event.data;
+      const updates = { isStreaming: false };
+      if (data.partial) {
+        updates.partial = true;
+      }
+      if (data.stats) {
+        updates.stats = data.stats;
+      }
+      if (data.promptContext) {
+        updates.promptContext = data.promptContext;
+      }
+      return createChatMessageUpdatedMessage(data.messageId, updates);
+    }
+    case "tool.preparing": {
+      const data = event.data;
+      return createChatToolPreparingMessage(data.messageId, data.index, data.name);
+    }
+    case "tool.call": {
+      const data = event.data;
+      return createChatToolCallMessage(
+        data.messageId,
+        data.toolCall.id,
+        data.toolCall.name,
+        data.toolCall.arguments
+      );
+    }
+    case "tool.output": {
+      const data = event.data;
+      return createChatToolOutputMessage("", data.toolCallId, data.content, data.stream);
+    }
+    case "tool.result": {
+      const data = event.data;
+      return createChatToolResultMessage(
+        data.messageId,
+        data.toolCallId,
+        "",
+        // Tool name not available in event, but not used by frontend for matching
+        data.result
+      );
+    }
+    case "phase.changed": {
+      const data = event.data;
+      return createPhaseChangedMessage(data.phase);
+    }
+    case "task.completed": {
+      const data = event.data;
+      return createServerMessage("task.completed", data);
+    }
+    case "mode.changed": {
+      const data = event.data;
+      return createModeChangedMessage(data.mode, data.auto, data.reason);
+    }
+    case "running.changed": {
+      const data = event.data;
+      return createSessionRunningMessage(data.isRunning);
+    }
+    case "criteria.set": {
+      const data = event.data;
+      return createCriteriaUpdatedMessage(data.criteria);
+    }
+    case "criterion.updated": {
+      return null;
+    }
+    case "context.state": {
+      const data = event.data;
+      return createContextStateMessage(data);
+    }
+    case "session.name_generated": {
+      const data = event.data;
+      return {
+        type: "session.name_generated",
+        payload: { name: data.name },
+        sessionId: event.sessionId
+      };
+    }
+    case "todo.updated": {
+      const data = event.data;
+      return createChatTodoMessage(data.todos);
+    }
+    case "chat.done": {
+      const data = event.data;
+      return createChatDoneMessage(data.messageId, data.reason, data.stats);
+    }
+    case "chat.error": {
+      const data = event.data;
+      return createChatErrorMessage(data.error, data.recoverable);
+    }
+    case "chat.ask_user": {
+      const data = event.data;
+      return createChatAskUserMessage(data.callId, data.question);
+    }
+    case "format.retry": {
+      const data = event.data;
+      return createChatFormatRetryMessage(data.attempt, data.maxAttempts);
+    }
+    case "turn.snapshot":
+    case "context.compacted":
+      return null;
+    default:
+      return null;
+  }
+}
+
+export {
+  parseClientMessage,
+  serializeServerMessage,
+  createErrorMessage,
+  createSessionStateMessage,
+  createSessionListMessage,
+  createSessionRunningMessage,
+  createProjectStateMessage,
+  createProjectListMessage,
+  createChatDeltaMessage,
+  createChatThinkingMessage,
+  createChatToolPreparingMessage,
+  createChatToolCallMessage,
+  createChatToolResultMessage,
+  createChatToolOutputMessage,
+  createChatTodoMessage,
+  createChatSummaryMessage,
+  createChatProgressMessage,
+  createChatFormatRetryMessage,
+  createChatMessageMessage,
+  createChatMessageUpdatedMessage,
+  createChatDoneMessage,
+  createChatErrorMessage,
+  createChatPathConfirmationMessage,
+  createChatAskUserMessage,
+  createChatVisionFallbackMessage,
+  createModeChangedMessage,
+  createPhaseChangedMessage,
+  createCriteriaUpdatedMessage,
+  createContextStateMessage,
+  createSessionNameGeneratedMessage,
+  isSessionLoadPayload,
+  isChatSendPayload,
+  isModeSwitchPayload,
+  isCriteriaEditPayload,
+  isPathConfirmPayload,
+  isAskAnswerPayload,
+  createQueueStateMessage,
+  isQueueAsapPayload,
+  isQueueCompletionPayload,
+  isQueueCancelPayload,
+  storedEventToServerMessage
+};
+//# sourceMappingURL=chunk-S4QKTRGJ.js.map

package/dist/{chunk-ARFK3RZW.js → chunk-TPT6HP4H.js}

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

package/dist/chunk-TVQOONDR.js

@@ -0,0 +1,75 @@
+// src/server/config.ts
+import { z } from "zod";
+var backendSchema = z.enum(["auto", "vllm", "sglang", "ollama", "llamacpp"]).default("auto");
+var visionFallbackSchema = z.object({
+  enabled: z.boolean().default(false),
+  url: z.string().default("http://localhost:11434"),
+  model: z.string().default("qwen3-vl:2b")
+});
+var envSchema = z.object({
+  // New env var name, with fallback to old name for backward compatibility
+  OPENFOX_LLM_URL: z.string().url().optional(),
+  OPENFOX_VLLM_URL: z.string().url().optional(),
+  OPENFOX_BACKEND: backendSchema,
+  OPENFOX_MODEL_NAME: z.string().default("qwen3.5-122b-int4-autoround"),
+  OPENFOX_MAX_CONTEXT: z.coerce.number().default(2e5),
+  OPENFOX_PORT: z.coerce.number().default(10369),
+  OPENFOX_HOST: z.string().default("0.0.0.0"),
+  OPENFOX_WORKDIR: z.string().optional(),
+  OPENFOX_DB_PATH: z.string().default("./openfox.db"),
+  OPENFOX_LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  OPENFOX_DISABLE_THINKING: z.coerce.boolean().default(false),
+  OPENFOX_DEV: z.coerce.boolean().default(false)
+});
+function loadConfig() {
+  const env = envSchema.parse(process.env);
+  const llmUrl = env.OPENFOX_LLM_URL ?? env.OPENFOX_VLLM_URL ?? "http://localhost:8000/v1";
+  const workdir = env.OPENFOX_WORKDIR ?? process.cwd();
+  return {
+    llm: {
+      baseUrl: llmUrl,
+      model: env.OPENFOX_MODEL_NAME,
+      timeout: 3e5,
+      // 5 minutes (deprecated, kept for backward compatibility)
+      idleTimeout: 3e5,
+      // 5 minutes of inactivity
+      backend: env.OPENFOX_BACKEND,
+      disableThinking: env.OPENFOX_DISABLE_THINKING
+    },
+    context: {
+      maxTokens: env.OPENFOX_MAX_CONTEXT,
+      compactionThreshold: 0.85,
+      compactionTarget: 0.6
+    },
+    agent: {
+      maxIterations: 10,
+      maxConsecutiveFailures: 3,
+      toolTimeout: 12e4
+    },
+    server: {
+      port: env.OPENFOX_PORT,
+      host: env.OPENFOX_HOST
+    },
+    database: {
+      path: env.OPENFOX_DB_PATH
+    },
+    mode: env.OPENFOX_DEV ? "development" : "production",
+    workdir
+  };
+}
+
+// src/server/runtime-config.ts
+var runtimeConfig = null;
+function setRuntimeConfig(config) {
+  runtimeConfig = config;
+}
+function getRuntimeConfig() {
+  return runtimeConfig ?? loadConfig();
+}
+
+export {
+  loadConfig,
+  setRuntimeConfig,
+  getRuntimeConfig
+};
+//# sourceMappingURL=chunk-TVQOONDR.js.map