@oar-sh/oar 0.9.23 → 0.9.25

package/server/claude-worker/claude-sdk-adapter.mjs

@@ -1,4 +1,4 @@
-import { createSdkMcpServer, query } from '@anthropic-ai/claude-agent-sdk';
+import { loadAgentSdk } from '../agent-sdk-loader.mjs';
 
 import { formatClaudeBackgroundCommandLimitLabel } from '../../shared/claude-background-command-limit.mjs';
 import { parseThinkingDisplay } from '../../shared/claude-thinking.mjs';
@@ -9,6 +9,9 @@ import { createPreviewToolDefinition } from './claude-preview-tool.mjs';
 import { createRemoteRelayToolDefinition } from './claude-remote-relay-tool.mjs';
 import { CLAUDE_LIVE_FLAG_SETTINGS_CODE, CLAUDE_LIVE_FLAG_SETTINGS_GUIDANCE } from './claude-turn-failure.mjs';
 
+// The SDK the relay installed for this worker (agent-sdk-loader.mjs).
+const { createSdkMcpServer, query } = await loadAgentSdk('claude');
+
 export { CLAUDE_LIVE_FLAG_SETTINGS_CODE };
 
 // The name the in-process MCP server is registered under; it prefixes every

package/server/claude-worker/sdk-message-normalizer.mjs

@@ -555,6 +555,11 @@ export function createSdkMessageNormalizer() {
         const thinking = state.thinking.get(index);
         if (thinking) {
           thinking.text = capThought(thinking.text + String(event?.delta?.thinking || ''));
+          // Gated as stream text: a delta can be one token, and every update
+          // carries the whole thought. Past the cap the text stops changing,
+          // so nothing more goes out until the block's final frame.
+          if (!shouldEmitStreamUpdate(thinking.text, thinking.lastEmittedText)) return actions;
+          thinking.lastEmittedText = thinking.text;
           actions.push({
             channel: 'thought',
             payload: {
@@ -715,7 +720,7 @@ export function createSdkMessageNormalizer() {
       const assistantError = lastAssistantError;
       lastAssistantError = '';
       const apiErrorStatus = Number(sdkMessage.api_error_status ?? NaN);
-      return [{
+      return [...flushOpenThoughts(), {
         channel: 'result',
         payload: {
           text: String(sdkMessage.result || '').trim(),
@@ -745,6 +750,29 @@ export function createSdkMessageNormalizer() {
     return [];
   }
 
+  // A thinking block the turn left open (aborted, failed) never gets its
+  // final frame: what the delta gating held back goes out with the result,
+  // so the stored thought ends with the last delta.
+  function flushOpenThoughts() {
+    const actions = [];
+    for (const state of threads.values()) {
+      for (const thinking of state.thinking.values()) {
+        if (!thinking.text.trim() || thinking.text === thinking.lastEmittedText) continue;
+        thinking.lastEmittedText = thinking.text;
+        actions.push({
+          channel: 'thought',
+          payload: {
+            reasoningId: thinking.reasoningId,
+            text: thinking.text,
+            done: false,
+            subagentRunId: subagentRunIdFor(state.key === 'main' ? null : state.key),
+          },
+        });
+      }
+    }
+    return actions;
+  }
+
   function finalStreamText() {
     return threadState(null).streamText;
   }

package/server/copilot-worker/copilot-sdk-session-process.mjs

@@ -5005,10 +5005,12 @@ export function createCopilotSdkSessionRunner({
 
   /**
    * One image-model row (shared/worker-runtime/direct-openai-image.mjs). With
-   * an image operation the relay's execute route publishes the reply, the
-   * failure or the requeue itself; without one the shared helper publishes
-   * the reply, and a refusal by the provider is published here as the row's
-   * failure. Anything else requeues the row, as on the extension engine.
+   * an image operation the relay's execute route publishes the reply or the
+   * failure itself; without one the shared helper publishes the reply, and
+   * any failure of the request is published here as the row's failure, never
+   * requeued: the relay already retried it once, and a second run is billed
+   * again. Only an execute call that did not get through requeues the row
+   * (the route refuses to send an operation's request twice).
    */
   async function runDirectImageTurn(message) {
     const id = String(message.id || '');
@@ -5025,15 +5027,18 @@ export function createCopilotSdkSessionRunner({
       dbg('image turn', message.id, result.via, result.outcome);
     } catch (error) {
       if (isOpenAIImageTerminalError(error)) {
-        dbg('image turn refused by OpenAI', message.id, error.message);
+        // The relay's note and code (the ones its image operation uses for
+        // the same cases); an older relay names no code.
+        const code = error.imageCode
+          || (error.relayProcessing === true ? 'image-reply-unprocessed' : 'image-provider-rejected');
+        dbg('image turn failed', message.id, code, error.message);
         await publishResponse(message, {
           text: error.message,
           model: null,
           terminalError: {
             kind: 'openai-image-failed',
-            // The code the relay's image operation uses for the same refusal.
-            code: 'image-provider-rejected',
-            stableCode: 'image-provider-rejected',
+            code,
+            stableCode: code,
             message: error.message,
             ...(error.detail ? { detail: String(error.detail) } : {}),
             failedAt: new Date().toISOString(),

package/server/cursor-worker/cursor-sdk-adapter.mjs

@@ -1,6 +1,8 @@
 import path from 'node:path';
 import fs from 'node:fs';
 
+import { loadAgentSdk } from '../agent-sdk-loader.mjs';
+
 import {
   createTurnLiveness,
   createTurnStalledError,
@@ -18,7 +20,7 @@ import { WORKING_DIRECTORY_MISSING_CODE, isWorkingDirectoryMissingError } from '
  */
 
 async function defaultAgentFactory() {
-  const { Agent } = await import('@cursor/sdk');
+  const { Agent } = await loadAgentSdk('cursor');
   return {
     create: (options) => Agent.create(options),
     resume: (agentId, options) => Agent.resume(agentId, options),
@@ -30,7 +32,7 @@ async function defaultAgentFactory() {
 // `storeFactoryImpl(storePath, { cwd })` with the real store rooted in the
 // storePath's directory.
 async function defaultStoreFactory() {
-  const { SqliteLocalAgentStore } = await import('@cursor/sdk/sqlite');
+  const { SqliteLocalAgentStore } = await loadAgentSdk('cursor', { entry: 'sqlite' });
   return (storePath, { cwd } = {}) =>
     SqliteLocalAgentStore.open({
       workspaceRef: cwd || path.dirname(storePath),
@@ -497,7 +499,7 @@ async function defaultModelsList({ apiKey }) {
   // The namespace form is the only working call shape: `Cursor` has a private
   // constructor and `models` is a static member, so the old client-instance
   // fallback could only ever throw a TypeError that masked the real error.
-  const sdk = await import('@cursor/sdk');
+  const sdk = await loadAgentSdk('cursor');
   return sdk.Cursor.models.list({ apiKey });
 }
 

package/server/cursor-worker/sdk-message-normalizer.mjs

@@ -170,6 +170,9 @@ export function createSdkMessageNormalizer() {
       deltaOwnsThinking = true;
       if (!openThought) openThought = { reasoningId: allocateThoughtId(), text: '' };
       openThought.text = capThought(openThought.text + String(update?.text || ''));
+      // Gated as stream text; the thought's close sends the whole text.
+      if (!shouldEmitStreamUpdate(openThought.text, openThought.lastEmittedText)) return actions;
+      openThought.lastEmittedText = openThought.text;
       actions.push({
         channel: 'thought',
         payload: {
@@ -201,6 +204,14 @@ export function createSdkMessageNormalizer() {
 
     if (type === 'turn-ended') {
       if (update?.usage && typeof update.usage === 'object') lastUsage = update.usage;
+      // A thought the turn left open: what the delta gating held back.
+      if (openThought?.text.trim() && openThought.text !== openThought.lastEmittedText) {
+        openThought.lastEmittedText = openThought.text;
+        actions.push({
+          channel: 'thought',
+          payload: { reasoningId: openThought.reasoningId, text: openThought.text, done: false, subagentRunId: null },
+        });
+      }
       return actions;
     }
 
@@ -231,6 +242,8 @@ export function createSdkMessageNormalizer() {
           state.openThought = { reasoningId: `cursor-thought-${runId}-${state.thoughtIndex++}`, text: '' };
         }
         state.openThought.text = capThought(state.openThought.text + String(nested.text || ''));
+        if (!shouldEmitStreamUpdate(state.openThought.text, state.openThought.lastEmittedText)) return actions;
+        state.openThought.lastEmittedText = state.openThought.text;
         actions.push({
           channel: 'thought',
           payload: {

package/server/db-schema.mjs

@@ -44,6 +44,8 @@ import { migrateConversationPlanOnly } from './migrations/0035-conversation-plan
 import { migrateTokenUsage } from './migrations/0036-token-usage.mjs';
 import { migrateRelayAsksQueueId } from './migrations/0037-relay-asks-queue-id.mjs';
 import { migrateTurnSeq } from './migrations/0038-turn-seq.mjs';
+import { migrateMediaIndex } from './migrations/0039-media-index.mjs';
+import { migrateImageSessionDefaults } from './migrations/0040-image-session-defaults.mjs';
 import { migrateImageConversationSchema } from './repositories/image-conversation-repository.mjs';
 
 // Mirrors DEFAULT_RELAY_MODE in server-runtime.mjs; used only by the one-time
@@ -1096,6 +1098,23 @@ try {
   console.warn(`[turn-seq] migration 0038 failed; retrying on next boot: ${error?.message || error}`);
 }
 
+// The media gallery index: tables, the two queue triggers on messages and a
+// one-time seed of the queue. The gallery works without it (empty), so a
+// failure is logged and retried next boot.
+try {
+  migrateMediaIndex(db);
+} catch (error) {
+  console.warn(`[media-index] migration 0039 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// An image session's own size/quality/count defaults. Image turns run on the
+// built-in defaults without it, so a failure is logged and retried next boot.
+try {
+  migrateImageSessionDefaults(db);
+} catch (error) {
+  console.warn(`[image-sessions] migration 0040 failed; retrying on next boot: ${error?.message || error}`);
+}
+
 const conversationColumns = db.prepare(`PRAGMA table_info(conversations)`).all().map((c) => c.name);
 if (!conversationColumns.includes('archived')) {
   db.exec(`ALTER TABLE conversations ADD COLUMN archived INTEGER NOT NULL DEFAULT 0`);

package/server/grok-worker/sdk-message-normalizer.mjs

@@ -148,6 +148,9 @@ export function createSdkMessageNormalizer() {
         openThought = { reasoningId: allocateThoughtId(), text: '' };
       }
       openThought.text = capThought(openThought.text + chunk);
+      // Gated as stream text; the thought's close sends the whole text.
+      if (!shouldEmitStreamUpdate(openThought.text, openThought.lastEmittedText)) return actions;
+      openThought.lastEmittedText = openThought.text;
       actions.push({
         channel: 'thought',
         payload: {

package/server/migrations/0039-media-index.mjs

@@ -0,0 +1,167 @@
+'use strict';
+
+/**
+ * Migration: the media gallery index.
+ *
+ * `media_items`: one row per picture, video or attached file of a message
+ * (services/media-extract.mjs decides what counts). Rows go with their
+ * message or conversation (foreign keys, ON DELETE CASCADE). `message_ts`
+ * copies the message time so the gallery pages by an index.
+ *
+ * `media_index_queue`: the ids of messages to (re)index. Two triggers on
+ * `messages` put a row id here on insert and when a column the index reads
+ * changes; they never parse anything, so the write path pays one small
+ * insert. The indexer (services/media-index-service.mjs) drains the queue in
+ * batches. `seq` grows on every re-queue, so a drain only removes the queue
+ * row it actually indexed.
+ *
+ * `media_index_meta`: the extractor version the queue was seeded for. When
+ * it is missing (first run) or older than MEDIA_EXTRACTOR_VERSION, every
+ * message is queued once and the version is stored; later boots seed nothing.
+ *
+ * Not in SCHEMA_SQL (db-schema.mjs): the triggers name columns that older
+ * migrations add. The triggers are checked on every boot and re-created when
+ * missing or different, like the FTS triggers.
+ *
+ * Additive and idempotent. Rolling back: drop the triggers first, then the
+ * tables (a trigger left pointing at a dropped table breaks message inserts):
+ *   DROP TRIGGER IF EXISTS media_index_on_insert;
+ *   DROP TRIGGER IF EXISTS media_index_on_update;
+ *   DROP TABLE IF EXISTS media_index_queue; DROP TABLE IF EXISTS media_items;
+ *   DROP TABLE IF EXISTS media_index_meta;
+ *
+ * Usage: node server/migrations/0039-media-index.mjs [path/to/oar.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+import { cliDbPath } from '../services/database-file.mjs';
+import { MEDIA_EXTRACTOR_VERSION } from '../services/media-extract.mjs';
+
+export const MEDIA_INDEX_TRIGGERS = Object.freeze(['media_index_on_insert', 'media_index_on_update']);
+// Columns the index reads; a change to one re-queues the message.
+const WATCHED_COLUMNS = Object.freeze(['text', 'attachments', 'timestamp', 'role', 'kind', 'origin_json', 'conversation_id']);
+
+const QUEUE_UPSERT = `INSERT INTO media_index_queue (message_id, seq) VALUES (NEW.id, 0)
+    ON CONFLICT(message_id) DO UPDATE SET seq = seq + 1;`;
+
+function tableExists(db, name) {
+  return !!db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`).get(name);
+}
+
+function columnsOf(db, table) {
+  return db.prepare(`PRAGMA table_info(${table})`).all().map((column) => column.name);
+}
+
+export function mediaIndexTriggerSql(messageColumns) {
+  const watched = WATCHED_COLUMNS.filter((column) => messageColumns.includes(column));
+  return {
+    media_index_on_insert: `CREATE TRIGGER media_index_on_insert AFTER INSERT ON messages BEGIN
+    ${QUEUE_UPSERT}
+  END`,
+    media_index_on_update: `CREATE TRIGGER media_index_on_update AFTER UPDATE OF ${watched.join(', ')} ON messages BEGIN
+    ${QUEUE_UPSERT}
+  END`,
+  };
+}
+
+export function migrateMediaIndex(db) {
+  if (!tableExists(db, 'messages') || !tableExists(db, 'conversations')) {
+    return { applied: false, tablesCreated: 0, triggersCreated: 0, seeded: 0 };
+  }
+  let tablesCreated = 0;
+  let triggersCreated = 0;
+  let seeded = 0;
+  const run = db.transaction(() => {
+    if (!tableExists(db, 'media_items')) {
+      db.exec(`
+        CREATE TABLE media_items (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          message_id TEXT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+          conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+          ordinal INTEGER NOT NULL,
+          role TEXT NOT NULL,
+          sender TEXT NOT NULL,
+          origin TEXT NOT NULL,
+          locator_kind TEXT NOT NULL,
+          locator TEXT NOT NULL,
+          identity_key TEXT NOT NULL,
+          category TEXT NOT NULL,
+          media_kind TEXT NOT NULL,
+          mime TEXT,
+          name TEXT,
+          alt TEXT,
+          size_bytes INTEGER,
+          message_ts TEXT NOT NULL,
+          UNIQUE (message_id, ordinal)
+        );
+        CREATE INDEX idx_media_items_conv ON media_items(conversation_id, category, message_ts DESC, id DESC);
+        CREATE INDEX idx_media_items_all ON media_items(category, message_ts DESC, id DESC);
+        CREATE INDEX idx_media_items_identity ON media_items(identity_key);
+      `);
+      tablesCreated += 1;
+    }
+    if (!tableExists(db, 'media_index_queue')) {
+      db.exec(`
+        CREATE TABLE media_index_queue (
+          message_id TEXT PRIMARY KEY REFERENCES messages(id) ON DELETE CASCADE,
+          seq INTEGER NOT NULL DEFAULT 0
+        )
+      `);
+      tablesCreated += 1;
+    }
+    if (!tableExists(db, 'media_index_meta')) {
+      db.exec(`CREATE TABLE media_index_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`);
+      tablesCreated += 1;
+    }
+
+    const expected = mediaIndexTriggerSql(columnsOf(db, 'messages'));
+    for (const name of MEDIA_INDEX_TRIGGERS) {
+      const row = db.prepare(`SELECT sql FROM sqlite_master WHERE type = 'trigger' AND name = ?`).get(name);
+      if (row?.sql === expected[name]) continue;
+      if (row) db.exec(`DROP TRIGGER ${name}`);
+      db.exec(expected[name]);
+      triggersCreated += 1;
+    }
+
+    const version = db.prepare(`SELECT value FROM media_index_meta WHERE key = 'extractor_version'`).get()?.value;
+    if (String(version || '') !== String(MEDIA_EXTRACTOR_VERSION)) {
+      seeded = db.prepare(`
+        INSERT INTO media_index_queue (message_id, seq)
+        SELECT id, 0 FROM messages WHERE true
+        ON CONFLICT(message_id) DO UPDATE SET seq = seq + 1
+      `).run().changes;
+      db.prepare(`INSERT INTO media_index_meta (key, value) VALUES ('extractor_version', ?)
+        ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(String(MEDIA_EXTRACTOR_VERSION));
+    }
+  });
+  run();
+  return { applied: tablesCreated + triggersCreated + seeded > 0, tablesCreated, triggersCreated, seeded };
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateMediaIndex(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  try {
+    const dbPath = cliDbPath(process.argv[2], new URL('..', import.meta.url));
+    const result = migrate(dbPath);
+    console.log(`Migration 0039 on ${dbPath}`);
+    console.log(result.applied
+      ? `  media index: tables created ${result.tablesCreated}, triggers created ${result.triggersCreated}, messages queued ${result.seeded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0039 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0040-image-session-defaults.mjs

@@ -0,0 +1,93 @@
+'use strict';
+
+/**
+ * Migration: an image session's own defaults, and a turn's options.
+ *
+ * `image_sessions.defaults_json`: the size, quality, count, output format and
+ * background an image session's turns use unless a turn names its own
+ * (relay_tool update_session `image`, the conversation settings route).
+ * JSON as shared/openai-image-options.mjs validates it; NULL means none.
+ *
+ * `queue.image_options_json`: the options of one image turn as the send
+ * settled them, for a turn without an image operation (the worker sends them
+ * with its direct request). NULL for every other turn.
+ *
+ * The image tables are created by migrateImageConversationSchema
+ * (repositories/image-conversation-repository.mjs), which this migration
+ * calls first, additively, so a database whose tables are missing gets them
+ * before the column. A database without the queue table (no relay's) is
+ * left alone.
+ *
+ * Additive and idempotent. Safe to run on every boot. Rolling back needs no
+ * data change: older code ignores the column.
+ *
+ * Usage: node server/migrations/0040-image-session-defaults.mjs [path/to/oar.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+import { cliDbPath } from '../services/database-file.mjs';
+import { migrateImageConversationSchema } from '../repositories/image-conversation-repository.mjs';
+
+export function hasImageSessionDefaultsColumn(db) {
+  try {
+    return db.prepare(`PRAGMA table_info(image_sessions)`).all().some((column) => column.name === 'defaults_json');
+  } catch {
+    return false;
+  }
+}
+
+function tableExists(db, name) {
+  return !!db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`).get(name);
+}
+
+export function hasQueueImageOptionsColumn(db) {
+  try {
+    return db.prepare(`PRAGMA table_info(queue)`).all().some((column) => column.name === 'image_options_json');
+  } catch {
+    return false;
+  }
+}
+
+export function migrateImageSessionDefaults(db) {
+  // The image schema reads the queue; a database without one is no relay's.
+  if (!tableExists(db, 'queue')) return { applied: false, columnsAdded: 0 };
+  migrateImageConversationSchema(db);
+  let columnsAdded = 0;
+  if (!hasImageSessionDefaultsColumn(db)) {
+    db.exec(`ALTER TABLE image_sessions ADD COLUMN defaults_json TEXT`);
+    columnsAdded += 1;
+  }
+  if (!hasQueueImageOptionsColumn(db)) {
+    db.exec(`ALTER TABLE queue ADD COLUMN image_options_json TEXT`);
+    columnsAdded += 1;
+  }
+  return { applied: columnsAdded > 0, columnsAdded };
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateImageSessionDefaults(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  try {
+    // The given path, else the database in server/data (oar.db, else the
+    // name before 0.9.20); never a new one.
+    const dbPath = cliDbPath(process.argv[2], new URL('..', import.meta.url));
+    const result = migrate(dbPath);
+    console.log(`Migration 0040 on ${dbPath}`);
+    console.log(result.applied ? `  image session defaults, turn options: columns added ${result.columnsAdded}` : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0040 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}