open-research 1.0.0 → 1.0.1

package/dist/chunk-3GZIDCV2.js

@@ -0,0 +1,185 @@
+import {
+  readJsonFile,
+  writeJsonFile
+} from "./chunk-77Q5B5H7.js";
+import {
+  getOpenResearchAuthFile,
+  getOpenResearchGeminiAuthFile,
+  getOpenResearchRoot
+} from "./chunk-4HCPHCC2.js";
+
+// src/lib/auth/store.ts
+import fs from "fs/promises";
+var AUTH_FILE_MODE = 384;
+async function ensureCliHome(options) {
+  const root = getOpenResearchRoot(options);
+  await fs.mkdir(root, { recursive: true, mode: 448 });
+  return root;
+}
+async function saveStoredAuth(auth, options) {
+  await ensureCliHome(options);
+  const authFile = getOpenResearchAuthFile(options);
+  await writeJsonFile(authFile, auth, AUTH_FILE_MODE);
+  await fs.chmod(authFile, AUTH_FILE_MODE);
+  return authFile;
+}
+async function loadStoredAuth(options) {
+  const authFile = getOpenResearchAuthFile(options);
+  return readJsonFile(authFile, null);
+}
+async function clearStoredAuth(options) {
+  const authFile = getOpenResearchAuthFile(options);
+  await fs.rm(authFile, { force: true });
+}
+async function saveGeminiAuth(auth, options) {
+  await ensureCliHome(options);
+  const authFile = getOpenResearchGeminiAuthFile(options);
+  await writeJsonFile(authFile, auth, AUTH_FILE_MODE);
+  await fs.chmod(authFile, AUTH_FILE_MODE);
+  return authFile;
+}
+async function loadGeminiAuth(options) {
+  const authFile = getOpenResearchGeminiAuthFile(options);
+  return readJsonFile(authFile, null);
+}
+
+// src/lib/auth/gemini-oauth.ts
+var GEMINI_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+var GEMINI_TOKEN_URL = "https://oauth2.googleapis.com/token";
+var GEMINI_USERINFO_URL = "https://www.googleapis.com/oauth2/v1/userinfo";
+var GEMINI_CODE_ASSIST_URL = "https://cloudcode-pa.googleapis.com";
+var GEMINI_CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com";
+var GEMINI_CLIENT_SECRET = "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";
+var GEMINI_SCOPES = "https://www.googleapis.com/auth/cloud-platform openid email profile";
+function getGeminiRedirectUri(port) {
+  return `http://127.0.0.1:${port}/oauth2callback`;
+}
+function buildGeminiAuthorizationUrl(input) {
+  const params = new URLSearchParams({
+    client_id: GEMINI_CLIENT_ID,
+    response_type: "code",
+    redirect_uri: getGeminiRedirectUri(input.port),
+    scope: GEMINI_SCOPES,
+    state: input.state,
+    access_type: "offline",
+    prompt: "consent"
+  });
+  return `${GEMINI_AUTH_URL}?${params}`;
+}
+async function exchangeGeminiCodeForTokens(code, redirectUri) {
+  const response = await fetch(GEMINI_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: GEMINI_CLIENT_ID,
+      client_secret: GEMINI_CLIENT_SECRET,
+      code,
+      grant_type: "authorization_code",
+      redirect_uri: redirectUri
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Gemini token exchange failed: ${response.status} ${text}`);
+  }
+  return response.json();
+}
+async function refreshGeminiAccessToken(refreshToken) {
+  const response = await fetch(GEMINI_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: GEMINI_CLIENT_ID,
+      client_secret: GEMINI_CLIENT_SECRET,
+      refresh_token: refreshToken,
+      grant_type: "refresh_token"
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Gemini token refresh failed: ${response.status} ${text}`);
+  }
+  return response.json();
+}
+async function getGeminiUserEmail(accessToken) {
+  const response = await fetch(`${GEMINI_USERINFO_URL}?alt=json`, {
+    headers: { Authorization: `Bearer ${accessToken}` }
+  });
+  if (!response.ok) return "unknown";
+  const data = await response.json();
+  return data.email ?? "unknown";
+}
+async function loadCodeAssistProject(accessToken) {
+  const response = await fetch(`${GEMINI_CODE_ASSIST_URL}/v1internal:loadCodeAssist`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      metadata: {
+        ideType: "IDE_UNSPECIFIED",
+        platform: "PLATFORM_UNSPECIFIED",
+        pluginType: "GEMINI"
+      }
+    })
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`loadCodeAssist failed: ${response.status} ${text}`);
+  }
+  const data = await response.json();
+  const project = data.cloudaicompanionProject;
+  if (typeof project === "string") return project;
+  if (project && typeof project === "object" && "id" in project) return project.id;
+  if (data.allowedTiers?.length) {
+    return onboardUser(accessToken);
+  }
+  throw new Error("Could not determine Gemini project ID. You may need a Google AI subscription.");
+}
+async function onboardUser(accessToken) {
+  const response = await fetch(`${GEMINI_CODE_ASSIST_URL}/v1internal:onboardUser`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({})
+  });
+  if (!response.ok) {
+    throw new Error(`Gemini onboarding failed: ${response.status}`);
+  }
+  const data = await response.json();
+  if (data.done && data.response?.cloudaicompanionProject) {
+    return data.response.cloudaicompanionProject;
+  }
+  if (data.name) {
+    for (let i = 0; i < 10; i++) {
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      const poll = await fetch(`${GEMINI_CODE_ASSIST_URL}/v1internal/${data.name}`, {
+        headers: { Authorization: `Bearer ${accessToken}` }
+      });
+      if (!poll.ok) continue;
+      const result = await poll.json();
+      if (result.done && result.response?.cloudaicompanionProject) {
+        return result.response.cloudaicompanionProject;
+      }
+    }
+  }
+  throw new Error("Gemini onboarding timed out. Try again.");
+}
+
+export {
+  saveStoredAuth,
+  loadStoredAuth,
+  clearStoredAuth,
+  saveGeminiAuth,
+  loadGeminiAuth,
+  GEMINI_CODE_ASSIST_URL,
+  getGeminiRedirectUri,
+  buildGeminiAuthorizationUrl,
+  exchangeGeminiCodeForTokens,
+  refreshGeminiAccessToken,
+  getGeminiUserEmail,
+  loadCodeAssistProject
+};

package/dist/{chunk-TQSQRNX6.js → chunk-3KZN54JZ.js}

@@ -1,38 +1,24 @@
+import {
+  readJsonFile,
+  writeJsonFile
+} from "./chunk-77Q5B5H7.js";
 import {
   getOpenResearchConfigFile
-} from "./chunk-I5NVYKG7.js";
+} from "./chunk-4HCPHCC2.js";
+import {
+  getProviderCatalog
+} from "./chunk-GVEVKDGV.js";
 
 // src/lib/config/store.ts
 import { z } from "zod";
-
-// src/lib/fs/json.ts
-import fs from "fs/promises";
-import path from "path";
-async function readJsonFile(filePath, fallback) {
-  try {
-    const raw = await fs.readFile(filePath, "utf8");
-    return JSON.parse(raw);
-  } catch (error) {
-    const code = typeof error === "object" && error && "code" in error ? String(error.code) : "";
-    if (code === "ENOENT") {
-      return fallback;
-    }
-    throw error;
-  }
-}
-async function writeJsonFile(filePath, value, mode) {
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-  await fs.writeFile(filePath, JSON.stringify(value, null, 2), {
-    encoding: "utf8",
-    mode
-  });
-}
-
-// src/lib/config/store.ts
 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({
@@ -41,15 +27,18 @@ var openResearchConfigSchema = z.object({
     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
+    openai: openAIProviderConfigSchema,
+    gemini: geminiProviderConfigSchema
   }).optional(),
   apiKeys: z.object({
     openai: z.string().optional(),
     semanticScholar: z.string().optional(),
     openAlex: z.string().optional(),
-    brave: z.string().optional()
+    brave: z.string().optional(),
+    gemini: z.string().optional()
   }).optional()
 });
 var DEFAULT_OPEN_RESEARCH_CONFIG = {
@@ -60,9 +49,11 @@ var DEFAULT_OPEN_RESEARCH_CONFIG = {
     editPolicy: "mixed"
   },
   theme: "dark",
+  activeProvider: "openai",
   lastWorkspace: null,
   providers: {
-    openai: {}
+    openai: {},
+    gemini: {}
   },
   apiKeys: {}
 };
@@ -235,10 +226,10 @@ async function executeFetchUrl(args, signal) {
 }
 
 // src/lib/fs/pdf.ts
-import fs2 from "fs/promises";
+import fs from "fs/promises";
 async function extractPdfText(filePath, options) {
   const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
-  const buffer = await fs2.readFile(filePath);
+  const buffer = await fs.readFile(filePath);
   const document = await pdfjs.getDocument({ data: new Uint8Array(buffer) }).promise;
   const totalPages = document.numPages;
   const start = Math.max(1, options?.startPage ?? 1);
@@ -433,7 +424,7 @@ async function extractWithTarget(input, provider) {
         { role: "system", content: systemPrompt },
         { role: "user", content: truncatedContent }
       ],
-      model: "gpt-5.4-mini",
+      model: getProviderCatalog(provider.kind).backgroundModel,
       temperature: 0,
       maxTokens: 1500,
       jsonSchema: EXTRACTION_SCHEMA
@@ -496,8 +487,6 @@ function formatExtractionResults(sources) {
 }
 
 export {
-  readJsonFile,
-  writeJsonFile,
   extractPdfText,
   themeValues,
   getConfiguredOpenAIApiKey,

package/dist/{chunk-I5NVYKG7.js → chunk-4HCPHCC2.js}

@@ -10,6 +10,9 @@ function getOpenResearchRoot(options) {
 function getOpenResearchAuthFile(options) {
   return path.join(getOpenResearchRoot(options), "auth.json");
 }
+function getOpenResearchGeminiAuthFile(options) {
+  return path.join(getOpenResearchRoot(options), "gemini-auth.json");
+}
 function getOpenResearchConfigFile(options) {
   return path.join(getOpenResearchRoot(options), "config.json");
 }
@@ -29,6 +32,7 @@ function getWorkspaceSessionsDir(workspaceDir) {
 export {
   getOpenResearchRoot,
   getOpenResearchAuthFile,
+  getOpenResearchGeminiAuthFile,
   getOpenResearchConfigFile,
   getOpenResearchSkillsDir,
   getWorkspaceMetaDir,

package/dist/chunk-77Q5B5H7.js

@@ -0,0 +1,27 @@
+// src/lib/fs/json.ts
+import fs from "fs/promises";
+import path from "path";
+async function readJsonFile(filePath, fallback) {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    const code = typeof error === "object" && error && "code" in error ? String(error.code) : "";
+    if (code === "ENOENT") {
+      return fallback;
+    }
+    throw error;
+  }
+}
+async function writeJsonFile(filePath, value, mode) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(value, null, 2), {
+    encoding: "utf8",
+    mode
+  });
+}
+
+export {
+  readJsonFile,
+  writeJsonFile
+};

package/dist/chunk-GVEVKDGV.js

@@ -0,0 +1,68 @@
+// src/lib/llm/provider-catalog.ts
+var OPENAI_PROVIDER_MODELS = [
+  "gpt-5.4",
+  "gpt-5.4-mini",
+  "o3",
+  "o4-mini"
+];
+var OPENAI_CATALOG = {
+  family: "openai",
+  displayName: "OpenAI",
+  models: OPENAI_PROVIDER_MODELS,
+  defaultModel: "gpt-5.4",
+  backgroundModel: "gpt-5.4-mini"
+};
+var GEMINI_PROVIDER_MODELS = [
+  "gemini-3.1-pro-preview",
+  "gemini-3-flash-preview"
+];
+var GEMINI_CATALOG = {
+  family: "gemini",
+  displayName: "Gemini",
+  models: GEMINI_PROVIDER_MODELS,
+  defaultModel: "gemini-3.1-pro-preview",
+  backgroundModel: "gemini-3-flash-preview"
+};
+function getProviderCatalog(providerKind) {
+  switch (providerKind) {
+    case "gemini_auth":
+    case "gemini_api_key":
+      return GEMINI_CATALOG;
+    case "openai_auth":
+    case "openai_api_key":
+    default:
+      return OPENAI_CATALOG;
+  }
+}
+function getAvailableModels(providerKind) {
+  return getProviderCatalog(providerKind).models;
+}
+function isSupportedModel(model, providerKind) {
+  if (!model) return false;
+  return getAvailableModels(providerKind).includes(model);
+}
+function getDefaultModel(providerKind) {
+  return getProviderCatalog(providerKind).defaultModel;
+}
+function selectModelForTask(providerKind, requestedModel, task) {
+  const catalog = getProviderCatalog(providerKind);
+  const selected = isSupportedModel(requestedModel, providerKind) ? requestedModel : catalog.defaultModel;
+  switch (task) {
+    case "conversation":
+      return selected;
+    case "compaction":
+      return selected.includes("5.4") || selected.includes("pro") ? catalog.backgroundModel : selected;
+    case "memory":
+    case "workspace":
+      return catalog.backgroundModel;
+    default:
+      return selected;
+  }
+}
+
+export {
+  getProviderCatalog,
+  getAvailableModels,
+  getDefaultModel,
+  selectModelForTask
+};

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

@@ -1,6 +1,6 @@
 import {
   getWorkspaceSessionsDir
-} from "./chunk-I5NVYKG7.js";
+} from "./chunk-4HCPHCC2.js";
 
 // src/lib/workspace/sessions.ts
 import fs from "fs/promises";