@oar-sh/oar 0.9.15 → 0.9.17

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

@@ -112,8 +112,13 @@ import { STEER_FOLDED_TEXT, STEER_STOPPED_TEXT, STEER_TURN_FAILED_TEXT } from '.
 import { buildSteerSettleFailure } from '../../shared/steer-settle-failure.mjs';
 import { shouldEmitStreamUpdate } from '../../shared/stream-emit-gating.mjs';
 import { withSteerNote } from '../../shared/steer-note.mjs';
-import { isRelayEventDelivery } from '../../shared/relay-events.mjs';
+import { isRelayAutomatedDelivery } from '../../shared/relay-events.mjs';
 import { isTransientRelayError } from '../../shared/worker-runtime/relay-errors.mjs';
+import {
+  isOpenAIImageTerminalError,
+  runDirectOpenAIImageTurn,
+  shouldUseDirectOpenAIImageApi,
+} from '../../shared/worker-runtime/direct-openai-image.mjs';
 import {
   createTurnLiveness,
   createTurnStalledError,
@@ -556,6 +561,12 @@ export function createCopilotSdkSessionRunner({
   // terminal error until the publish lands, so recovery can never re-run them
   // (see publishSettleMarker).
   const settlingMessages = new Map();
+  // Image-model rows running on the relay's image routes (id → message). They
+  // never reach the runtime, so no turn owns them; the heartbeat and the crash
+  // guard still have to.
+  const directImageMessages = new Map();
+  // `openai` on a BYOK worker; the failure notes name the provider.
+  const workerProvider = String(env.COPILOT_PROVIDER_TYPE || '').trim().toLowerCase();
   // Settle markers that could not be posted even terminally; the heartbeat
   // hands them to the relay to fail (id → terminalError).
   const settleFailedTerminals = new Map();
@@ -3728,7 +3739,7 @@ export function createCopilotSdkSessionRunner({
     // afterwards: a runtime that died or went silent under a Stop used to put
     // the watchdog's failure on every row instead.
     if (failure && !turn.aborted) {
-      const classified = classifyCopilotTurnException(failure);
+      const classified = classifyCopilotTurnException(failure, { provider: workerProvider });
       dbg('copilot turn failed', turn.message?.id || '(continuation)', classified.detail);
       const running = turn.currentOwner || turn.primaryEntry;
       for (const entry of pending) {
@@ -3747,7 +3758,7 @@ export function createCopilotSdkSessionRunner({
       return;
     }
     if (result?.isError) {
-      const classified = classifyCopilotSessionError(result.errorData || { message: result.errorMessage });
+      const classified = classifyCopilotSessionError(result.errorData || { message: result.errorMessage }, { provider: workerProvider });
       dbg('turn failed', turn.message?.id || '(continuation)', classified.stableCode);
       const running = turn.currentOwner || turn.primaryEntry;
       for (const entry of pending) {
@@ -4117,6 +4128,7 @@ export function createCopilotSdkSessionRunner({
           dbg('continuation output dropped (no relay row)');
           const classified = classifyCopilotTurnException(
             turn.failure || new Error('the relay refused a continuation row for this turn'),
+            { provider: workerProvider },
           );
           for (const entry of turn.entries) {
             if (entry.settled || entry.turn !== turn) continue;
@@ -4456,7 +4468,7 @@ export function createCopilotSdkSessionRunner({
     // Not in a continuation: there the running work is the runtime's own
     // follow-up, not a request of the user's to keep going with.
     // Nor in an event message the relay wrote: the note speaks as the user.
-    const prompt = withRelayContext(context?.prefix, turn.kind === 'continuation' || isRelayEventDelivery(message) ? body : withSteerNote(body));
+    const prompt = withRelayContext(context?.prefix, turn.kind === 'continuation' || isRelayAutomatedDelivery(message) ? body : withSteerNote(body));
     // Re-checked AFTER the awaits and before anything is sent or registered.
     // Nothing has been sent yet, so handing the row back to the normal path is
     // free.
@@ -4821,6 +4833,9 @@ export function createCopilotSdkSessionRunner({
   async function handlePendingPayload(pending) {
     const message = pending?.message || null;
     if (!message) return false;
+    // An image model is no chat model: its row goes to the relay's image
+    // routes, whatever the runtime is doing, and never into the runtime.
+    if (shouldUseDirectOpenAIImageApi(message)) return runDirectImageTurn(message);
     // Held (a card is open, a compaction is running, a tool of the main agent
     // is running, the turn-opening prompt is not sent yet): hand the row back
     // with no retry penalty; the relay re-delivers it when the hold ends. An
@@ -4850,7 +4865,7 @@ export function createCopilotSdkSessionRunner({
         if (outcome !== NOT_STEERED) return outcome;
       } catch (error) {
         dbg('steering failed', message.id, error?.message || String(error));
-        const classified = classifyCopilotTurnException(error);
+        const classified = classifyCopilotTurnException(error, { provider: workerProvider });
         await publishResponse(message, {
           text: classified.text,
           model: null,
@@ -4863,6 +4878,54 @@ export function createCopilotSdkSessionRunner({
     return runTurn(turn);
   }
 
+  /**
+   * 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.
+   */
+  async function runDirectImageTurn(message) {
+    const id = String(message.id || '');
+    directImageMessages.set(id, message);
+    touch();
+    try {
+      const result = await runDirectOpenAIImageTurn({
+        api,
+        message,
+        // An edit can take minutes, longer than fetch waits for headers.
+        requestOptions: { longCall: true },
+        responseFields: attemptFields(message),
+      });
+      dbg('image turn', message.id, result.via, result.outcome);
+    } catch (error) {
+      if (isOpenAIImageTerminalError(error)) {
+        dbg('image turn refused by OpenAI', message.id, 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',
+            message: error.message,
+            ...(error.detail ? { detail: String(error.detail) } : {}),
+            failedAt: new Date().toISOString(),
+            queueMessageId: id || null,
+          },
+        });
+      } else {
+        dbg('image turn failed; requeueing', message.id, error?.message || String(error));
+        await api('POST', '/api/requeue', { messageId: message.id, ...attemptFields(message) }).catch(() => {});
+      }
+    } finally {
+      directImageMessages.delete(id);
+      touch();
+    }
+    return true;
+  }
+
   // --------------------------------------------------------------- teardown --
 
   function getActiveQueueMessageId() {
@@ -4872,6 +4935,7 @@ export function createCopilotSdkSessionRunner({
       const id = String(entry.message?.id || '');
       if (id && !entry.released) return id;
     }
+    for (const id of directImageMessages.keys()) return id;
     return '';
   }
 
@@ -4911,6 +4975,7 @@ export function createCopilotSdkSessionRunner({
     for (const { message, variant } of settlingMessages.values()) {
       push(message, buildSteerSettleFailure(message, { variant, agentLabel: SETTLE_AGENT_LABEL }));
     }
+    for (const message of directImageMessages.values()) push(message);
     return entries;
   }
 
@@ -4949,8 +5014,9 @@ export function createCopilotSdkSessionRunner({
     // registry and refuses ids it does not know.
     stopBackgroundTask,
     // "Active" spans both ownerships: a settled turn still publishing must
-    // keep the worker's idle/shutdown gates closed just like a running one.
-    isTurnActive: () => !!activeTurn || publishingTurns.size > 0,
+    // keep the worker's idle/shutdown gates closed just like a running one,
+    // and so must an image row on the relay's image routes.
+    isTurnActive: () => !!activeTurn || publishingTurns.size > 0 || directImageMessages.size > 0,
     dispose,
     // The turn's tokens/cost/TTFT, as posted to `/api/copilot-plan-usage`.
     getLastTurnUsage: () => lastTurnUsage,

package/server/db-schema.mjs

@@ -24,6 +24,18 @@ import { migrateConversationGroupPosition } from './migrations/0015-conversation
 import { migrateShareAccessLog } from './migrations/0016-share-access-log.mjs';
 import { migrateConversationHistoryIndexes } from './migrations/0017-conversation-history-indexes.mjs';
 import { migrateBackgroundTaskRows } from './migrations/0018-background-task-rows.mjs';
+import { migrateRelayEventSubscriptionOptions } from './migrations/0019-relay-event-subscription-options.mjs';
+import { migrateConversationMayCreateSessions } from './migrations/0020-conversation-may-create-sessions.mjs';
+import { migrateConversationGroupAgentMarks } from './migrations/0021-conversation-group-agent-marks.mjs';
+import { migrateRelaySchedules } from './migrations/0022-relay-schedules.mjs';
+import { migrateRelayAsks } from './migrations/0023-relay-asks.mjs';
+import { migrateDeepSeekUsageTotals } from './migrations/0024-deepseek-usage-totals.mjs';
+import { migrateDeepSeekUsageRequestsDaily } from './migrations/0025-deepseek-usage-requests-daily.mjs';
+import { migrateDeepSeekUsageServedModels } from './migrations/0026-deepseek-usage-served-models.mjs';
+import { migrateDeepSeekUsageCheckpointRuns } from './migrations/0027-deepseek-usage-checkpoint-runs.mjs';
+import { migrateDeepSeekUsageCheckpointRequestRuns } from './migrations/0028-deepseek-usage-checkpoint-request-runs.mjs';
+import { migrateDeepSeekBalanceRises } from './migrations/0029-deepseek-balance-rises.mjs';
+import { migrateDeepSeekUsageActuals } from './migrations/0030-deepseek-usage-actuals.mjs';
 import { migrateImageConversationSchema } from './repositories/image-conversation-repository.mjs';
 
 // Mirrors DEFAULT_RELAY_MODE in server-runtime.mjs; used only by the one-time
@@ -855,6 +867,109 @@ try {
   console.warn(`[background-tasks] migration 0018 failed; retrying on next boot: ${error?.message || error}`);
 }
 
+// Options of relay event subscriptions (digest, quiet hours, exclude) and the
+// watcher's own prompts: columns on 0011's table and one table. The event
+// service checks for them and refuses the options without them, so a failure
+// is logged and retried next boot like 0018.
+try {
+  migrateRelayEventSubscriptionOptions(db);
+} catch (error) {
+  console.warn(`[relay-events] migration 0019 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// The owner's "agents in this conversation may start sessions": one column.
+// Without it nobody can turn the switch on (the preferences route refuses
+// it) and the one-level rule holds for every session, so a failure is logged
+// and retried next boot like 0019.
+try {
+  migrateConversationMayCreateSessions(db);
+} catch (error) {
+  console.warn(`[remote-relays] migration 0020 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// What an agent's update_session may do to a group: two columns. Without
+// them an owner's group an agent emptied is kept until the next boot repair
+// only, so a failure is logged and retried next boot like 0020.
+try {
+  migrateConversationGroupAgentMarks(db);
+} catch (error) {
+  console.warn(`[session-groups] migration 0021 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// Relay schedules: one new table. The schedule service checks for it and
+// refuses the schedule actions without it, so a failure is logged and
+// retried next boot like 0021.
+try {
+  migrateRelaySchedules(db);
+} catch (error) {
+  console.warn(`[relay-schedules] migration 0022 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// Questions that don't block (remote_relay ask): one new table. The ask
+// service checks for it and refuses the ask actions without it, so a failure
+// is logged and retried next boot like 0022.
+try {
+  migrateRelayAsks(db);
+} catch (error) {
+  console.warn(`[relay-asks] migration 0023 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// DeepSeek usage totals: one new table. The plan usage service creates it
+// itself as well, so a failure here is logged and retried next boot like 0023.
+try {
+  migrateDeepSeekUsageTotals(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0024 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// DeepSeek search/fetch counts, daily spend and balance reference: four
+// columns on 0024's table and two tables, handled like 0024.
+try {
+  migrateDeepSeekUsageRequestsDaily(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0025 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// DeepSeek usage booked under a Claude model name is folded into the DeepSeek
+// model that served it, handled like 0024.
+try {
+  migrateDeepSeekUsageServedModels(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0026 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// The DeepSeek usage checkpoint learns the worker process's run id and its
+// search and fetch counts: three columns on 0024's table, handled like 0024.
+try {
+  migrateDeepSeekUsageCheckpointRuns(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0027 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// The checkpoint's search and fetch counts get a run id of their own: one
+// column on 0024's table, handled like 0024.
+try {
+  migrateDeepSeekUsageCheckpointRequestRuns(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0028 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// The balance reference notes when the balance last rose: one column on
+// 0025's table, handled like 0025.
+try {
+  migrateDeepSeekBalanceRises(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0029 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// The imported figures of DeepSeek's usage export: a table of its own, handled
+// like 0024.
+try {
+  migrateDeepSeekUsageActuals(db);
+} catch (error) {
+  console.warn(`[deepseek-usage] migration 0030 failed; retrying on next boot: ${error?.message || error}`);
+}
+
 const runtimeSessionColumns = db.prepare(`PRAGMA table_info(runtime_sessions)`).all().map((c) => c.name);
 if (runtimeSessionColumns.length) {
   if (!runtimeSessionColumns.includes('strategy')) {