@siftd/connect-agent 0.2.52 → 0.2.54

package/README.md

@@ -133,6 +133,22 @@ export function buildWorkerPrompt(task, options) { ... }
 - `VOYAGE_API_KEY` - (Optional) For better semantic search embeddings
 - `DATABASE_URL` - (Optional) PostgreSQL for cloud memory persistence
 
+### Model + Cost Controls (Optional)
+
+- `LIA_FORCE_OPUS` - Defaults to `1`; set to `0` to allow model overrides
+- `LIA_MODEL` - Explicit model override (defaults to Opus 4.5 when forced)
+- `LIA_MAX_BUDGET_USD` - Per-worker budget cap (USD) for Claude Code CLI
+- `LIA_TOOL_MAX_TOKENS` - Max tokens for `/todo` + `/cal` tool calls
+- `LIA_WORKER_VERBOSE` - Set to `1` for verbose worker logging
+
+### Usage Logging
+
+Anthropic usage is logged per channel in:
+
+```
+~/Lia-Hub/shared/outputs/.lia/usage.jsonl
+```
+
 ## Requirements
 
 - Node.js 18+

package/dist/agent.js

@@ -423,46 +423,63 @@ export async function runAgent(pollInterval = 2000) {
     });
     if (wsConnected) {
         console.log('[AGENT] Using WebSocket for real-time communication\n');
-        // Handle messages via WebSocket
-        wsClient.onMessage(async (wsMsg) => {
-            if (wsMsg.type === 'message' && wsMsg.content && wsMsg.id) {
-                const message = {
-                    id: wsMsg.id,
-                    content: wsMsg.content,
-                    timestamp: wsMsg.timestamp || Date.now()
-                };
-                const response = await processMessage(message);
+    }
+    else {
+        console.log('[AGENT] WebSocket unavailable, using HTTP polling\n');
+    }
+    // Handle messages via WebSocket
+    wsClient.onMessage(async (wsMsg) => {
+        if (wsMsg.type === 'message' && wsMsg.content && wsMsg.id) {
+            const message = {
+                id: wsMsg.id,
+                content: wsMsg.content,
+                timestamp: wsMsg.timestamp || Date.now()
+            };
+            const response = await processMessage(message);
+            if (wsClient?.connected()) {
                 // Send response via WebSocket
                 wsClient.sendResponse(wsMsg.id, response);
                 console.log(`[AGENT] Response sent via WebSocket (${response.length} chars)`);
             }
-        });
-        // Keep process alive - WebSocket handles messages
-        console.log('[AGENT] Listening for WebSocket messages...\n');
-        // Poll only if WebSocket is not connected (WS input is preferred for latency).
-        while (true) {
-            await new Promise(resolve => setTimeout(resolve, pollInterval));
-            if (!wsClient?.connected()) {
-                try {
-                    const { messages } = await pollMessages();
-                    for (const msg of messages) {
-                        const response = await processMessage(msg);
-                        await sendResponse(msg.id, response);
-                        console.log(`[AGENT] Response sent (${response.length} chars)`);
-                    }
-                }
-                catch (error) {
-                    console.error('[AGENT] Poll error:', error.message);
-                }
+            else {
+                await sendResponse(wsMsg.id, response);
+                console.log(`[AGENT] Response sent via HTTP (${response.length} chars)`);
             }
         }
-    }
-    else {
-        // Fall back to polling
-        console.log('[AGENT] WebSocket unavailable, using HTTP polling\n');
-        while (true) {
+    });
+    console.log('[AGENT] Listening for WebSocket messages...\n');
+    const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+    const basePollInterval = pollInterval;
+    const maxPollBackoff = 30000;
+    const wsReconnectInterval = 30000;
+    let pollErrorCount = 0;
+    let lastPollErrorLog = 0;
+    let lastWsReconnectAttempt = Date.now();
+    let nextPollDelay = basePollInterval;
+    const logPollError = (message) => {
+        const now = Date.now();
+        if (now - lastPollErrorLog > 10000) {
+            lastPollErrorLog = now;
+            console.error('[AGENT] Poll error:', message);
+        }
+    };
+    const computeBackoff = (count) => {
+        const exponent = Math.min(count, 5);
+        const delay = Math.min(maxPollBackoff, basePollInterval * Math.pow(2, exponent));
+        const jitter = delay * 0.1 * (Math.random() * 2 - 1);
+        return Math.max(basePollInterval, Math.round(delay + jitter));
+    };
+    while (true) {
+        const now = Date.now();
+        if (!wsClient?.connected() && now - lastWsReconnectAttempt > wsReconnectInterval) {
+            lastWsReconnectAttempt = now;
+            void wsClient.connect();
+        }
+        if (!wsClient?.connected()) {
             try {
                 const { messages } = await pollMessages();
+                pollErrorCount = 0;
+                nextPollDelay = basePollInterval;
                 for (const msg of messages) {
                     const response = await processMessage(msg);
                     await sendResponse(msg.id, response);
@@ -470,11 +487,22 @@ export async function runAgent(pollInterval = 2000) {
                 }
             }
             catch (error) {
-                if (error instanceof Error && !error.message.includes('ECONNREFUSED')) {
-                    console.error('[AGENT] Poll error:', error.message);
+                pollErrorCount += 1;
+                const status = error.status;
+                const message = error instanceof Error ? error.message : String(error);
+                logPollError(message);
+                if (status === 401 || status === 403) {
+                    nextPollDelay = maxPollBackoff;
+                }
+                else {
+                    nextPollDelay = computeBackoff(pollErrorCount);
                 }
             }
-            await new Promise(resolve => setTimeout(resolve, pollInterval));
         }
+        else {
+            pollErrorCount = 0;
+            nextPollDelay = basePollInterval;
+        }
+        await sleep(nextPollDelay);
     }
 }

package/dist/api.js

@@ -26,7 +26,9 @@ export async function connectWithPairingCode(code) {
 export async function pollMessages() {
     const res = await fetchWithAuth('/api/agent/messages');
     if (!res.ok) {
-        throw new Error(`Failed to poll messages: ${res.status}`);
+        const error = new Error(`Failed to poll messages: ${res.status}`);
+        error.status = res.status;
+        throw error;
     }
     return res.json();
 }

package/dist/orchestrator.js

@@ -734,8 +734,8 @@ export class MasterOrchestrator {
     }
     hasCalendarMutation(message) {
         const lower = this.stripTodoSnapshot(message).toLowerCase();
-        const target = /(^|\s)\/cal\b|\/calendar\b|\bcalendar\b|\bcal\b/.test(lower);
-        const action = /\b(add|create|schedule|book|move|reschedule|update|change|cancel|delete|remove)\b/.test(lower);
+        const target = /(^|\s)\/cal\b|\/calendar\b|\bcalendar\b|\bcal\b|\bschedule\b|\bagenda\b/.test(lower);
+        const action = /\b(add|create|schedule|book|move|reschedule|update|change|cancel|delete|remove|set|put|place|remind)\b/.test(lower);
         const query = /\b(what|show|list|open|view|see)\b/.test(lower);
         return target && action && !query;
     }
@@ -1422,9 +1422,9 @@ ${hubContextStr}
         const toolsBase = this.getToolDefinitions();
         const last = messages[messages.length - 1];
         const lastContent = last && last.role === 'user' && typeof last.content === 'string' ? last.content : '';
-        const restrictWorkers = lastContent
-            ? (this.hasTodoMutation(lastContent) || this.hasCalendarMutation(lastContent))
-            : false;
+        const requiredTodo = lastContent ? this.hasTodoMutation(lastContent) : false;
+        const requiredCal = lastContent ? this.hasCalendarMutation(lastContent) : false;
+        const restrictWorkers = requiredTodo || requiredCal;
         const wantsTodoOrCal = restrictWorkers;
         const todoCalTools = new Set(['calendar_upsert_events', 'todo_upsert_items']);
         const blockedTools = new Set([
@@ -1444,6 +1444,7 @@ ${hubContextStr}
         const requestTimeoutMs = 60000;
         const forcedToolChoice = this.getToolChoice(currentMessages);
         let retriedForcedTool = false;
+        let retriedTodoCal = false;
         while (iterations < maxIterations) {
             iterations++;
             const toolChoice = forcedToolChoice ?? this.getToolChoice(currentMessages);
@@ -1492,13 +1493,44 @@ ${hubContextStr}
                     ];
                     continue;
                 }
+                if (wantsTodoOrCal && !retriedTodoCal && (requiredTodo || requiredCal)) {
+                    retriedTodoCal = true;
+                    const required = [
+                        requiredTodo ? 'todo_upsert_items' : null,
+                        requiredCal ? 'calendar_upsert_events' : null
+                    ].filter(Boolean).join(' and ');
+                    const followup = `You must call ${required} now. Do not spawn workers or call any other tools.`;
+                    currentMessages = [
+                        ...currentMessages,
+                        { role: 'assistant', content: response.content },
+                        { role: 'user', content: followup }
+                    ];
+                    continue;
+                }
                 return this.extractText(response.content);
             }
             const toolUseBlocks = response.content.filter((block) => block.type === 'tool_use');
             const toolNames = toolUseBlocks.map((block) => block.name);
             // Process tool calls
             const toolResults = await this.processToolCalls(response.content, sendMessage);
-            if (wantsTodoOrCal && (toolNames.includes('todo_upsert_items') || toolNames.includes('calendar_upsert_events'))) {
+            const missingTodo = requiredTodo && !toolNames.includes('todo_upsert_items');
+            const missingCal = requiredCal && !toolNames.includes('calendar_upsert_events');
+            if (wantsTodoOrCal && (missingTodo || missingCal) && !retriedTodoCal) {
+                retriedTodoCal = true;
+                const required = [
+                    missingTodo ? 'todo_upsert_items' : null,
+                    missingCal ? 'calendar_upsert_events' : null
+                ].filter(Boolean).join(' and ');
+                const followup = `You must call ${required} now. Do not repeat tools already called. Do not spawn workers.`;
+                currentMessages = [
+                    ...currentMessages,
+                    { role: 'assistant', content: response.content },
+                    { role: 'user', content: toolResults },
+                    { role: 'user', content: followup }
+                ];
+                continue;
+            }
+            if (wantsTodoOrCal && !missingTodo && !missingCal) {
                 const updates = [];
                 if (toolNames.includes('todo_upsert_items'))
                     updates.push('Updated /todo.');

package/dist/websocket.d.ts

@@ -35,6 +35,8 @@ export declare class AgentWebSocket {
     private reconnectDelay;
     private pingInterval;
     private isConnected;
+    private connecting;
+    private connectPromise;
     private pendingResponses;
     private cloudflareBlocked;
     private pendingMessages;

package/dist/websocket.js

@@ -19,6 +19,8 @@ export class AgentWebSocket {
     reconnectDelay = 1000;
     pingInterval = null;
     isConnected = false;
+    connecting = false;
+    connectPromise = null;
     pendingResponses = new Map();
     cloudflareBlocked = false; // Track if Cloudflare is blocking WebSockets
     pendingMessages = [];
@@ -40,7 +42,32 @@ export class AgentWebSocket {
      * Connect to the WebSocket server
      */
     async connect() {
-        return new Promise((resolve) => {
+        if (this.connected()) {
+            return Promise.resolve(true);
+        }
+        if (this.connecting && this.connectPromise) {
+            return this.connectPromise;
+        }
+        if (this.ws && this.ws.readyState !== WebSocket.OPEN) {
+            try {
+                this.ws.terminate();
+            }
+            catch {
+                // Ignore terminate errors
+            }
+            this.ws = null;
+        }
+        this.connecting = true;
+        this.connectPromise = new Promise((resolve) => {
+            let settled = false;
+            const finalize = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.connecting = false;
+                this.connectPromise = null;
+                resolve(value);
+            };
             try {
                 console.log('[WS] Connecting to', this.serverUrl);
                 this.ws = new WebSocket(this.serverUrl, {
@@ -59,7 +86,7 @@ export class AgentWebSocket {
                     else {
                         this.readyPending = true;
                     }
-                    resolve(true);
+                    finalize(true);
                 });
                 this.ws.on('message', (data) => {
                     this.handleMessage(data.toString());
@@ -72,6 +99,7 @@ export class AgentWebSocket {
                     this.isConnected = false;
                     this.stopPingInterval();
                     this.attemptReconnect();
+                    finalize(false);
                 });
                 this.ws.on('error', (error) => {
                     // Check for Cloudflare 524 timeout - don't spam logs
@@ -85,22 +113,23 @@ export class AgentWebSocket {
                         console.error('[WS] Error:', error.message);
                     }
                     if (!this.isConnected) {
-                        resolve(false);
+                        finalize(false);
                     }
                 });
                 // Timeout for initial connection
                 setTimeout(() => {
                     if (!this.isConnected) {
                         console.log('[WS] Connection timeout');
-                        resolve(false);
+                        finalize(false);
                     }
                 }, 10000);
             }
             catch (error) {
                 console.error('[WS] Connection failed:', error);
-                resolve(false);
+                finalize(false);
             }
         });
+        return this.connectPromise;
     }
     /**
      * Set handler for incoming messages
@@ -339,7 +368,9 @@ export class AgentWebSocket {
         this.reconnectAttempts++;
         const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
         setTimeout(() => {
-            this.connect();
+            if (!this.connecting) {
+                this.connect();
+            }
         }, delay);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siftd/connect-agent",
-  "version": "0.2.52",
+  "version": "0.2.54",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",