mixdog 0.9.174 → 1.0.0

package/src/runtime/channels/lib/worker-main.mjs

@@ -1,15 +1,14 @@
 import * as fs from 'node:fs';
-import * as os from 'node:os';
 import * as path from 'node:path';
 import { createRequire } from 'node:module';
-const _require = createRequire(import.meta.url);
 import { loadConfig, createProvider, DATA_DIR } from './config.mjs';
 import { resolveVoiceRuntime } from './voice-runtime-fetcher.mjs';
+import { whisperThreadCount } from './voice-transcription.mjs';
+import { TOOL_DEFS } from '../tool-defs.mjs';
 import { ensureReady, stopVoiceWhisperServer } from './whisper-server.mjs';
 import { ensurePrivateRuntimeRoot, resolveRuntimeRoot } from '../../shared/runtime-root.mjs';
 import { Scheduler } from './scheduler.mjs';
 import { hasPending as dispatchHasPending } from '../../agent/orchestrator/dispatch-persist.mjs';
-import { setListener as setActivityBusListener } from '../../agent/orchestrator/activity-bus.mjs';
 import { stripSoftWarns } from '../../agent/orchestrator/tool-loop-guard.mjs';
 import { JsonStateFile } from './state-file.mjs';
 import {
@@ -34,6 +33,7 @@ import { createOwnerHeartbeat } from './owner-heartbeat.mjs';
 import { runWorkerIpc } from './worker-ipc.mjs';
 import { createOwnedRuntime } from './owned-runtime.mjs';
 import { runWorkerBootstrap } from './worker-bootstrap.mjs';
+const _require = createRequire(import.meta.url);
 // Zombie-Lead repro (2026-07-02): logCrash-then-survive left a worker alive
 // after an unhandled rejection whose async state was already corrupted
 // (observed: EPERM on active-instance.json rename retry), so it spun
@@ -135,6 +135,12 @@ const scheduler = new Scheduler(
   // Single resolved main-channel id used for the schedule `channel` flag.
   config.channelId
 );
+// Schedules fire as visible sessions; the session runner belongs to the
+// session-runtime layer, so this worker entry injects it (lazy, like webhooks).
+scheduler.setScheduleRunner(async (schedule, opts) => {
+  const { runScheduleSession } = await import('../../../session-runtime/schedule-session-run.mjs');
+  return runScheduleSession(schedule, opts);
+});
 // Register the pending-dispatch probe so the scheduler treats an in-flight
 // bridge dispatch as "active" regardless of user-inbound silence.
 scheduler.setPendingCheck(() => {
@@ -144,10 +150,6 @@ scheduler.setPendingCheck(() => {
     return false;
   }
 });
-// Bridge the orchestrator-side activity notifier into the scheduler so
-// events like `addPending` can bump lastActivity without importing the
-// scheduler instance directly (avoids module cycles).
-setActivityBusListener(() => scheduler.noteActivity());
 let webhookServer = null;
 let eventPipeline = null;
 let bridgeRuntimeConnected = false;
@@ -155,45 +157,39 @@ let bridgeRuntimeConnected = false;
 const { logOwnership, currentOwnerState } = createOwnerHeartbeat();
 // ── Owned-runtime lifecycle ─────────────────────────────────────────────────
 // Live getters/setters keep shared worker state visible across lifecycle phases.
-const {
-  startAutomationRuntime,
-  startOwnedRuntime,
-  stopOwnedRuntime,
-  refreshBridgeOwnership,
-  reloadRuntimeConfig,
-  notifyRemoteAcquired,
-} = createOwnedRuntime({
-  getConfig: () => config,
-  setConfig: (v) => {
-    config = v;
-  },
-  getProvider: () => provider,
-  setProvider: (v) => {
-    provider = v;
-  },
-  getBridgeRuntimeConnected: () => bridgeRuntimeConnected,
-  setBridgeRuntimeConnected: (v) => {
-    bridgeRuntimeConnected = v;
-  },
-  getWebhookServer: () => webhookServer,
-  setWebhookServer: (v) => {
-    webhookServer = v;
-  },
-  getEventPipeline: () => eventPipeline,
-  setEventPipeline: (v) => {
-    eventPipeline = v;
-  },
-  getChannelBridgeActive: () => channelBridgeActive,
-  instanceId: INSTANCE_ID,
-  TERMINAL_LEAD_PID,
-  sendNotifyToParent,
-  scheduler,
-  statusState,
-  logOwnership,
-  currentOwnerState,
-  wireWebhookHandlers,
-  wireEventQueueHandlers,
-});
+const { startAutomationRuntime, startOwnedRuntime, stopOwnedRuntime, reloadRuntimeConfig, notifyRemoteAcquired } =
+  createOwnedRuntime({
+    getConfig: () => config,
+    setConfig: (v) => {
+      config = v;
+    },
+    getProvider: () => provider,
+    setProvider: (v) => {
+      provider = v;
+    },
+    getBridgeRuntimeConnected: () => bridgeRuntimeConnected,
+    setBridgeRuntimeConnected: (v) => {
+      bridgeRuntimeConnected = v;
+    },
+    getWebhookServer: () => webhookServer,
+    setWebhookServer: (v) => {
+      webhookServer = v;
+    },
+    getEventPipeline: () => eventPipeline,
+    setEventPipeline: (v) => {
+      eventPipeline = v;
+    },
+    getChannelBridgeActive: () => channelBridgeActive,
+    instanceId: INSTANCE_ID,
+    TERMINAL_LEAD_PID,
+    sendNotifyToParent,
+    scheduler,
+    statusState,
+    logOwnership,
+    currentOwnerState,
+    wireWebhookHandlers,
+    wireEventQueueHandlers,
+  });
 function injectAndRecord(channelId, _name, content, options) {
   // Strip soft-warn marker blocks (Tool-loop / Repeated-input / legacy
   // Repeated-tool / Mixed-tool / Tool-budget / Same-file multi-chunk /
@@ -234,7 +230,7 @@ function wireWebhookHandlers() {
   // Webhook fires run as sessions (schedules parity); the Automations
   // session row is the only surface (channel relay retired).
   webhookServer.setBridgeDispatch(async ({ prompt, model, cwd, workflow, attachments, delivery, context, signal }) => {
-    const { runWebhookSession } = await import('../../shared/webhook-session-run.mjs');
+    const { runWebhookSession } = await import('../../../session-runtime/webhook-session-run.mjs');
     const run = await runWebhookSession({
       name: context?.endpoint || 'webhook',
       model: model || null,
@@ -264,7 +260,6 @@ function wireEventQueueHandlers(eventQueue) {
 // Inbound messaging, provider interaction handlers, and channel voice-message
 // transcription are DELETED with Discord/Telegram (user decision: PWA replaces
 // channels). The headless provider emits no events, so nothing wires here.
-import { TOOL_DEFS } from '../tool-defs.mjs';
 // Tool dispatch in worker mode goes through the IPC `call` handler at the
 // bottom of this file (parent's `callWorker` → `handleToolCall`). There is no
 // orphan worker-level MCP Server: the parent (server.mjs) owns the single
@@ -284,7 +279,6 @@ const { handleToolCall, handleToolCallWithBridgeRetry } = createToolDispatch({
     },
     writeBridgeState,
     notifyRemoteAcquired,
-    refreshBridgeOwnership,
     startChannelBridge: () => start({ messaging: true }),
     stopOwnedRuntime,
     reloadRuntimeConfig,
@@ -341,15 +335,12 @@ async function start(options = {}) {
       if (config.voice?.enabled === false) return;
       const runtime = resolveVoiceRuntime(DATA_DIR);
       if (!runtime?.installed) return;
-      const _cpuCount = (() => {
-        try {
-          return os.cpus().length;
-        } catch {
-          return 2;
-        }
-      })();
-      const threadCount = config.voice?.transcription?.threadCount ?? Math.max(1, Math.ceil(_cpuCount / 4));
-      await ensureReady({ serverCmd: runtime.serverCmd, modelPath: runtime.modelPath, threadCount, host: '127.0.0.1' });
+      await ensureReady({
+        serverCmd: runtime.serverCmd,
+        modelPath: runtime.modelPath,
+        threadCount: whisperThreadCount(config),
+        host: '127.0.0.1',
+      });
     } catch (err) {
       try {
         process.stderr.write(`mixdog: voice.transcription pre-warm skipped: ${err}\n`);

package/src/runtime/computer-bridge/client.mjs

@@ -122,7 +122,8 @@ function extraFieldTexts(rest) {
 
 function elementLine(element) {
   if (!element || typeof element !== 'object') return element;
-  const { mark, ref, role, name, value, state, source, enabled, has_keyboard_focus, bounds, actions, ...rest } = element;
+  const { mark, ref, role, name, value, state, source, enabled, has_keyboard_focus, bounds, actions, ...rest } =
+    element;
   return [
     isUnsetField(mark) ? null : `#${mark}`,
     isUnsetField(ref) ? null : `[${ref}]`,
@@ -229,11 +230,7 @@ function canonicalComputerResultIsError(text, args) {
 
 /** Sync gate for the session tool surface (featureDisallowedTools). */
 export function computerBridgeAvailableSync() {
-  return readDiscovery() !== null;
-}
-
-function readDiscovery() {
-  return readBridgeDiscovery(DISCOVERY_FILE);
+  return readBridgeDiscovery(DISCOVERY_FILE) !== null;
 }
 
 function computerCommandHeaders(bridge) {
@@ -342,7 +339,7 @@ async function postWithBridgeRecovery(discovery, command, encoded, sessionId, co
     try {
       const response = await postComputerCommand(bridge, encoded, { signal: context?.signal });
       if (response.status === 401 && attempt === 0 && isReplaySafeComputerCommand(command)) {
-        const replacement = readDiscovery();
+        const replacement = readBridgeDiscovery(DISCOVERY_FILE);
         if (bridgeDiscoveryChanged(bridge, replacement)) {
           await response.body?.cancel().catch(() => undefined);
           bridge = replacement;
@@ -355,7 +352,7 @@ async function postWithBridgeRecovery(discovery, command, encoded, sessionId, co
       const timedOut = error?.name === 'TimeoutError';
       const mutationMayHaveExecuted = computerMutationMayHaveExecuted(command);
       if (attempt === 0 && !externallyAborted && !timedOut) {
-        const replacement = readDiscovery();
+        const replacement = readBridgeDiscovery(DISCOVERY_FILE);
         if (bridgeDiscoveryChanged(bridge, replacement)) {
           if (isReplaySafeComputerCommand(command)) {
             bridge = replacement;
@@ -421,7 +418,7 @@ function computerToolResult(value, args) {
 /** Execute one `computer` tool call. Returns MCP-shaped content so the
  *  internal-tools normalizer forwards text and screenshot images as-is. */
 export async function executeComputerTool(rawArgs, context = {}) {
-  const discovery = readDiscovery();
+  const discovery = readBridgeDiscovery(DISCOVERY_FILE);
   if (!discovery) return computerErrorResult(`Error: ${BRIDGE_UNAVAILABLE_MESSAGE}`);
   // Resolve the argument shape once so validation, host translation, and the
   // canonical result text all read the same input.
@@ -513,7 +510,7 @@ async function settlePendingComputerWork(value, command, bridge, sessionId, cont
 }
 
 async function sendComputerSessionControl(sessionId, action, timeoutMs) {
-  const discovery = readDiscovery();
+  const discovery = readBridgeDiscovery(DISCOVERY_FILE);
   if (!discovery) return false;
   try {
     const response = await postComputerCommand(

package/src/runtime/computer-bridge/core-actions.mjs

@@ -276,7 +276,7 @@ function actionArgumentsError(action, type, label, frameId) {
     if (hasOwn(action, 'ref') && hasOwn(action, 'element')) return `${label} accepts only one of ref or element`;
     return typeof action.value === 'string' ? null : `${label} requires value`;
   }
-  if (type === 'key') return typeof action.keys === 'string' ? null : `${label} requires keys`;
+  if (type === 'key' || type === 'key_down' || type === 'key_up') return typeof action.keys === 'string' ? null : `${label} requires keys`;
   if (type === 'wait') {
     const { duration } = action;
     const valid = typeof duration === 'number' && Number.isFinite(duration) && duration >= 0 && duration <= 5;

package/src/runtime/computer-bridge/limits.d.mts

@@ -1,7 +1,6 @@
 export const MAX_COMPUTER_REQUEST_BYTES: number;
 export const MAX_COMPUTER_INTERNAL_REQUEST_BYTES: number;
 export const MAX_COMPUTER_RESPONSE_BYTES: number;
-export const MAX_COMPUTER_TEXT_CHARS: number;
 export const MAX_COMPUTER_IMAGE_CHARS: number;
 export const MAX_COMPUTER_FOREGROUND_TEXT_CHARS: number;
 export function validateComputerReply(value: unknown): void;

package/src/runtime/github/client.mjs

@@ -4,7 +4,13 @@ import { lstat, mkdir, realpath } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, parse, resolve } from 'node:path';
 import { buildGithubCommand } from './commands.mjs';
-import { githubRepository, githubRequestMutates, isRepoFreeGithubAction, validateGithubRequest } from './contract.mjs';
+import {
+  DEFAULT_GITHUB_HOSTNAME,
+  githubRepository,
+  githubRequestMutates,
+  isRepoFreeGithubAction,
+  validateGithubRequest,
+} from './contract.mjs';
 import { withGitRepoWriteLock } from '../agent/orchestrator/tools/builtin/git-repo-rw-lock.mjs';
 
 const MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
@@ -99,12 +105,13 @@ export async function executeGithubRequest(value, cwd, options = {}) {
   if (['repo.create', 'repo.clone', 'repo.fork'].includes(input.action) && !input.repo) {
     throw new TypeError('This action requires an explicit owner/name in repo.');
   }
+  const hostname = input.hostname || DEFAULT_GITHUB_HOSTNAME;
   if (!isRepoFreeGithubAction(input.action) && !input.repo) {
     // Bind every request to a concrete repository before any write is sent.
     const raw = await run(
       {
         args: ['repo', 'view', '--json', 'nameWithOwner'],
-        hostname: input.hostname || 'github.com',
+        hostname,
         json: true,
         mutation: false,
       },
@@ -130,7 +137,7 @@ export async function executeGithubRequest(value, cwd, options = {}) {
     if (input.action === 'pr.merge' && data?.merged === false) {
       throw new Error(data.message || 'GitHub refused to merge this pull request.');
     }
-    const result = { action: input.action, repo: input.repo || '', hostname: input.hostname || 'github.com', data };
+    const result = { action: input.action, repo: input.repo || '', hostname, data };
     if (command.list) {
       const items = command.collection ? data?.[command.collection] : data;
       if (!Array.isArray(items)) throw new Error('GitHub returned an invalid list.');
@@ -155,7 +162,5 @@ export async function executeGithubRequest(value, cwd, options = {}) {
             { signal: options.signal }
           )
       : invoke;
-  return githubRequestMutates(input)
-    ? serial(`${input.hostname || 'github.com'}/${input.repo || '@account'}`.toLowerCase(), work)
-    : invoke();
+  return githubRequestMutates(input) ? serial(`${hostname}/${input.repo || '@account'}`.toLowerCase(), work) : invoke();
 }

package/src/runtime/github/commands.mjs

@@ -1,4 +1,5 @@
 import {
+  DEFAULT_GITHUB_HOSTNAME,
   GITHUB_ACTIONS,
   githubNumber,
   githubRepository,
@@ -19,6 +20,7 @@ export function buildGithubCommand(value) {
   const page = input.page ?? 1;
   const limit = input.limit ?? 30;
   const query = `per_page=${limit}&page=${page}`;
+  const hostname = input.hostname || DEFAULT_GITHUB_HOSTNAME;
   const number = () => githubNumber(input.number);
   const id = () => githubNumber(input.id, 'id');
   const text = (key) => githubText(input[key], key, key === 'body' ? 60000 : 1000);
@@ -27,7 +29,7 @@ export function buildGithubCommand(value) {
       'api',
       endpoint,
       '--hostname',
-      input.hostname || 'github.com',
+      hostname,
       '--method',
       method,
       ...(body === undefined ? [] : ['--input', '-']),
@@ -44,7 +46,7 @@ export function buildGithubCommand(value) {
     args,
     json,
     mutation: definition.write === true,
-    hostname: input.hostname || 'github.com',
+    hostname,
   });
   switch (action) {
     case 'repo.list':

package/src/runtime/github/contract.mjs

@@ -1,4 +1,6 @@
 // One allowlist for the desktop, agent schema, and mutation classifier.
+export const DEFAULT_GITHUB_HOSTNAME = 'github.com';
+
 export const GITHUB_ACTIONS = Object.freeze({
   'repo.list': { fields: ['owner', 'page', 'limit'], list: true },
   'repo.view': { fields: [] },
@@ -171,7 +173,7 @@ export function validateGithubRequest(input) {
   for (const key of ['base', 'head', 'ref', 'tag', 'target', 'workflow']) {
     if (out[key] !== undefined) {
       githubText(out[key], key, 512);
-      if (/^[-]|[\r\n]/.test(out[key])) throw new TypeError(`Invalid ${key}.`);
+      if (/^-|[\r\n]/.test(out[key])) throw new TypeError(`Invalid ${key}.`);
     }
   }
   if (out.inputs !== undefined) {

package/src/runtime/local-provider/hugging-face.mjs

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { resolvePluginData } from '../shared/plugin-paths.mjs';
-import { huggingFaceFileUrl, registerLocalModel } from './registered-models.mjs';
+import { HUGGING_FACE_REPOSITORY_ID, huggingFaceFileUrl, registerLocalModel } from './registered-models.mjs';
 import { parseGgufHeader, ggufMemoryPlan } from './gguf-header.mjs';
 
 const ORIGIN = 'https://huggingface.co';
@@ -59,7 +59,7 @@ export function createHuggingFaceCatalog({ fetchFn = fetch, dataDir = resolvePlu
   function repositoryId(value) {
     if (
       typeof value !== 'string' ||
-      !/^[\w.-]+\/[\w.-]+$/.test(value) ||
+      !HUGGING_FACE_REPOSITORY_ID.test(value) ||
       value.split('/').some((p) => p === '.' || p === '..')
     )
       throw new TypeError('repository must be an owner/name Hugging Face model id.');
@@ -85,7 +85,7 @@ export function createHuggingFaceCatalog({ fetchFn = fetch, dataDir = resolvePlu
       return {
         models: rows
           .slice(0, 20)
-          .filter((row) => /^[\w.-]+\/[\w.-]+$/.test(row.id || ''))
+          .filter((row) => HUGGING_FACE_REPOSITORY_ID.test(row.id || ''))
           .map((row) => ({
             repository: row.id,
             downloads: Number(row.downloads) || 0,

package/src/runtime/local-provider/registered-models.mjs

@@ -7,6 +7,8 @@ const MAX_REGISTRY_BYTES = 1024 * 1024;
 const cache = new Map();
 const registryPath = (dataDir) => join(dataDir, 'local-provider', 'registered-models.json');
 
+export const HUGGING_FACE_REPOSITORY_ID = /^[\w.-]+\/[\w.-]+$/;
+
 /** Pinned Hugging Face download URL for one repository file at an exact revision. */
 export function huggingFaceFileUrl(repository, revision, remoteFilename) {
   return `https://huggingface.co/${repository}/resolve/${revision}/${remoteFilename.split('/').map(encodeURIComponent).join('/')}`;
@@ -27,7 +29,7 @@ function validateModel(entry) {
     entry.estimatedVramBytes < entry.size ||
     entry.minimumVramBytes !== entry.estimatedVramBytes ||
     !/^[a-f0-9]{40}$/.test(entry.revision || '') ||
-    !/^[\w.-]+\/[\w.-]+$/.test(entry.repository || '') ||
+    !HUGGING_FACE_REPOSITORY_ID.test(entry.repository || '') ||
     typeof entry.remoteFilename !== 'string' ||
     entry.remoteFilename.split('/').some((part) => !part || part === '.' || part === '..') ||
     // biome-ignore lint/suspicious/noControlCharactersInRegex: rejects control characters in an untrusted remote file name

package/src/runtime/local-provider/request-queue.mjs

@@ -1,4 +1,5 @@
 import { DEFAULT_ACTIVITY_HEARTBEAT_MS } from '../agent/orchestrator/stall-policy.mjs';
+import { createSerialChain } from './serial-chain.mjs';
 
 export const DEFAULT_LOCAL_IDLE_TTL_SECONDS = 3600;
 
@@ -19,7 +20,7 @@ export function createLocalRequestQueue({
   clearTimer = clearTimeout,
   now = Date.now,
 } = {}) {
-  let chain = Promise.resolve();
+  const serial = createSerialChain();
   let timer = null;
   let idleDeadline = null;
   let active = 0;
@@ -32,14 +33,6 @@ export function createLocalRequestQueue({
     timer = null;
     idleDeadline = null;
   }
-  function serialize(operation) {
-    const next = chain.then(operation, operation);
-    chain = next.then(
-      () => {},
-      () => {}
-    );
-    return next;
-  }
   function scheduleIdle() {
     clearIdle();
     if (requests.size || stopping || !ttl) return;
@@ -48,7 +41,7 @@ export function createLocalRequestQueue({
       timer = null;
       idleDeadline = null;
       if (requests.size) return;
-      void serialize(unload).then(
+      void serial.enqueue(unload).then(
         () => {
           lastUnloadError = null;
         },
@@ -92,25 +85,27 @@ export function createLocalRequestQueue({
         }
       };
       combined.addEventListener('abort', onAbort, { once: true });
-      const pending = serialize(async () => {
-        if (heartbeat) clearInterval(heartbeat);
-        combined.throwIfAborted();
-        request.started = true;
-        active++;
-        try {
+      const pending = serial
+        .enqueue(async () => {
+          if (heartbeat) clearInterval(heartbeat);
+          combined.throwIfAborted();
+          request.started = true;
+          active++;
           try {
-            onStageChange?.('requesting');
-          } catch {}
-          return await operation(combined);
-        } finally {
-          active--;
-        }
-      }).finally(() => {
-        combined.removeEventListener('abort', onAbort);
-        if (heartbeat) clearInterval(heartbeat);
-        requests.delete(request);
-        scheduleIdle();
-      });
+            try {
+              onStageChange?.('requesting');
+            } catch {}
+            return await operation(combined);
+          } finally {
+            active--;
+          }
+        })
+        .finally(() => {
+          combined.removeEventListener('abort', onAbort);
+          if (heartbeat) clearInterval(heartbeat);
+          requests.delete(request);
+          scheduleIdle();
+        });
       return Promise.race([pending, early]);
     },
     stop() {
@@ -120,7 +115,7 @@ export function createLocalRequestQueue({
       // Interrupt loading/inference now; do not wait behind the work being stopped.
       stopping = (async () => {
         await unload();
-        await chain;
+        await serial.idle();
         clearIdle();
       })().finally(() => {
         stopping = null;

package/src/runtime/local-provider/serial-chain.mjs

@@ -0,0 +1,19 @@
+/**
+ * Run operations one after another, whatever the outcome of the previous one.
+ * `enqueue` resolves with its own operation's result; `idle` resolves (never
+ * rejects) once everything enqueued so far has settled.
+ */
+export function createSerialChain() {
+  let chain = Promise.resolve();
+  return {
+    enqueue(operation) {
+      const next = chain.then(operation, operation);
+      chain = next.then(
+        () => {},
+        () => {}
+      );
+      return next;
+    },
+    idle: () => chain,
+  };
+}

package/src/runtime/local-provider/server-process.mjs

@@ -3,6 +3,7 @@ import { createServer } from 'node:net';
 import { setTimeout as delay } from 'node:timers/promises';
 import { redactedLog, spawnServerState } from './server-process/child-state.mjs';
 import { awaitServerReady } from './server-process/readiness.mjs';
+import { createSerialChain } from './serial-chain.mjs';
 
 async function freeLoopbackPort() {
   return new Promise((resolve, reject) => {
@@ -39,18 +40,9 @@ export function createLocalServerProcess({
 } = {}) {
   // The owner record: which child is current and what the last one reported.
   const owner = { current: null, lastExit: null, lastError: null };
-  let chain = Promise.resolve();
+  const { enqueue: serialize } = createSerialChain();
   const pendingStarts = new Set();
 
-  function serialize(operation) {
-    const next = chain.then(operation, operation);
-    chain = next.then(
-      () => {},
-      () => {}
-    );
-    return next;
-  }
-
   async function stopState(state) {
     if (!state || state.exited) return;
     state.expectedExit = true;

package/src/runtime/media/adapters/antigravity-image.mjs

@@ -9,6 +9,7 @@
  */
 import { randomUUID } from 'node:crypto';
 import { resolveAntigravityAuth } from '../auth.mjs';
+import { timeoutSignal } from '../bounded-signal.mjs';
 import { upstreamError } from '../upstream-error.mjs';
 import { geminiImageRequestBody, pickGeminiImagePart } from './gemini-image.mjs';
 import { CONTENT_ENDPOINTS, antigravityHeaders } from '../../agent/orchestrator/providers/antigravity-oauth-tokens.mjs';
@@ -54,7 +55,6 @@ export async function generateImage(
 ) {
   const auth = await resolveAuth();
   const body = antigravityImageRequestBody({ projectId: auth.projectId, model, prompt, options, references });
-  const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
   const res = await fetchFn(`${endpoint}/v1internal:streamGenerateContent?alt=sse`, {
     method: 'POST',
     headers: {
@@ -65,7 +65,7 @@ export async function generateImage(
     },
     body: JSON.stringify(body),
     redirect: 'error',
-    signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+    signal: timeoutSignal(signal, REQUEST_TIMEOUT_MS),
   });
   if (!res.ok) throw upstreamError('Antigravity image', res.status, await res.text().catch(() => ''));
   const { parts, failure } = antigravityImageParts(await res.text());

package/src/runtime/media/adapters/codex-image.mjs

@@ -8,6 +8,7 @@
  */
 import { randomBytes } from 'node:crypto';
 import { resolveCodexAuth } from '../auth.mjs';
+import { timeoutSignal } from '../bounded-signal.mjs';
 import { decodeBase64Media } from '../download.mjs';
 import { mediaError } from '../lanes.mjs';
 import { upstreamError } from '../upstream-error.mjs';
@@ -96,13 +97,12 @@ export async function generateImage(
   // a newly discovered model can still be rejected by the Codex version gate.
   await warmVersion();
   const body = codexImageRequestBody({ model, prompt, options, references });
-  const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
   const res = await fetchFn(CODEX_RESPONSES_URL, {
     method: 'POST',
     headers: codexImageRequestHeaders(auth),
     body: JSON.stringify(body),
     redirect: 'error',
-    signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+    signal: timeoutSignal(signal, REQUEST_TIMEOUT_MS),
   });
   if (!res.ok || !res.body) throw upstreamError('ChatGPT image', res.status, await res.text().catch(() => ''));
 

package/src/runtime/media/adapters/gemini-image.mjs

@@ -7,6 +7,7 @@
  * requested output setting or retry a paid request.
  */
 import { resolveGeminiKey } from '../auth.mjs';
+import { timeoutSignal } from '../bounded-signal.mjs';
 import { decodeBase64Media } from '../download.mjs';
 import { mediaError } from '../lanes.mjs';
 import { upstreamError } from '../upstream-error.mjs';
@@ -42,7 +43,7 @@ async function post(model, key, body, signal, fetchFn) {
     headers: { 'Content-Type': 'application/json', 'x-goog-api-key': key },
     body: JSON.stringify(body),
     redirect: 'error',
-    signal: AbortSignal.any([signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)].filter(Boolean)),
+    signal: timeoutSignal(signal, REQUEST_TIMEOUT_MS),
   });
 }
 

package/src/runtime/media/adapters/gemini-video.mjs

@@ -8,6 +8,7 @@
  *     the sample URI with `alt=media`.
  */
 import { resolveGeminiKey } from '../auth.mjs';
+import { boundedSignal } from '../bounded-signal.mjs';
 import { decodeBase64Media, downloadGeminiMedia } from '../download.mjs';
 import { mediaError } from '../lanes.mjs';
 import { upstreamError } from '../upstream-error.mjs';
@@ -20,11 +21,6 @@ const TOTAL_TIMEOUT_MS = 900_000;
 // the 15-minute budget from ever starting (or ever ending).
 const REQUEST_TIMEOUT_MS = 60_000;
 
-function boundedSignal(signal, deadline, capMs = REQUEST_TIMEOUT_MS) {
-  const remaining = Math.max(1, deadline - Date.now());
-  return AbortSignal.any([signal, AbortSignal.timeout(Math.min(capMs, remaining))].filter(Boolean));
-}
-
 function isOmniModel(model) {
   return /omni/i.test(String(model || ''));
 }
@@ -90,7 +86,7 @@ async function generateViaVeo({ model, prompt, options, references = [], signal,
     method: 'POST',
     headers,
     body: JSON.stringify({ instances: [instance], parameters }),
-    signal: boundedSignal(signal, deadline),
+    signal: boundedSignal(signal, deadline, REQUEST_TIMEOUT_MS),
   });
   if (!started.ok) throw upstreamError('Veo video', started.status, await started.text().catch(() => ''));
   const operation = await started.json();
@@ -102,7 +98,7 @@ async function generateViaVeo({ model, prompt, options, references = [], signal,
     await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
     const poll = await fetch(`${BASE_URL}/${operation.name}`, {
       headers,
-      signal: boundedSignal(signal, deadline),
+      signal: boundedSignal(signal, deadline, REQUEST_TIMEOUT_MS),
     });
     if (!poll.ok) throw upstreamError('Veo poll', poll.status, await poll.text().catch(() => ''));
     const data = await poll.json();