obol-ai 0.2.6 → 0.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obol-ai",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Self-evolving AI assistant that learns, remembers, and acts on its own. Persistent vector memory, self-rewriting personality, proactive heartbeats.",
   "main": "src/index.js",
   "bin": {
@@ -22,7 +22,7 @@
   "author": "Jo Vinkenroye <jestersimpps@gmail.com>",
   "license": "MIT",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.39.0",
+    "@anthropic-ai/sdk": "^0.78.0",
     "@supabase/supabase-js": "^2.49.1",
     "@xenova/transformers": "^2.17.2",
     "commander": "^13.1.0",

package/src/background.js

@@ -78,7 +78,7 @@ This helps track what you're doing. Complete the full task, then give the final
 TASK: ${task}`;
 
       const bgNotify = verboseNotify ? (msg) => verboseNotify(`[bg#${taskState.id}] ${msg}`) : undefined;
-      const result = await claude.chat(bgPrompt, {
+      const { text: result } = await claude.chat(bgPrompt, {
         chatId: `bg-${taskState.id}`,
         userName: 'BackgroundTask',
         verbose,
@@ -125,7 +125,7 @@ Give a ONE LINE progress update (emoji + what's happening). Be specific about wh
 
       // Use a separate quick call — don't interfere with the main task
       const checkInChatId = `checkin-${taskState.id}`;
-      const update = await claude.chat(checkInPrompt, {
+      const { text: update } = await claude.chat(checkInPrompt, {
         chatId: checkInChatId,
         userName: 'CheckIn',
       });
@@ -177,6 +177,7 @@ function formatDuration(seconds) {
 }
 
 async function sendLong(ctx, text) {
+  if (!text?.trim()) return;
   if (text.length <= 4096) {
     await ctx.reply(text, { parse_mode: 'Markdown' }).catch(() =>
       ctx.reply(text)

package/src/claude.js

@@ -5,6 +5,7 @@ const { execSync, execFileSync } = require('child_process');
 const { refreshTokens, isExpired, isOAuthToken } = require('./oauth');
 const { saveConfig, loadConfig, OBOL_DIR } = require('./config');
 const { execAsync, isAllowedUrl } = require('./sanitize');
+const { ChatHistory } = require('./history');
 
 const MAX_EXEC_TIMEOUT = 120;
 let MAX_TOOL_ITERATIONS = 100;
@@ -114,74 +115,14 @@ async function ensureFreshToken(anthropicConfig) {
   }
 }
 
-function repairHistory(history) {
-  const allToolUseIds = new Set();
-  for (const msg of history) {
-    if (msg.role === 'assistant' && Array.isArray(msg.content)) {
-      for (const b of msg.content) {
-        if (b.type === 'tool_use') allToolUseIds.add(b.id);
-      }
-    }
-  }
-
-  for (let i = history.length - 1; i >= 0; i--) {
-    const msg = history[i];
-    if (msg.role !== 'user' || !Array.isArray(msg.content)) continue;
-    const toolResults = msg.content.filter(b => b.type === 'tool_result');
-    if (toolResults.length === 0) continue;
-    const orphaned = toolResults.filter(b => !allToolUseIds.has(b.tool_use_id));
-    if (orphaned.length === 0) continue;
-    const remaining = msg.content.filter(b => b.type !== 'tool_result' || allToolUseIds.has(b.tool_use_id));
-    if (remaining.length === 0) {
-      history.splice(i, 1);
-    } else {
-      msg.content = remaining;
-    }
-  }
-
-  for (let i = 0; i < history.length; i++) {
-    const msg = history[i];
-    if (msg.role !== 'assistant' || !Array.isArray(msg.content)) continue;
-    const toolUseIds = msg.content.filter(b => b.type === 'tool_use').map(b => b.id);
-    if (toolUseIds.length === 0) continue;
-    const next = history[i + 1];
-    if (next?.role === 'user' && Array.isArray(next.content)) {
-      const existingIds = new Set(next.content.filter(b => b.type === 'tool_result').map(b => b.tool_use_id));
-      const missingIds = toolUseIds.filter(id => !existingIds.has(id));
-      if (missingIds.length > 0) {
-        next.content = [
-          ...next.content,
-          ...missingIds.map(id => ({ type: 'tool_result', tool_use_id: id, content: '[interrupted]' })),
-        ];
-      }
-    } else {
-      const fakeResults = toolUseIds.map(id => ({
-        type: 'tool_result', tool_use_id: id, content: '[interrupted]',
-      }));
-      history.splice(i + 1, 0, { role: 'user', content: fakeResults });
-    }
-  }
-
-  for (let i = history.length - 1; i > 0; i--) {
-    if (history[i].role === history[i - 1].role && history[i].role === 'user') {
-      const prev = history[i - 1];
-      const curr = history[i];
-      const prevArr = Array.isArray(prev.content) ? prev.content : [{ type: 'text', text: prev.content }];
-      const currArr = Array.isArray(curr.content) ? curr.content : [{ type: 'text', text: curr.content }];
-      history[i - 1] = { role: 'user', content: [...prevArr, ...currArr] };
-      history.splice(i, 1);
-    }
-  }
-}
-
 function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR, bridgeEnabled }) {
   let client = createAnthropicClient(anthropicConfig);
 
   let baseSystemPrompt = buildSystemPrompt(personality, userDir, { bridgeEnabled });
 
-  const histories = new Map();
+  const histories = new ChatHistory(50);
   const chatLocks = new Map();
-  const MAX_HISTORY = 50;
+  const chatAbortControllers = new Map();
 
   const tools = buildTools(memory, { bridgeEnabled });
 
@@ -206,12 +147,13 @@ function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR
     const chatId = context.chatId || 'default';
 
     if (isChatBusy(chatId)) {
-      return 'I\'m still working on the previous request. Give me a moment.';
+      return { text: 'I\'m still working on the previous request. Give me a moment.', usage: null, model: null };
     }
 
     const releaseLock = await acquireChatLock(chatId);
+    const abortController = new AbortController();
+    chatAbortControllers.set(chatId, abortController);
 
-    if (!histories.has(chatId)) histories.set(chatId, []);
     const history = histories.get(chatId);
 
     try {
@@ -296,133 +238,93 @@ Model: Default to "sonnet". Use "haiku" for: greetings, brief acknowledgments (t
       }
     }
 
-    while (history.length >= MAX_HISTORY) {
-      let cut = 0;
-      while (cut < history.length - 1) {
-        const msg = history[cut];
-        cut++;
-        if (msg.role === 'assistant' && Array.isArray(msg.content) &&
-            msg.content.some(b => b.type === 'tool_use')) continue;
-        if (msg.role === 'user' && Array.isArray(msg.content) &&
-            msg.content.some(b => b.type === 'tool_result')) continue;
-        if (msg.role === 'assistant') break;
-      }
-      history.splice(0, cut);
-      if (cut === 0) { history.shift(); history.shift(); break; }
-    }
-    while (history.length > 0) {
-      const first = history[0];
-      if (first.role !== 'user') { history.shift(); continue; }
-      if (Array.isArray(first.content) && first.content.some(b => b.type === 'tool_result')) {
-        history.shift(); continue;
-      }
-      break;
-    }
-    repairHistory(history);
+    histories.prune(chatId);
 
-    // Add user message with memory context
     const enrichedMessage = memoryContext
       ? userMessage + memoryContext
       : userMessage;
     if (context.images?.length) {
-      history.push({
-        role: 'user',
-        content: [...context.images, { type: 'text', text: enrichedMessage }],
-      });
+      histories.pushUser(chatId, [...context.images, { type: 'text', text: enrichedMessage }]);
     } else {
-      history.push({ role: 'user', content: enrichedMessage });
+      histories.pushUser(chatId, enrichedMessage);
     }
 
     const model = context._model || 'claude-sonnet-4-6';
     vlog(`[model] ${model} | history=${history.length} msgs`);
     const systemPrompt = baseSystemPrompt + `\nCurrent time: ${new Date().toISOString()}`;
-    let response = await client.messages.create({
+    const runnableTools = buildRunnableTools(tools, memory, context, vlog);
+
+    const runner = client.beta.messages.toolRunner({
       model,
       max_tokens: 4096,
       system: systemPrompt,
-      messages: history,
-      tools: tools.length > 0 ? tools : undefined,
-    });
-
-    let toolIterations = 0;
-    while (response.stop_reason === 'tool_use') {
-      toolIterations++;
-      if (toolIterations > MAX_TOOL_ITERATIONS) {
-        const bailoutContent = response.content;
-        history.push({ role: 'assistant', content: bailoutContent });
-        const bailoutResults = bailoutContent
-          .filter(b => b.type === 'tool_use')
-          .map(b => ({ type: 'tool_result', tool_use_id: b.id, content: '[max tool iterations reached]' }));
-        history.push({ role: 'user', content: [
-          ...bailoutResults,
-          { type: 'text', text: 'You have used too many tool calls. Please provide a final response now based on what you have so far.' },
-        ] });
-        response = await client.messages.create({
-          model,
-          max_tokens: 4096,
-          system: systemPrompt,
-          messages: history,
-        });
-        break;
+      messages: [...history],
+      tools: runnableTools.length > 0 ? runnableTools : undefined,
+      max_iterations: MAX_TOOL_ITERATIONS,
+    }, { signal: abortController.signal });
+
+    let finalMessage;
+    let totalUsage = { input_tokens: 0, output_tokens: 0 };
+    for await (const message of runner) {
+      finalMessage = message;
+      if (message.usage) {
+        totalUsage.input_tokens += message.usage.input_tokens || 0;
+        totalUsage.output_tokens += message.usage.output_tokens || 0;
+        vlog(`[tokens] in=${message.usage.input_tokens} out=${message.usage.output_tokens}`);
       }
-
-      const assistantContent = response.content;
-      history.push({ role: 'assistant', content: assistantContent });
-
-      const toolResults = [];
-      for (const block of assistantContent) {
-        if (block.type === 'tool_use') {
-          const inputSummary = block.name === 'exec' ? block.input.command :
-            block.name === 'write_file' ? block.input.path :
-            block.name === 'read_file' ? block.input.path :
-            block.name === 'memory_search' ? block.input.query :
-            block.name === 'memory_add' ? `[${block.input.category || 'fact'}]` :
-            block.name === 'web_fetch' ? block.input.url :
-            block.name === 'background_task' ? block.input.task?.substring(0, 60) :
-            JSON.stringify(block.input).substring(0, 80);
-          vlog(`[tool] ${block.name}: ${inputSummary}`);
-          const result = await executeToolCall(block, memory, context);
-          toolResults.push({
-            type: 'tool_result',
-            tool_use_id: block.id,
-            content: result,
-          });
-        }
-      }
-
-      history.push({ role: 'user', content: toolResults });
-
-      response = await client.messages.create({
-        model,
-        max_tokens: 4096,
-        system: systemPrompt,
-        messages: history,
-        tools,
-      });
     }
 
-    const textBlocks = response.content.filter(b => b.type === 'text');
-    const replyText = textBlocks.map(b => b.text).join('\n');
-
-    if (response.usage) {
-      vlog(`[tokens] in=${response.usage.input_tokens} out=${response.usage.output_tokens}`);
+    const runnerMessages = runner.params.messages;
+    const newMessages = runnerMessages.slice(history.length);
+    histories.pushMessages(chatId, newMessages);
+
+    if (finalMessage.stop_reason === 'tool_use') {
+      const bailoutResults = finalMessage.content
+        .filter(b => b.type === 'tool_use')
+        .map(b => ({ type: 'tool_result', tool_use_id: b.id, content: '[max tool iterations reached]' }));
+      histories.pushUser(chatId, [
+        ...bailoutResults,
+        { type: 'text', text: 'You have used too many tool calls. Please provide a final response now based on what you have so far.' },
+      ]);
+      const bailoutResponse = await client.messages.create({
+        model, max_tokens: 4096, system: systemPrompt, messages: [...histories.get(chatId)],
+      }, { signal: abortController.signal });
+      histories.pushAssistant(chatId, bailoutResponse.content);
+      if (bailoutResponse.usage) {
+        totalUsage.input_tokens += bailoutResponse.usage.input_tokens || 0;
+        totalUsage.output_tokens += bailoutResponse.usage.output_tokens || 0;
+      }
+      const text = bailoutResponse.content.filter(b => b.type === 'text').map(b => b.text).join('\n');
+      return { text, usage: totalUsage, model };
     }
 
-    history.push({ role: 'assistant', content: response.content });
-
-    return replyText;
+    const text = finalMessage.content.filter(b => b.type === 'text').map(b => b.text).join('\n');
+    return { text, usage: totalUsage, model };
 
     } catch (e) {
+      if (e.message === 'Request was aborted.' || e.constructor?.name === 'APIUserAbortError') {
+        return { text: null, usage: null, model: null };
+      }
       if (e.status === 400 && e.message?.includes('tool_use')) {
         console.error('[claude] Repairing corrupted history after 400 error');
-        repairHistory(history);
+        histories.repair(chatId);
       }
       throw e;
     } finally {
+      chatAbortControllers.delete(chatId);
       releaseLock();
     }
   }
 
+  function stopChat(chatId) {
+    const controller = chatAbortControllers.get(chatId);
+    if (controller) {
+      controller.abort();
+      return true;
+    }
+    return false;
+  }
+
   function reloadPersonality() {
     const pDir = userDir ? path.join(userDir, 'personality') : undefined;
     const newPersonality = require('./personality').loadPersonality(pDir);
@@ -440,33 +342,15 @@ Model: Default to "sonnet". Use "haiku" for: greetings, brief acknowledgments (t
   }
 
   function injectHistory(chatId, role, content) {
-    if (!histories.has(chatId)) histories.set(chatId, []);
-    const history = histories.get(chatId);
-    history.push({ role, content });
+    histories.inject(chatId, role, content);
   }
 
   function getContextStats(chatId) {
     const id = chatId || 'default';
-    const history = histories.get(id) || [];
-    const MAX_CONTEXT = 200000;
-    let chars = baseSystemPrompt.length;
-    for (const msg of history) {
-      if (typeof msg.content === 'string') {
-        chars += msg.content.length;
-      } else if (Array.isArray(msg.content)) {
-        for (const b of msg.content) {
-          if (b.text) chars += b.text.length;
-          else if (b.content) chars += (typeof b.content === 'string' ? b.content.length : JSON.stringify(b.content).length);
-          else if (b.type === 'tool_use') chars += JSON.stringify(b.input || {}).length + (b.name?.length || 0);
-        }
-      }
-    }
-    const estimatedTokens = Math.round(chars / 4);
-    const pct = Math.min(100, Math.round((estimatedTokens / MAX_CONTEXT) * 100));
-    return { messages: history.length, estimatedTokens, maxTokens: MAX_CONTEXT, pct };
+    return histories.estimateTokens(id, baseSystemPrompt.length);
   }
 
-  return { chat, client, reloadPersonality, clearHistory, injectHistory, getContextStats };
+  return { chat, client, reloadPersonality, clearHistory, injectHistory, getContextStats, stopChat };
 }
 
 function buildSystemPrompt(personality, userDir, opts = {}) {
@@ -622,6 +506,14 @@ Examples:
 
 Returns the tapped button label, or \`"timeout"\` if the user doesn't respond within the timeout (default 60s).
 
+### Scheduling (\`schedule_event\`, \`list_events\`, \`cancel_event\`)
+Schedule reminders and events. The user gets a Telegram message when the time comes.
+- \`schedule_event\` — schedule a reminder with title, due_at (ISO 8601), timezone (IANA), optional description
+- \`list_events\` — list pending/sent/cancelled events
+- \`cancel_event\` — cancel a scheduled event by ID
+
+When scheduling: always search memory first for the user's timezone/location. If no timezone found, ask the user or default to UTC. Parse natural language dates relative to the user's timezone.
+
 ### Bridge (\`bridge_ask\`, \`bridge_tell\`)
 Only available if bridge is enabled. Communicate with partner's AI agent.
 `);
@@ -893,6 +785,44 @@ function buildTools(memory, opts = {}) {
     },
   });
 
+  tools.push({
+    name: 'schedule_event',
+    description: 'Schedule a reminder or event. The user will receive a Telegram message when the time comes. Always search memory first for the user\'s timezone/location. If no timezone found, ask the user or default to UTC.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Short title for the reminder/event' },
+        due_at: { type: 'string', description: 'ISO 8601 datetime string for when the event is due (e.g. 2026-02-25T15:00:00)' },
+        timezone: { type: 'string', description: 'IANA timezone (e.g. Europe/Brussels, America/New_York). Default: UTC' },
+        description: { type: 'string', description: 'Context or details about the event. Always include relevant info from the conversation (e.g. what to do, who it involves, where).' },
+      },
+      required: ['title', 'due_at'],
+    },
+  });
+
+  tools.push({
+    name: 'list_events',
+    description: 'List scheduled events/reminders for the user.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        status: { type: 'string', enum: ['pending', 'sent', 'cancelled'], description: 'Filter by status (default: pending)' },
+      },
+    },
+  });
+
+  tools.push({
+    name: 'cancel_event',
+    description: 'Cancel a scheduled event/reminder by its ID.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        event_id: { type: 'string', description: 'UUID of the event to cancel' },
+      },
+      required: ['event_id'],
+    },
+  });
+
   if (opts.bridgeEnabled) {
     const { buildBridgeTool, buildBridgeTellTool } = require('./bridge');
     tools.push(buildBridgeTool());
@@ -902,6 +832,26 @@ function buildTools(memory, opts = {}) {
   return tools;
 }
 
+function buildRunnableTools(tools, memory, context, vlog) {
+  return tools.map(tool => ({
+    ...tool,
+    run: async (input) => {
+      const inputSummary = tool.name === 'exec' ? input.command :
+        tool.name === 'write_file' ? input.path :
+        tool.name === 'read_file' ? input.path :
+        tool.name === 'memory_search' ? input.query :
+        tool.name === 'memory_add' ? `[${input.category || 'fact'}]` :
+        tool.name === 'web_fetch' ? input.url :
+        tool.name === 'background_task' ? input.task?.substring(0, 60) :
+        tool.name === 'schedule_event' ? `${input.title} @ ${input.due_at}` :
+        tool.name === 'cancel_event' ? input.event_id :
+        JSON.stringify(input).substring(0, 80);
+      vlog(`[tool] ${tool.name}: ${inputSummary}`);
+      return await executeToolCall({ name: tool.name, input }, memory, context);
+    },
+  }));
+}
+
 function resolveUserPath(inputPath, userDir) {
   if (!userDir) throw new Error('userDir is required for path resolution');
   const resolved = path.isAbsolute(inputPath)
@@ -1122,6 +1072,39 @@ async function executeToolCall(toolUse, memory, context = {}) {
         return await bridgeTell(input.message, context.userId, context.config, context._notifyFn, input.partner_id);
       }
 
+      case 'schedule_event': {
+        if (!context.scheduler) return 'Scheduler not available (Supabase not configured).';
+        const tz = input.timezone || 'UTC';
+        const localDate = new Date(input.due_at);
+        if (isNaN(localDate.getTime())) return `Invalid date: ${input.due_at}`;
+        const utcDate = toUTC(input.due_at, tz);
+        const event = await context.scheduler.add(context.chatId, input.title, utcDate, tz, input.description || null);
+        const displayTime = new Date(utcDate).toLocaleString('en-US', { timeZone: tz });
+        return `Scheduled: "${input.title}" for ${displayTime} (${tz}) — ID: ${event.id}`;
+      }
+
+      case 'list_events': {
+        if (!context.scheduler) return 'Scheduler not available (Supabase not configured).';
+        const events = await context.scheduler.list({ status: input.status });
+        if (events.length === 0) return `No ${input.status || 'pending'} events.`;
+        return JSON.stringify(events.map(e => ({
+          id: e.id,
+          title: e.title,
+          description: e.description,
+          due_at: e.due_at,
+          timezone: e.timezone,
+          due_local: new Date(e.due_at).toLocaleString('en-US', { timeZone: e.timezone }),
+          status: e.status,
+        })));
+      }
+
+      case 'cancel_event': {
+        if (!context.scheduler) return 'Scheduler not available (Supabase not configured).';
+        const cancelled = await context.scheduler.cancel(input.event_id);
+        if (!cancelled) return `Event not found or not yours: ${input.event_id}`;
+        return `Cancelled: "${cancelled.title}"`;
+      }
+
       default:
         return `Unknown tool: ${name}`;
     }
@@ -1130,6 +1113,25 @@ async function executeToolCall(toolUse, memory, context = {}) {
   }
 }
 
+function toUTC(dateStr, timezone) {
+  const match = dateStr.match(/(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):?(\d{2})?/);
+  if (!match) return new Date(dateStr + 'Z').toISOString();
+  const [, y, mo, d, h, mi, s] = match;
+  const wallAsUTC = Date.UTC(+y, +mo - 1, +d, +h, +mi, +(s || 0));
+  if (timezone === 'UTC') return new Date(wallAsUTC).toISOString();
+  const fmt = new Intl.DateTimeFormat('en-US', {
+    timeZone: timezone,
+    year: 'numeric', month: '2-digit', day: '2-digit',
+    hour: '2-digit', minute: '2-digit', second: '2-digit',
+    hour12: false,
+  });
+  const parts = fmt.formatToParts(new Date(wallAsUTC));
+  const get = (type) => parts.find(p => p.type === type)?.value || '00';
+  const hr = +get('hour') === 24 ? 0 : +get('hour');
+  const tzWall = Date.UTC(+get('year'), +get('month') - 1, +get('day'), hr, +get('minute'), +get('second'));
+  return new Date(wallAsUTC - (tzWall - wallAsUTC)).toISOString();
+}
+
 function getMaxToolIterations() { return MAX_TOOL_ITERATIONS; }
 function setMaxToolIterations(n) { MAX_TOOL_ITERATIONS = n; }
 

package/src/db/migrate.js

@@ -130,6 +130,38 @@ async function migrate(supabaseConfig) {
       CREATE POLICY "service_role_all" ON obol_messages FOR ALL TO service_role USING (true) WITH CHECK (true);
     EXCEPTION WHEN duplicate_object THEN NULL;
     END $$;`,
+
+    // Events table (scheduling & reminders)
+    `CREATE TABLE IF NOT EXISTS obol_events (
+      id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+      user_id BIGINT NOT NULL,
+      chat_id BIGINT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT,
+      due_at TIMESTAMPTZ NOT NULL,
+      timezone TEXT NOT NULL DEFAULT 'UTC',
+      status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','sent','cancelled')),
+      created_at TIMESTAMPTZ DEFAULT NOW()
+    );`,
+    `CREATE INDEX IF NOT EXISTS idx_obol_events_due ON obol_events (due_at) WHERE status = 'pending';`,
+    `CREATE INDEX IF NOT EXISTS idx_obol_events_user ON obol_events (user_id);`,
+    `ALTER TABLE obol_events ENABLE ROW LEVEL SECURITY;`,
+    `DO $$ BEGIN
+      CREATE POLICY "service_role_all" ON obol_events FOR ALL TO service_role USING (true) WITH CHECK (true);
+    EXCEPTION WHEN duplicate_object THEN NULL;
+    END $$;`,
+
+    // Drop redundant user_id from obol_messages (chat_id == user_id for Telegram private chats)
+    `DROP INDEX IF EXISTS idx_obol_messages_user;`,
+    `ALTER TABLE obol_messages DROP COLUMN IF EXISTS user_id;`,
+
+    // Atomic access count increment for memory search hits
+    `CREATE OR REPLACE FUNCTION increment_memory_access(memory_ids UUID[])
+    RETURNS VOID LANGUAGE SQL AS $$
+      UPDATE obol_memory
+      SET access_count = access_count + 1, accessed_at = NOW()
+      WHERE id = ANY(memory_ids);
+    $$;`,
   ];
 
   // Save SQL file for manual fallback
@@ -148,24 +180,24 @@ async function migrate(supabaseConfig) {
   }
 
   const projectRef = url.replace('https://', '').replace('.supabase.co', '');
+  const batchedSql = sqlStatements.join('\n\n');
 
-  for (const sql of sqlStatements) {
-    try {
-      const res = await fetch(`https://api.supabase.com/v1/projects/${projectRef}/database/query`, {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${accessToken}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ query: sql }),
-      });
-      if (!res.ok) {
-        const err = await res.text();
-        console.log(`  ⚠️  SQL warning: ${err.substring(0, 100)}`);
-      }
-    } catch (e) {
-      console.log(`  ⚠️  Migration step failed: ${e.message}`);
+  try {
+    const res = await fetch(`https://api.supabase.com/v1/projects/${projectRef}/database/query`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ query: batchedSql }),
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      console.log(`  ⚠️  Migration warning: ${err.substring(0, 200)}`);
     }
+  } catch (e) {
+    console.log(`  ⚠️  Migration failed: ${e.message}`);
   }
 }