open-research 1.1.2 → 1.2.0

package/dist/chunk-CRSHN3PQ.js

@@ -0,0 +1,98 @@
+import {
+  readJsonFile,
+  writeJsonFile
+} from "./chunk-77Q5B5H7.js";
+import {
+  getOpenResearchConfigFile
+} from "./chunk-4HCPHCC2.js";
+
+// src/lib/config/store.ts
+import { z } from "zod";
+var themeValues = ["dark", "light"];
+var providerValues = ["openai", "gemini"];
+var openAIProviderConfigSchema = z.object({
+  apiKey: z.string().optional()
+}).optional();
+var geminiProviderConfigSchema = z.object({
+  apiKey: z.string().optional()
+}).optional();
+var openResearchConfigSchema = z.object({
+  version: z.literal(1),
+  defaults: z.object({
+    model: z.string().min(1),
+    reasoningEffort: z.enum(["low", "medium", "high", "xhigh"]),
+    editPolicy: z.literal("mixed")
+  }),
+  theme: z.enum(themeValues).default("dark"),
+  activeProvider: z.enum(providerValues).default("openai"),
+  lastWorkspace: z.string().nullable(),
+  providers: z.object({
+    openai: openAIProviderConfigSchema,
+    gemini: geminiProviderConfigSchema
+  }).optional(),
+  apiKeys: z.object({
+    openai: z.string().optional(),
+    semanticScholar: z.string().optional(),
+    openAlex: z.string().optional(),
+    brave: z.string().optional(),
+    gemini: z.string().optional()
+  }).optional()
+});
+var DEFAULT_OPEN_RESEARCH_CONFIG = {
+  version: 1,
+  defaults: {
+    model: "gpt-5.4",
+    reasoningEffort: "medium",
+    editPolicy: "mixed"
+  },
+  theme: "dark",
+  activeProvider: "openai",
+  lastWorkspace: null,
+  providers: {
+    openai: {},
+    gemini: {}
+  },
+  apiKeys: {}
+};
+function getConfiguredOpenAIApiKey(config) {
+  return config?.providers?.openai?.apiKey || config?.apiKeys?.openai;
+}
+function getSemanticScholarApiKey(config) {
+  return config?.apiKeys?.semanticScholar || process.env.SEMANTIC_SCHOLAR_API_KEY;
+}
+function getOpenAlexApiKey(config) {
+  return config?.apiKeys?.openAlex || process.env.OPENALEX_API_KEY;
+}
+function getBraveApiKey(config) {
+  return config?.apiKeys?.brave || process.env.BRAVE_API_KEY;
+}
+async function loadOpenResearchConfig(options) {
+  const configFile = getOpenResearchConfigFile(options);
+  const config = await readJsonFile(configFile, null);
+  if (!config) {
+    return null;
+  }
+  return openResearchConfigSchema.parse(config);
+}
+async function saveOpenResearchConfig(config, options) {
+  await writeJsonFile(getOpenResearchConfigFile(options), config);
+}
+async function ensureOpenResearchConfig(options) {
+  const existing = await loadOpenResearchConfig(options);
+  if (existing) {
+    return existing;
+  }
+  await writeJsonFile(getOpenResearchConfigFile(options), DEFAULT_OPEN_RESEARCH_CONFIG);
+  return DEFAULT_OPEN_RESEARCH_CONFIG;
+}
+
+export {
+  themeValues,
+  getConfiguredOpenAIApiKey,
+  getSemanticScholarApiKey,
+  getOpenAlexApiKey,
+  getBraveApiKey,
+  loadOpenResearchConfig,
+  saveOpenResearchConfig,
+  ensureOpenResearchConfig
+};

package/dist/chunk-EW27OWCA.js

@@ -0,0 +1,272 @@
+import {
+  selectModelForTask
+} from "./chunk-GVEVKDGV.js";
+
+// src/lib/agent/context-manager.ts
+var BYTES_PER_TOKEN = 4;
+function estimateTokens(text) {
+  const bytes = Buffer.byteLength(text, "utf8");
+  return Math.ceil(bytes / BYTES_PER_TOKEN);
+}
+function estimateMessageTokens(msg) {
+  let tokens = 4;
+  if (typeof msg.content === "string") {
+    tokens += estimateTokens(msg.content);
+  } else if (Array.isArray(msg.content)) {
+    for (const part of msg.content) {
+      if ("text" in part) tokens += estimateTokens(part.text);
+    }
+  }
+  if (msg.tool_calls) {
+    for (const tc of msg.tool_calls) {
+      tokens += estimateTokens(tc.function.name) + estimateTokens(tc.function.arguments);
+    }
+  }
+  return tokens;
+}
+function estimateConversationTokens(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    total += estimateMessageTokens(msg);
+  }
+  return total;
+}
+var MODEL_CONTEXT_WINDOWS = {
+  "gpt-5.4": 272e3,
+  "gpt-5.3-codex": 272e3,
+  "gpt-5.2-codex": 272e3,
+  "gpt-5.2": 272e3,
+  "gpt-5.1-codex": 272e3,
+  "gpt-5.1": 272e3,
+  "gpt-5": 272e3,
+  "gpt-4o": 128e3,
+  "gpt-5.4-mini": 128e3,
+  "o3": 2e5,
+  "o4-mini": 2e5,
+  "gemini-3.1-pro-preview": 1048576,
+  "gemini-3-flash-preview": 1048576
+};
+var DEFAULT_CONTEXT_WINDOW = 128e3;
+var AUTO_COMPACT_TOKEN_LIMIT = 25e4;
+function getContextWindow(model) {
+  return MODEL_CONTEXT_WINDOWS[model] ?? DEFAULT_CONTEXT_WINDOW;
+}
+function getCompactThreshold(model) {
+  const window = getContextWindow(model);
+  return window > AUTO_COMPACT_TOKEN_LIMIT ? AUTO_COMPACT_TOKEN_LIMIT : Math.floor(window * 0.8);
+}
+function emptyBreakdown() {
+  return { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 }, total: 0 };
+}
+function createSessionUsage() {
+  return {
+    cumulative: emptyBreakdown(),
+    lastTurn: emptyBreakdown(),
+    estimatedCurrentTokens: 0,
+    compactionCount: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    lastTurnTokens: 0
+  };
+}
+function updateUsageFromApi(usage, apiUsage) {
+  const cached = apiUsage.cachedTokens ?? 0;
+  const reasoning = apiUsage.reasoningTokens ?? 0;
+  const adjustedInput = Math.max(0, apiUsage.promptTokens - cached);
+  const adjustedOutput = Math.max(0, apiUsage.completionTokens - reasoning);
+  usage.cumulative.input += adjustedInput;
+  usage.cumulative.output += adjustedOutput;
+  usage.cumulative.reasoning += reasoning;
+  usage.cumulative.cache.read += cached;
+  usage.cumulative.total += apiUsage.totalTokens;
+  usage.lastTurn = {
+    input: adjustedInput,
+    output: adjustedOutput,
+    reasoning,
+    cache: { read: cached, write: 0 },
+    total: apiUsage.totalTokens
+  };
+  usage.inputTokens = usage.cumulative.input;
+  usage.outputTokens = usage.cumulative.output;
+  usage.totalTokens = usage.cumulative.total;
+  usage.lastTurnTokens = apiUsage.totalTokens;
+}
+var PRUNE_PROTECT_TOKENS = 4e4;
+var PRUNE_MIN_SAVINGS = 2e4;
+var PRUNE_SKIP_RECENT_USER_TURNS = 2;
+function pruneToolOutputs(messages) {
+  const userIndices = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") userIndices.push(i);
+  }
+  const protectBoundary = userIndices.length >= PRUNE_SKIP_RECENT_USER_TURNS ? userIndices[PRUNE_SKIP_RECENT_USER_TURNS - 1] : 0;
+  const toolIndices = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role === "tool" && i < protectBoundary) {
+      toolIndices.push(i);
+    }
+  }
+  if (toolIndices.length === 0) return { messages, savedTokens: 0 };
+  let protectedTokens = 0;
+  let cutoffIdx = toolIndices.length;
+  for (let i = toolIndices.length - 1; i >= 0; i--) {
+    const msg = messages[toolIndices[i]];
+    const tokens = estimateMessageTokens(msg);
+    if (protectedTokens + tokens > PRUNE_PROTECT_TOKENS) {
+      cutoffIdx = i;
+      break;
+    }
+    protectedTokens += tokens;
+  }
+  let savedTokens = 0;
+  const result = [...messages];
+  for (let i = 0; i < cutoffIdx; i++) {
+    const idx = toolIndices[i];
+    const msg = result[idx];
+    const oldTokens = estimateMessageTokens(msg);
+    const stub = "[output pruned \u2014 use read_file to re-read if needed]";
+    savedTokens += oldTokens - estimateTokens(stub);
+    result[idx] = { ...msg, content: stub };
+  }
+  if (savedTokens < PRUNE_MIN_SAVINGS) {
+    return { messages, savedTokens: 0 };
+  }
+  return { messages: result, savedTokens };
+}
+var COMPACTION_SYSTEM_PROMPT = `You are a conversation summarizer for a research agent. Your job is to create a handoff summary that another agent instance can use to seamlessly continue the work.
+
+Do not respond to any questions in the conversation. Only output the summary.
+Respond in the same language the user used.`;
+var COMPACTION_USER_TEMPLATE = `Provide a detailed summary of our conversation above for handoff to another agent that will continue the work.
+
+Stick to this template:
+
+## Goal
+[What is the user trying to accomplish? Be specific.]
+
+## Instructions
+- [Important instructions or preferences the user gave]
+- [Research methodology constraints or requirements]
+- [If there is a research charter or plan, summarize its key points]
+
+## Discoveries
+- [Key findings from paper searches, data analysis, or experiments]
+- [Important facts, numbers, or evidence discovered]
+- [Any surprising or contradicting results]
+
+## Accomplished
+- [What work has been completed]
+- [What is currently in progress]
+- [What remains to be done]
+
+## Relevant Files
+[List workspace files that were read, created, or modified. Include what each contains.]
+- path/to/file.md \u2014 description of contents
+- experiments/script.py \u2014 what it does and its results
+
+## Active Context
+- [Current research question or hypothesis being investigated]
+- [Which skills are active]
+- [Any pending user decisions or questions]
+
+## Next Steps
+1. [Most immediate next action]
+2. [Following action]
+3. [And so on]
+
+{CUSTOM_INSTRUCTIONS}`;
+async function compactConversation(messages, provider, model, customInstructions, signal) {
+  const systemMsg = messages.find((m) => m.role === "system");
+  const conversationMsgs = messages.filter((m) => m.role !== "system");
+  const conversationText = conversationMsgs.map((m) => {
+    const role = m.role === "assistant" ? "Agent" : m.role === "user" ? "User" : "Tool";
+    let content;
+    if (typeof m.content === "string") {
+      content = m.content.length > 3e3 ? m.content.slice(0, 3e3) + "\n[... truncated]" : m.content;
+    } else if (m.content) {
+      content = JSON.stringify(m.content).slice(0, 1e3);
+    } else if (m.tool_calls?.length) {
+      content = m.tool_calls.map((tc) => `[tool: ${tc.function.name}]`).join(", ");
+    } else {
+      content = "[empty]";
+    }
+    return `[${role}]: ${content}`;
+  }).join("\n\n");
+  const customBlock = customInstructions ? `
+
+Additional instructions: ${customInstructions}` : "";
+  const userPrompt = COMPACTION_USER_TEMPLATE.replace("{CUSTOM_INSTRUCTIONS}", customBlock);
+  const compactionModel = selectModelForTask(provider.kind, model, "compaction");
+  const summaryResponse = await provider.callLLM({
+    messages: [
+      { role: "system", content: COMPACTION_SYSTEM_PROMPT },
+      {
+        role: "user",
+        content: `Here is the conversation to summarize:
+
+${conversationText.slice(0, 12e4)}
+
+---
+
+${userPrompt}`
+      }
+    ],
+    model: compactionModel,
+    maxTokens: 4096
+  });
+  const compacted = [];
+  if (systemMsg) compacted.push(systemMsg);
+  compacted.push({
+    role: "user",
+    content: "What have we accomplished so far in this research session?"
+  });
+  compacted.push({
+    role: "assistant",
+    content: summaryResponse.content
+  });
+  return compacted;
+}
+async function maybeCompact(messages, model, provider, usage, signal) {
+  const estimated = estimateConversationTokens(messages);
+  usage.estimatedCurrentTokens = estimated;
+  const threshold = getCompactThreshold(model);
+  if (estimated < threshold) {
+    return { messages, didCompact: false };
+  }
+  const { messages: pruned, savedTokens } = pruneToolOutputs(messages);
+  const afterPrune = estimated - savedTokens;
+  if (afterPrune < threshold) {
+    usage.estimatedCurrentTokens = afterPrune;
+    usage.compactionCount++;
+    return { messages: pruned, didCompact: true };
+  }
+  const compacted = await compactConversation(pruned, provider, model, void 0, signal);
+  usage.estimatedCurrentTokens = estimateConversationTokens(compacted);
+  usage.compactionCount++;
+  return { messages: compacted, didCompact: true };
+}
+async function manualCompact(messages, model, provider, usage, customInstructions, signal) {
+  if (messages.length <= 2) {
+    return { messages, didCompact: false };
+  }
+  const { messages: pruned } = pruneToolOutputs(messages);
+  const compacted = await compactConversation(pruned, provider, model, customInstructions, signal);
+  usage.estimatedCurrentTokens = estimateConversationTokens(compacted);
+  usage.compactionCount++;
+  return { messages: compacted, didCompact: true };
+}
+
+export {
+  estimateTokens,
+  estimateMessageTokens,
+  estimateConversationTokens,
+  getContextWindow,
+  getCompactThreshold,
+  createSessionUsage,
+  updateUsageFromApi,
+  pruneToolOutputs,
+  compactConversation,
+  maybeCompact,
+  manualCompact
+};

package/dist/{chunk-HRVDYJEC.js → chunk-KOBMIIQM.js}

@@ -59,6 +59,7 @@ async function loadSessionHistory(workspaceDir, sessionId) {
   const events = parseEvents(raw);
   const messages = [];
   const llmHistory = [];
+  const turnSnapshots = [];
   for (const event of events) {
     if (event.type === "chat.turn") {
       const payload = event.payload;
@@ -76,8 +77,12 @@ async function loadSessionHistory(workspaceDir, sessionId) {
         llmHistory.push(...payload.llmHistory);
       }
     }
+    if (event.type === "snapshot.turn") {
+      const payload = event.payload;
+      turnSnapshots.push(payload);
+    }
   }
-  return { messages, llmHistory };
+  return { messages, llmHistory, turnSnapshots };
 }
 
 export {