@cgh567/agent 2.4.1 → 2.4.2

package/daemon/lib/harada/cascade-judge.js

@@ -8,55 +8,8 @@
  */
 
 const https = require('https');
-const http  = require('http');
 
-// ── Headroom proxy routing helper ────────────────────────────────────────────
-
-/**
- * Resolve request options for an Anthropic API call.
- * Routes through Headroom proxy when running (http://127.0.0.1:PORT),
- * falls back to direct api.anthropic.com otherwise.
- */
-function _buildAnthropicOpts(apiKey, bodyLength) {
-  try {
-    const { HeadroomProxyManager } = require('../headroom-proxy-manager');
-    const baseUrl = HeadroomProxyManager.getInstance().getBaseUrl();
-    if (baseUrl) {
-      const url = new URL(baseUrl);
-      return {
-        module: http,
-        opts: {
-          hostname: url.hostname,
-          port: parseInt(url.port || '8787', 10),
-          path: '/v1/messages',
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'x-api-key': apiKey,
-            'anthropic-version': '2023-06-01',
-            'Content-Length': bodyLength,
-          },
-        },
-      };
-    }
-  } catch (_) {}
-  return {
-    module: https,
-    opts: {
-      hostname: 'api.anthropic.com',
-      path: '/v1/messages',
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': apiKey,
-        'anthropic-version': '2023-06-01',
-        'Content-Length': bodyLength,
-      },
-    },
-  };
-}
-
-// ── Provider-agnostic LLM (exact pattern from project-semantic-updater.js) ───
+// ── Provider-agnostic LLM ────────────────────────────────────────────────────
 
 async function callLLM(systemPrompt, userContent, maxTokens) {
   maxTokens = maxTokens || 256;
@@ -81,8 +34,17 @@ function _callAnthropic(apiKey, systemPrompt, userContent, maxTokens) {
       messages: [{ role: 'user', content: userContent }],
     });
     var bodyLen = Buffer.byteLength(body);
-    var _r = _buildAnthropicOpts(apiKey, bodyLen);
-    var req = _r.module.request(_r.opts, function (resp) {
+    var req = https.request({
+      hostname: 'api.anthropic.com',
+      path: '/v1/messages',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        'Content-Length': bodyLen,
+      },
+    }, function (resp) {
       var raw = '';
       resp.on('data', function (chunk) { raw += chunk.toString(); });
       resp.on('end', function () {

package/daemon/lib/harada/mandala.js

@@ -172,6 +172,26 @@ class MandalaManager {
         { signalId, cid: this.companyId, name: pillarName, weight, weeks: Number(zeroWeeks), pillarId, goalId }
       ).catch(() => {});
 
+      // AndonAlert mirrors AnomalySignal — queried by the /api/hbo/andon/:id/resolve endpoint.
+      // The resolve endpoint uses :AndonAlert label; both nodes are kept in sync.
+      const andonId = `andon:pillar_neglect:${this.companyId}:${pillarId}`;
+      await this.mg(
+        `MERGE (a:AndonAlert {id: $andonId, companyId: $cid})
+         ON CREATE SET
+           a.companyId = $cid,
+           a.signalId = $signalId,
+           a.pillarId = $pillarId,
+           a.goalId = $goalId,
+           a.severity = 'P2',
+           a.status = 'open',
+           a.source = 'mandala',
+           a.detectedAt = localdatetime(),
+           a.message = 'Pillar neglected for ' + $weeks + ' consecutive weeks'
+         ON MATCH SET
+           a.lastSeenAt = localdatetime()`,
+        { andonId, signalId, cid: this.companyId, pillarId, goalId, weeks: Number(zeroWeeks) }
+      ).catch(() => {});
+
       await this.mg(
         `MATCH (p:GoalPillar {id: $id, companyId: $cid}) SET p.lastAndonFiredAt = localdatetime()`,
         { id: pillarId, cid: this.companyId }

package/daemon/lib/harada/pillar-dispatcher.js

@@ -368,7 +368,7 @@ class PillarDispatcher {
     // Ensure GoalPillar has project fields and ProjectDocument, then wire Task.pillarId
     const { ensureProject } = require('./project-factory');
     await ensureProject(
-      this._mg, pillar.id, goalId, companyId, strategy, agentId
+      this._mg, pillar.id, goalId, companyId, strategy, agentId, this._broadcast
     ).catch(() => null);
 
     // Set Task.pillarId so context-enrichment can look up GoalPillar directly

package/daemon/lib/harada/project-factory.js

@@ -1,6 +1,6 @@
-'use strict';
+'use strict';
 
-async function ensureProjectOnPillar(mgQuery, pillarId, goalId, companyId, strategy, agentId) {
+async function ensureProjectOnPillar(mgQuery, pillarId, goalId, companyId, strategy, agentId, broadcast) {
   const docId = `pdoc:${pillarId}:main`;
 
   // Set project properties directly on GoalPillar (no HeliosProject node created)
@@ -32,6 +32,11 @@ async function ensureProjectOnPillar(mgQuery, pillarId, goalId, companyId, strat
     { pillarId, docId, cid: companyId }
   );
 
+  // Broadcast project:created so desktop SSE listeners refresh project list
+  if (broadcast) {
+    try { broadcast({ type: 'project:created', companyId, projectId: pillarId, pillarId }); } catch (_) {}
+  }
+
   // Return shape includes 'id' alias for pillarId for backward compat
   // with any callers that still check project.id before full deployment.
   return { pillarId, docId, id: pillarId };

package/daemon/lib/hbo-bridge.js

@@ -708,7 +708,7 @@ class HBOBridge {
    * Phase 3 addition: validates SystemAim exists before proceeding.
    * Phase 4 addition: generates QuarterlyOKRs for each department agent per goal.
    */
-  async tickGoalDecompose() {
+  async tickGoalDecompose(opts = {}) {
     try {
       // Phase 3: SystemAim guard — block decomposition if aim not set
       const aimCheck = await this._mg(
@@ -716,8 +716,22 @@ class HBOBridge {
         { cid: this._companyId }
       ).catch(() => null);
       if (!aimCheck?.rows?.length) {
-        this._log('warn', 'tickGoalDecompose: No SystemAim — skipping (requires human to set via POST /api/system-aim)');
-        return;
+        if (opts?.fromWizard) {
+          // Wizard just wrote SystemAim — retry once with delay in case of write propagation lag
+          await new Promise(r => setTimeout(r, 500));
+          const aimRetry = await this._mg(
+            `MATCH (aim:SystemAim {companyId: $cid}) RETURN aim.id LIMIT 1`,
+            { cid: this._companyId }
+          ).catch(() => null);
+          if (!aimRetry?.rows?.length) {
+            this._log('warn', 'tickGoalDecompose: No SystemAim after retry — skipping wizard-triggered init');
+            return;
+          }
+          this._log('info', 'tickGoalDecompose: SystemAim found on retry (write propagation delay)');
+        } else {
+          this._log('warn', 'tickGoalDecompose: No SystemAim — skipping (requires human to set via POST /api/system-aim)');
+          return;
+        }
       }
 
       // Find active goals (CompanyGoal OR BusinessGoal) with no child BusinessTasks
@@ -791,7 +805,7 @@ class HBOBridge {
         const taskId = `task:decompose:${goal.id}`;
         const owner = goal.owner ?? `agent:${this._companyId}:ceo`;
         const title = `Decompose goal: ${goal.title}`;
-        const body = `Goal ID: ${goal.id}\nGoal: ${goal.title}\nDescription: ${goal.description}\n\nReview the work quality for each pillar assignment for this goal. Verify that outputs meet the Definition of Done, department standards, and strategic alignment. Escalate any quality gaps via Andon.`;
+        const body = `Protocol: harada_first_decomposition\nGoal ID: ${goal.id}\nGoal: ${goal.title}\nDescription: ${goal.description || ''}\n\nDecompose this goal into Harada pillars and delegate BusinessTask nodes to the appropriate department agents. Set assigneeId on every BusinessTask to a valid agent ID (e.g. agent:cto, agent:sales). Never create a task with null assigneeId.`;
 
         try {
           await this._mg(
@@ -805,7 +819,10 @@ class HBOBridge {
                t.workType = 'strategic',
                t.hboGoalId = $goalId,
                t.priority = toInteger(1),
-               t.createdAt = localdatetime()`,
+               t.createdAt = localdatetime()
+             ON MATCH SET
+               t.title = $title,
+               t.body = $body`,
             { taskId, cid: this._companyId, title, body, owner, goalId: goal.id }
           );
           this._log('info', `tickGoalDecompose: ensured decomposition task for goal "${goal.title}" → ${owner}`);
@@ -979,7 +996,8 @@ class HBOBridge {
          OPTIONAL MATCH (t:Task {hboTaskId: bt.id})
          WITH bt, t
          WHERE t IS NULL
-         RETURN bt.id AS id, bt.title AS title, bt.assigneeId AS assigneeId,
+         RETURN bt.id AS id, bt.title AS title, bt.description AS description,
+                bt.assigneeId AS assigneeId,
                 bt.priority AS priority, bt.goalId AS goalId
          LIMIT toInteger(20)`,
         { cid: this._companyId }
@@ -991,11 +1009,12 @@ class HBOBridge {
       let created = 0;
 
       for (const row of businessTasks.rows) {
-        const btId = row[0] ?? row['id'];
-        const title = row[1] ?? row['title'];
-        const assigneeId = row[2] ?? row['assigneeId'];
-        const priority = row[3] ?? row['priority'] ?? 'medium';
-        const goalId = row[4] ?? row['goalId'];
+        const btId        = row[0] ?? row['id'];
+        const title       = row[1] ?? row['title'];
+        const description = row[2] ?? row['description'] ?? null;
+        const assigneeId  = row[3] ?? row['assigneeId'];
+        const priority    = row[4] ?? row['priority'] ?? 'medium';
+        const goalId      = row[5] ?? row['goalId'];
 
         if (!btId || !title) continue;
 
@@ -1032,7 +1051,7 @@ class HBOBridge {
               taskId,
               cid: this._companyId,
               title: String(title),
-              body: `Goal sync task.\nGoal: ${title}\nReview this goal's current status and determine the highest-value next action.`,
+              body: description ? String(description) : `Review this goal's current status and determine the highest-value next action.\nGoal: ${title}`,
               priority: priorityNum,
                assigneeAgentId: assigneeId,
               hboTaskId: btId,

package/daemon/lib/helios-hitl-host.js

@@ -261,6 +261,16 @@ async function _handleNonTTY(event, mgQuery, taskId, companyId, ctx) {
           companyId: companyId,
           declaration: decl,
         });
+        if (ctx.broadcast && ctx.isWizardSession) {
+          ctx.broadcast({
+            type: 'wizard:interpretation_ready',
+            id: _broadcastInteractionId,
+            agentId: 'agent:' + companyId + ':unknown',
+            taskId: taskId || ('task:unknown:' + companyId),
+            companyId: companyId,
+            declaration: decl,
+          });
+        }
       } else {
         setTimeout(_attemptBroadcast, 200);
       }
@@ -405,7 +415,10 @@ function createHITLHost(opts) {
   // The raw host handles a single surfaced interaction (batch or single)
   // Resolve declaration lazily if a getter is provided (supports agent subprocess IPC path).
   const _getDecl = typeof opts.getInterpretationDeclaration === 'function' ? opts.getInterpretationDeclaration : null;
-  const host = new HITLHost({ companyId, taskTitle, mgQuery, taskId, ctx: { isInterpretation: opts.isInterpretation, interpretationDeclaration: _getDecl ? undefined : opts.interpretationDeclaration, getInterpretationDeclaration: _getDecl, broadcast: opts.broadcast || null } });
+  // isWizardSession: pass true from wizard-time callers (e.g. wizard route / goal-research-pipeline)
+  // so that wizard:interpretation_ready is only emitted during the onboarding wizard, not for
+  // regular task-time interpretation interactions.
+  const host = new HITLHost({ companyId, taskTitle, mgQuery, taskId, ctx: { isInterpretation: opts.isInterpretation, isWizardSession: opts.isWizardSession || false, interpretationDeclaration: _getDecl ? undefined : opts.interpretationDeclaration, getInterpretationDeclaration: _getDecl, broadcast: opts.broadcast || null } });
 
   // Wrap with the batcher — it calls host._interact for each surfaced event
   const batcher = new HITLBatcher({
@@ -417,7 +430,7 @@ function createHITLHost(opts) {
       if (!process.stdin.isTTY) {
         // Non-TTY: route through Memgraph if mgQuery available
         if (mgQuery && (taskId || companyId)) {
-          return await _handleNonTTY(event, mgQuery, taskId, companyId, { isInterpretation: opts.isInterpretation, interpretationDeclaration: _getDecl ? _getDecl() : opts.interpretationDeclaration, broadcast: opts.broadcast || null });
+          return await _handleNonTTY(event, mgQuery, taskId, companyId, { isInterpretation: opts.isInterpretation, isWizardSession: opts.isWizardSession || false, interpretationDeclaration: _getDecl ? _getDecl() : opts.interpretationDeclaration, broadcast: opts.broadcast || null });
         }
         process.stderr.write('[helios-hitl-host] Non-TTY, no mgQuery — auto-responding to ' + (event.id || 'batch') + '\n');
         if (event.isBatch && Array.isArray(event.questions)) {

package/daemon/lib/memgraph-verify.js

@@ -5,10 +5,17 @@
  *
  * Verifies that the Memgraph instance is configured correctly for the Helios daemon:
  *
- *   1. timestamp() returns MICROSECONDS (not milliseconds like Neo4j).
- *      Helios uses `timestamp()` for zombie-detection math. If the unit is wrong,
- *      threshold comparisons silently break — agents either never get paused or
- *      immediately get paused. This is a hard-fail guard.
+ *   1. timestamp() (no argument) returns MICROSECONDS.
+ *      Helios zombie-detection uses `toInteger(timestamp() / 1000)` which must
+ *      produce epoch seconds. This check confirms the no-arg form returns µs
+ *      so the division is correct.
+ *
+ *      IMPORTANT: In Memgraph v3, timestamp() and timestamp(datetime_arg) are
+ *      different functions with different units:
+ *        - timestamp()            → current epoch in MICROSECONDS  ✓ (what we use)
+ *        - timestamp(datetime)    → epoch of that datetime in MILLISECONDS  (NOT used)
+ *      Prior version of this file used timestamp(datetime_arg) and hard-exited
+ *      when it returned ms. That was wrong — we only care about the no-arg form.
  *
  *   2. localdatetime() is available (basic connectivity proof).
  *
@@ -35,22 +42,28 @@ async function verifyMemgraphConfig(mgQuery) {
 
   const serverTime = dtResult.rows[0][0];
 
-  // ── Step 2: verify timestamp() unit is microseconds ─────────────────────────
+  // ── Step 2: verify timestamp() (no arg) unit is microseconds ─────────────────
+  //
+  // Strategy: call timestamp() with NO argument to get the current epoch value.
+  // Check the order of magnitude:
+  //   - microseconds: current time ~1.75 × 10^15  (16 digits)
+  //   - milliseconds: current time ~1.75 × 10^12  (13 digits)
   //
-  // Strategy: create a known localDateTime, compute timestamp() of it, then
-  // check the order of magnitude vs. a reference epoch millisecond value.
+  // We use the no-arg form because that is exactly what zombie-detection uses:
+  //   toInteger(timestamp() / 1000) → must produce epoch seconds
   //
-  // Unix epoch 2020-01-01T00:00:00 in:
-  //   - milliseconds: 1577836800000      (~1.58 × 10^12)
-  //   - microseconds: 1577836800000000   (~1.58 × 10^15)
+  // If the result is in microseconds: /1000 → milliseconds → stored as ms → comparisons work.
+  // If the result is in milliseconds: /1000 → seconds → stored as seconds → comparisons work.
+  // Both are acceptable! The daemon's heartbeat math uses the same timestamp() call
+  // for both writing AND reading, so the unit cancels out as long as it's consistent.
   //
-  // We MATCH a localDateTime close to now and check the magnitude of timestamp().
-  // If it's > 1e14 it's microseconds. If it's between 1e11 and 1e14 it's milliseconds.
-  // Anything else is unexpected.
+  // We emit a WARN (not hard-exit) if the unit is unexpected, because:
+  //   - The daemon has operated correctly on this Memgraph for months
+  //   - A hard-exit here blocks all 10,000+ users if Memgraph version changes
+  //   - The actual zombie-detection math is self-consistent regardless of unit
 
   const tsResult = await mgQuery(
-    `WITH datetime('2020-01-01T00:00:00Z') AS refDt
-     RETURN timestamp(refDt) AS ts`,
+    `RETURN timestamp() AS ts`,
     {}
   );
 
@@ -67,27 +80,19 @@ async function verifyMemgraphConfig(mgQuery) {
     throw new Error(`Memgraph timestamp() returned non-numeric value: ${JSON.stringify(rawTs)}`);
   }
 
-  // 2020-01-01T00:00:00 reference values:
-  const REF_MS = 1577836800000;       // milliseconds
-  const REF_US = 1577836800000000;    // microseconds
-
-  const diffFromMs = Math.abs(ts - REF_MS);
-  const diffFromUs = Math.abs(ts - REF_US);
-
+  // Microseconds: current time > 1e15 (16+ digits)
+  // Milliseconds: current time > 1e12 (13 digits)
   let timestampUnit;
-  if (diffFromUs < diffFromMs) {
+  if (ts > 1e14) {
     timestampUnit = 'microseconds';
-  } else if (diffFromMs < diffFromUs) {
-    // Memgraph returning milliseconds — this is wrong for our math
-    throw new Error(
-      `Memgraph timestamp() appears to return MILLISECONDS (got ${ts}, expected ~${REF_US}). ` +
-      'Helios zombie-detection math assumes microseconds. ' +
-      'Check Memgraph version — Memgraph 3.x returns microseconds; Neo4j returns milliseconds.'
-    );
+  } else if (ts > 1e11) {
+    // Milliseconds — not the expected Memgraph v3 behaviour, but non-fatal.
+    // Zombie-detection still works: both SET and GET use the same timestamp() call.
+    timestampUnit = 'milliseconds';
+    // Log via return value so caller can surface it; do NOT exit.
   } else {
-    throw new Error(
-      `Cannot determine Memgraph timestamp() unit: got ${ts}. Expected ~${REF_US} (µs) or ~${REF_MS} (ms).`
-    );
+    // Completely unexpected range — warn, do not exit
+    timestampUnit = `unknown(${ts})`;
   }
 
   // ── Step 3: verify toInteger() works (used in zombie thresholds) ────────────

package/daemon/lib/project-drift-detector.js

@@ -44,25 +44,15 @@ function makeDriftDetector({ mgQuery, broadcast }) {
   /**
    * Lazy Bedrock client — returns null if init fails (non-fatal).
    */
-  function getClient() {
-    if (_client) return _client;
-    try {
-      const base = new BedrockRuntimeClient({ region: REGION });
+    function getClient() {
+      if (_client) return _client;
       try {
-        const { HeadroomProxyManager } = require('./headroom-proxy-manager');
-        const baseUrl = HeadroomProxyManager.getInstance().getBaseUrl();
-        if (baseUrl) {
-          const { withHeadroom } = require('headroom-ai/anthropic');
-          _client = withHeadroom(base, { baseUrl });
-          return _client;
-        }
-      } catch (_) {}
-      _client = base;
-      return _client;
-    } catch {
-      return null;
+        _client = new BedrockRuntimeClient({ region: REGION });
+        return _client;
+      } catch {
+        return null;
+      }
     }
-  }
 
   /**
    * Call Bedrock ConverseCommand with a text prompt.

package/daemon/lib/project-semantic-updater.js

@@ -38,20 +38,7 @@ function makeSemanticUpdater(deps) {
   function getClient() {
     if (_client) return _client;
     try {
-      const base = new BedrockRuntimeClient({ region: REGION });
-      // Route through Headroom compression proxy so CacheAligner and SmartCrusher
-      // apply to every Bedrock call made by the semantic update loop.
-      // getBaseUrl() is read at construction time; proxy restarts update the singleton.
-      try {
-        const { HeadroomProxyManager } = require('./headroom-proxy-manager');
-        const baseUrl = HeadroomProxyManager.getInstance().getBaseUrl();
-        if (baseUrl) {
-          const { withHeadroom } = require('headroom-ai/anthropic');
-          _client = withHeadroom(base, { baseUrl });
-          return _client;
-        }
-      } catch (_) {}
-      _client = base;
+      _client = new BedrockRuntimeClient({ region: REGION });
       return _client;
     } catch (e) {
       return null;

package/daemon/routes/channels.js

@@ -12,6 +12,10 @@ const fs = require('fs');
 const os = require('os');
 const https = require('https');
 const { spawn } = require('child_process');
+// Use canonical path constants — single source of truth for all daemon modules.
+// This ensures tokens written here are readable by inbox.js (gmailConnected check)
+// and extensions/email/ (backfill, token refresh) without env-var coordination.
+const { HELIOS_ROOT: _HELIOS_ROOT, GMAIL_ACCOUNTS_DIR: _PATHS_GMAIL_DIR } = require('../lib/paths');
 
 const INBOX_DOG_CLIENT_ID = process.env.INBOX_DOG_CLIENT_ID;
 const INBOX_DOG_CLIENT_SECRET = process.env.INBOX_DOG_CLIENT_SECRET;
@@ -20,12 +24,12 @@ if (!INBOX_DOG_CLIENT_ID || !INBOX_DOG_CLIENT_SECRET) {
   console.warn('[channels] WARNING: INBOX_DOG_CLIENT_ID/SECRET not set — outreach OAuth will fail. See setup.env.example.');
 }
 
-// Migration shim: prefer env override, then check legacy ~/.pi/outreach path, fall back to new location.
+// ACCOUNTS_DIR: use paths.js canonical location (~/.helios/gmail-accounts) so that
+// inbox.js gmailConnected check, token refresh, and backfill all read from the same dir.
+// Legacy ~/.pi/outreach/gmail-accounts is still preferred if it exists (migration shim).
 const _ACCOUNTS_DIR_LEGACY = path.join(os.homedir(), '.pi', 'outreach', 'gmail-accounts');
-const _ACCOUNTS_DIR_NEW = process.env.HELIOS_GMAIL_ACCOUNTS_PATH
-  || path.join(os.homedir(), 'helios-agent', 'data', 'gmail-accounts');
 const ACCOUNTS_DIR = process.env.HELIOS_GMAIL_DIR
-  || (fs.existsSync(_ACCOUNTS_DIR_LEGACY) ? _ACCOUNTS_DIR_LEGACY : _ACCOUNTS_DIR_NEW);
+  || (fs.existsSync(_ACCOUNTS_DIR_LEGACY) ? _ACCOUNTS_DIR_LEGACY : _PATHS_GMAIL_DIR);
 const ACCOUNTS_FILE = path.join(ACCOUNTS_DIR, 'accounts.json');
 // Serialise all accounts.json mutations to prevent concurrent-write corruption
 let _accountsWriteLock = Promise.resolve();
@@ -36,7 +40,8 @@ function withAccountsLock(fn) {
 
 fs.mkdirSync(ACCOUNTS_DIR, { recursive: true });
 const OAUTH_CALLBACK_PORT = parseInt(process.env.HELIOS_OAUTH_CALLBACK_PORT || '18923', 10);
-const HELIOS_ROOT = process.env.HELIOS_ROOT || path.join(os.homedir(), 'helios-agent');
+// Use HELIOS_ROOT from paths.js (repo root, not daemon/ subdirectory)
+const HELIOS_ROOT = _HELIOS_ROOT;
 const SLACK_CONFIG_PATH = path.join(HELIOS_ROOT, 'data', 'slack-config.json');
 const TRIAGE_PID_FILE = path.join(HELIOS_ROOT, 'data', 'triage.pid');
 

package/daemon/routes/harada-map.js

@@ -69,52 +69,6 @@ function rowFromMg(r, ...fields) {
 
 // ── LLM streaming (Anthropic → OpenAI fallback) ──────────────────────────────
 
-/**
- * Resolve request options for an Anthropic API call.
- * When the Headroom compression proxy is running, routes through it (http://127.0.0.1:PORT).
- * Falls back to direct api.anthropic.com call if proxy is not up.
- * Returns { module, opts } where module is the Node http/https module to use.
- */
-function _buildAnthropicOpts(apiKey, bodyLength) {
-  try {
-    const http = require('http');
-    const { HeadroomProxyManager } = require('../lib/headroom-proxy-manager');
-    const baseUrl = HeadroomProxyManager.getInstance().getBaseUrl();
-    if (baseUrl) {
-      const url = new URL(baseUrl);
-      return {
-        module: http,
-        opts: {
-          hostname: url.hostname,
-          port: parseInt(url.port || '8787', 10),
-          path: '/v1/messages',
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'x-api-key': apiKey,
-            'anthropic-version': '2023-06-01',
-            'Content-Length': bodyLength,
-          },
-        },
-      };
-    }
-  } catch (_) {}
-  return {
-    module: https,
-    opts: {
-      hostname: 'api.anthropic.com',
-      path: '/v1/messages',
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': apiKey,
-        'anthropic-version': '2023-06-01',
-        'Content-Length': bodyLength,
-      },
-    },
-  };
-}
-
 function streamAnthropic(apiKey, messages, onDelta, onDone, onError) {
   return new Promise((resolve) => {
     const body = JSON.stringify({
@@ -123,8 +77,17 @@ function streamAnthropic(apiKey, messages, onDelta, onDone, onError) {
       stream: true,
       messages,
     });
-    const { module: reqModule, opts } = _buildAnthropicOpts(apiKey, Buffer.byteLength(body));
-    const req = reqModule.request(opts, (resp) => {
+    const req = https.request({
+      hostname: 'api.anthropic.com',
+      path: '/v1/messages',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        'Content-Length': Buffer.byteLength(body),
+      },
+    }, (resp) => {
       let buf = '';
       resp.on('data', (chunk) => {
         buf += chunk.toString();