@livedesk/hub 0.1.19 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/hub",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "LiveDesk local Hub API and browser frame bridge",
   "type": "module",
   "main": "src/server.js",

package/src/agents/agent-manager.js

@@ -1,7 +1,7 @@
 import os from 'node:os';
 import path from 'node:path';
-import { AgentSettingsStore, AGENT_PROVIDER_CODEX } from './agent-settings.js';
-import { AgentProviderError } from './provider-errors.js';
+import { AgentSettingsStore } from './agent-settings.js';
+import { AgentRuntimeError } from './agent-runtime-error.js';
 
 function publicCodexStatus(status = {}) {
   return {
@@ -42,69 +42,22 @@ export function createAgentManager({
 
   async function publicSettings() {
     const current = await settings.get();
-    const {
-      codexMaxTurns: _codexMaxTurns,
-      provider: _provider,
-      ...exposedSettings
-    } = current;
     const codex = await getCodexStatus();
-    const securityStatus = runtime?.getSecurityStatus?.() || {
-      isolatedCodexHome: false,
-      restrictedEnvironment: false,
-      livedeskMcpOnly: false,
-      selectedDeviceScopeEnforced: false,
-      failClosed: true,
-      verified: false,
-      state: 'unavailable'
-    };
     return {
-      ...exposedSettings,
+      enabled: current.enabled === true,
       codexInstallation: codex.installed ? 'installed' : 'not-installed',
       codexAuth: codex.authenticated,
-      codexStatus: codex.status,
-      codexPath: codex.codexPath,
-      agentWorkspacePath: current.codexWorkingDirectory,
-      securityStatus
+      codexStatus: codex.status
     };
   }
 
   return {
     getSettings: publicSettings,
-    async updateSettings(patch = {}) {
-      const nextPatch = { ...patch };
-      const requestedProvider = String(nextPatch.provider || AGENT_PROVIDER_CODEX).trim().toLowerCase();
-      const suppliedLegacyKey = typeof nextPatch.apiKey === 'string' && nextPatch.apiKey.trim().length > 0;
-      delete nextPatch.provider;
-      delete nextPatch.apiKey;
-      if (requestedProvider !== AGENT_PROVIDER_CODEX || suppliedLegacyKey) {
-        throw new AgentProviderError(
-          'agent-provider-retired',
-          'LiveDesk uses the Hub-hosted Codex Agent and does not configure alternate model providers.',
-          { status: 400 }
-        );
-      }
-      await settings.update({ ...nextPatch, provider: AGENT_PROVIDER_CODEX });
-      statusCache = { expiresAt: 0, value: null };
-      return publicSettings();
-    },
-    async resetSettings() {
-      await settings.reset();
-      statusCache = { expiresAt: 0, value: null };
-      return publicSettings();
-    },
-    // Kept as a harmless compatibility endpoint for an older cached web UI.
-    // No credential is read, written, or returned by the current Hub.
-    async deleteApiKey() {
-      return publicSettings();
-    },
     async testConnection() {
-      if (!runtime) throw new AgentProviderError('codex-sdk-not-installed', 'Codex SDK is not installed.', { status: 503 });
+      if (!runtime) throw new AgentRuntimeError('codex-sdk-not-installed', 'Codex SDK is not installed.', { status: 503 });
       statusCache = { expiresAt: 0, value: null };
       return runtime.testConnection();
     },
-    async createPlan() {
-      throw new AgentProviderError('agent-codex-run-required', 'Codex Agent requests use the LiveDesk tool loop.', { status: 409 });
-    },
     async createSummary(input) {
       const source = input && typeof input === 'object' ? input : {};
       const results = Array.isArray(source.results) ? source.results : [];
@@ -113,9 +66,8 @@ export function createAgentManager({
       };
     },
     async startRun(input) {
-      const current = await settings.get();
-      if (current.provider !== AGENT_PROVIDER_CODEX || !runtime) {
-        throw new AgentProviderError('agent-codex-not-active', 'Codex SDK is not the active Agent runtime.', { status: 409 });
+      if (!runtime) {
+        throw new AgentRuntimeError('agent-codex-not-active', 'Codex SDK is not available for LiveDesk Agent commands.', { status: 409 });
       }
       return runtime.start(input);
     },

package/src/agents/agent-runtime-error.js

@@ -0,0 +1,9 @@
+export class AgentRuntimeError extends Error {
+  constructor(code, message, { status = 502, retryable = false } = {}) {
+    super(message);
+    this.name = 'AgentRuntimeError';
+    this.code = code;
+    this.status = status;
+    this.retryable = retryable;
+  }
+}

package/src/agents/agent-settings.js

@@ -2,23 +2,13 @@ import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
-export const AGENT_PROVIDER_CODEX = 'codex';
-export const DEFAULT_AGENT_PROVIDER = AGENT_PROVIDER_CODEX;
-export const DEFAULT_AGENT_WORKSPACE = path.join(os.homedir(), '.livedesk', 'agent-workspace');
 export const DEFAULT_AGENT_SETTINGS = Object.freeze({
-  settingsVersion: 4,
+  settingsVersion: 5,
   enabled: true,
-  provider: DEFAULT_AGENT_PROVIDER,
-  codexSandboxMode: 'read-only',
-  codexApprovalPolicy: 'never',
-  codexWorkingDirectory: DEFAULT_AGENT_WORKSPACE,
   codexTaskTimeoutMs: 600000,
   codexMaxTurns: 12,
   codexMaxToolCalls: 20,
   codexResumeSessions: true,
-  codexShowDetailedEvents: true,
-  codexNetworkAccessEnabled: false,
-  codexWebSearchMode: 'disabled',
   maxConcurrentRequests: 2
 });
 
@@ -33,32 +23,15 @@ function numberValue(value, min, max, fallback, integer = false) {
   return integer ? Math.round(clamped) : clamped;
 }
 
-function normalizeWorkingDirectory() {
-  // The agent runtime owns this directory. Do not allow a browser/API caller
-  // to move Codex into a user project or an arbitrary filesystem root.
-  return DEFAULT_AGENT_WORKSPACE;
-}
-
 export function normalizeAgentSettings(value = {}) {
   const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
   return {
-    settingsVersion: 4,
+    settingsVersion: 5,
     enabled: booleanValue(source.enabled, DEFAULT_AGENT_SETTINGS.enabled),
-    // LiveDesk has one Agent runtime. Old provider values are deliberately
-    // normalized to Codex so an upgrade cannot reactivate a retired provider.
-    provider: AGENT_PROVIDER_CODEX,
-    // These are safety settings, not user-controlled execution toggles. They
-    // are accepted for compatibility but always normalized to the safe floor.
-    codexSandboxMode: 'read-only',
-    codexApprovalPolicy: 'never',
-    codexWorkingDirectory: normalizeWorkingDirectory(),
     codexTaskTimeoutMs: numberValue(source.codexTaskTimeoutMs, 30000, 1800000, DEFAULT_AGENT_SETTINGS.codexTaskTimeoutMs, true),
     codexMaxTurns: numberValue(source.codexMaxTurns, 1, 40, DEFAULT_AGENT_SETTINGS.codexMaxTurns, true),
     codexMaxToolCalls: numberValue(source.codexMaxToolCalls, 1, 100, DEFAULT_AGENT_SETTINGS.codexMaxToolCalls, true),
     codexResumeSessions: booleanValue(source.codexResumeSessions, DEFAULT_AGENT_SETTINGS.codexResumeSessions),
-    codexShowDetailedEvents: booleanValue(source.codexShowDetailedEvents, DEFAULT_AGENT_SETTINGS.codexShowDetailedEvents),
-    codexNetworkAccessEnabled: false,
-    codexWebSearchMode: 'disabled',
     maxConcurrentRequests: numberValue(source.maxConcurrentRequests, 1, 8, DEFAULT_AGENT_SETTINGS.maxConcurrentRequests, true)
   };
 }
@@ -95,10 +68,4 @@ export class AgentSettingsStore {
     return { ...next };
   }
 
-  async reset() {
-    const next = normalizeAgentSettings(DEFAULT_AGENT_SETTINGS);
-    await writeJsonAtomic(this.filePath, next);
-    this.settings = next;
-    return { ...next };
-  }
 }

package/src/agents/codex-agent-runtime.js

@@ -4,7 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
-import { AgentProviderError } from './provider-errors.js';
+import { AgentRuntimeError } from './agent-runtime-error.js';
 import { AGENT_TOOL_NAMES } from './agent-tool-registry.js';
 import { createAgentPermissionPolicy, hashAgentPermissionPolicy } from './agent-permissions.js';
 
@@ -57,12 +57,12 @@ function isAbortError(error) {
 
 function normalizeCodexError(error) {
   const message = safeText(error?.message, 800) || 'Codex run failed.';
-  if (error instanceof AgentProviderError && error.code !== 'codex-run-failed') return error;
-  if (/out of credits|usage limit|rate limit|too many requests/i.test(message)) return new AgentProviderError('codex-usage-limit-reached', 'The Codex workspace has no remaining usage.', { status: 402, retryable: true });
-  if (/refresh[_ -]?token[_ -]?(?:already[_ -]?)?used|token refresh|refresh credential/i.test(message)) return new AgentProviderError('codex-auth-stale', 'The saved Codex sign-in is stale. LiveDesk refreshed its Codex authentication bridge and will retry.', { status: 401, retryable: true });
-  if (/not authenticated|not logged in|authentication|unauthorized|login required/i.test(message)) return new AgentProviderError('codex-auth-required', 'Sign in with the Codex CLI first.', { status: 401 });
-  if (/user cancelled MCP tool call/i.test(message)) return new AgentProviderError('codex-mcp-tool-rejected', 'Codex rejected the LiveDesk MCP tool before it reached the Hub.', { status: 502 });
-  return new AgentProviderError('codex-run-failed', message, { status: 502, retryable: true });
+  if (error instanceof AgentRuntimeError && error.code !== 'codex-run-failed') return error;
+  if (/out of credits|usage limit|rate limit|too many requests/i.test(message)) return new AgentRuntimeError('codex-usage-limit-reached', 'The Codex workspace has no remaining usage.', { status: 402, retryable: true });
+  if (/refresh[_ -]?token[_ -]?(?:already[_ -]?)?used|token refresh|refresh credential/i.test(message)) return new AgentRuntimeError('codex-auth-stale', 'The saved Codex sign-in is stale. LiveDesk refreshed its Codex authentication bridge and will retry.', { status: 401, retryable: true });
+  if (/not authenticated|not logged in|authentication|unauthorized|login required/i.test(message)) return new AgentRuntimeError('codex-auth-required', 'Sign in with the Codex CLI first.', { status: 401 });
+  if (/user cancelled MCP tool call/i.test(message)) return new AgentRuntimeError('codex-mcp-tool-rejected', 'Codex rejected the LiveDesk MCP tool before it reached the Hub.', { status: 502 });
+  return new AgentRuntimeError('codex-run-failed', message, { status: 502, retryable: true });
 }
 
 function codexThreadOptions(workspace) {
@@ -164,16 +164,16 @@ async function ensureCodexHome(codexHome, globalCodexHome, { preferGlobalAuth =
   const resolvedHome = path.resolve(codexHome);
   const globalHome = path.resolve(globalCodexHome);
   if (!resolvedHome || resolvedHome === globalHome) {
-    throw new AgentProviderError('codex-isolation-unavailable', 'Codex requires a dedicated LiveDesk home.', { status: 503 });
+    throw new AgentRuntimeError('codex-isolation-unavailable', 'Codex requires a dedicated LiveDesk home.', { status: 503 });
   }
   try {
     await mkdir(resolvedHome, { recursive: true, mode: 0o700 });
     if (await access(path.join(resolvedHome, 'config.toml')).then(() => true, () => false)) {
-      throw new AgentProviderError('codex-environment-isolation-failed', 'The dedicated Codex home contains an unmanaged config.toml.', { status: 503 });
+      throw new AgentRuntimeError('codex-environment-isolation-failed', 'The dedicated Codex home contains an unmanaged config.toml.', { status: 503 });
     }
   } catch (error) {
-    if (error instanceof AgentProviderError) throw error;
-    const wrapped = new AgentProviderError('codex-environment-isolation-failed', 'The dedicated Codex home could not be prepared.', { status: 503 });
+    if (error instanceof AgentRuntimeError) throw error;
+    const wrapped = new AgentRuntimeError('codex-environment-isolation-failed', 'The dedicated Codex home could not be prepared.', { status: 503 });
     wrapped.cause = error;
     throw wrapped;
   }
@@ -200,7 +200,7 @@ async function ensureCodexHome(codexHome, globalCodexHome, { preferGlobalAuth =
       await replaceAuthHardLink(sourceAuthPath, targetAuthPath);
     }
   } catch (error) {
-    const wrapped = new AgentProviderError('codex-environment-isolation-failed', 'The Codex authentication bridge could not be prepared.', { status: 503 });
+    const wrapped = new AgentRuntimeError('codex-environment-isolation-failed', 'The Codex authentication bridge could not be prepared.', { status: 503 });
     wrapped.cause = error;
     throw wrapped;
   }
@@ -243,7 +243,7 @@ function runAgeMs(run) {
 }
 
 function codexAbortError(code, message) {
-  return new AgentProviderError(code, message, { status: code === 'codex-run-timeout' ? 504 : 409, retryable: code === 'codex-run-timeout' });
+  return new AgentRuntimeError(code, message, { status: code === 'codex-run-timeout' ? 504 : 409, retryable: code === 'codex-run-timeout' });
 }
 
 function safeAgentDeviceIds(value) {
@@ -331,7 +331,7 @@ export function createCodexAgentRuntime({
   function assertSecurityConfiguration() {
     const status = securityStatus();
     if (!status.isolatedCodexHome || !status.restrictedEnvironment || !status.livedeskMcpOnly || !status.selectedDeviceScopeEnforced) {
-      throw new AgentProviderError('codex-unsupported-security-config', 'Codex security isolation is not available.', { status: 503 });
+      throw new AgentRuntimeError('codex-unsupported-security-config', 'Codex security isolation is not available.', { status: 503 });
     }
   }
 
@@ -364,7 +364,7 @@ export function createCodexAgentRuntime({
 
   async function loadCodex() {
     if (!codexModulePromise) codexModulePromise = import('@openai/codex-sdk').catch(error => {
-      const wrapped = new AgentProviderError('codex-sdk-not-installed', 'Codex SDK is not installed in this LiveDesk package.', { status: 503 });
+      const wrapped = new AgentRuntimeError('codex-sdk-not-installed', 'Codex SDK is not installed in this LiveDesk package.', { status: 503 });
       wrapped.cause = error;
       throw wrapped;
     });
@@ -395,7 +395,7 @@ export function createCodexAgentRuntime({
         ? 'signed-in'
         : 'not-signed-in';
     } catch (error) {
-      if (error instanceof AgentProviderError) throw error;
+      if (error instanceof AgentRuntimeError) throw error;
       detail = safeText(error?.message, 300);
     }
     return { installed: true, authenticated, status: authenticated === 'signed-in' ? 'ready' : 'auth-required', codexPath: pathToCli, detail };
@@ -405,8 +405,8 @@ export function createCodexAgentRuntime({
     assertSecurityConfiguration();
     const startedAt = Date.now();
     const status = await getStatus();
-    if (!status.installed) throw new AgentProviderError('codex-sdk-not-installed', 'Codex SDK is not installed.', { status: 503 });
-    if (status.authenticated !== 'signed-in') throw new AgentProviderError('codex-auth-required', 'Sign in with the Codex CLI first.', { status: 401 });
+    if (!status.installed) throw new AgentRuntimeError('codex-sdk-not-installed', 'Codex SDK is not installed.', { status: 503 });
+    if (status.authenticated !== 'signed-in') throw new AgentRuntimeError('codex-auth-required', 'Sign in with the Codex CLI first.', { status: 401 });
     const settings = await settingsStore.get();
     await mkdir(workspace, { recursive: true });
     await prepareCodexHome();
@@ -416,7 +416,7 @@ export function createCodexAgentRuntime({
     try {
       const thread = codex.startThread(codexThreadOptions(workspace));
       const turn = await thread.run('Reply with the single word READY. Do not use tools.', { signal: controller.signal });
-      if (!String(turn.finalResponse || '').trim()) throw new AgentProviderError('codex-empty-response', 'Codex returned an empty response.', { status: 502 });
+      if (!String(turn.finalResponse || '').trim()) throw new AgentRuntimeError('codex-empty-response', 'Codex returned an empty response.', { status: 502 });
       return { ok: true, latencyMs: Date.now() - startedAt, threadId: thread.id || '' };
     } catch (error) {
       throw normalizeCodexError(error);
@@ -492,15 +492,15 @@ export function createCodexAgentRuntime({
       timeoutTimer.unref?.();
       await mkdir(workspace, { recursive: true });
       if (activeCount > settings.maxConcurrentRequests) {
-        throw new AgentProviderError('agent-concurrency-limit', 'The LiveDesk Agent concurrency limit is reached.', { status: 429, retryable: true });
+        throw new AgentRuntimeError('agent-concurrency-limit', 'The LiveDesk Agent concurrency limit is reached.', { status: 429, retryable: true });
       }
       if (run.abortController.signal.aborted) {
         if (run.abortReason === 'timeout') throw codexAbortError('codex-run-timeout', 'The Codex task exceeded its timeout.');
         throw Object.assign(new Error('The Codex task was cancelled.'), { name: 'AbortError' });
       }
       const status = await getStatus();
-      if (!status.installed) throw new AgentProviderError('codex-sdk-not-installed', 'Codex SDK is not installed.', { status: 503 });
-      if (status.authenticated !== 'signed-in') throw new AgentProviderError('codex-auth-required', 'Sign in with the Codex CLI first.', { status: 401 });
+      if (!status.installed) throw new AgentRuntimeError('codex-sdk-not-installed', 'Codex SDK is not installed.', { status: 503 });
+      if (status.authenticated !== 'signed-in') throw new AgentRuntimeError('codex-auth-required', 'Sign in with the Codex CLI first.', { status: 401 });
       reportProgress(run, 'preparing-tools', 'Codex is ready. Preparing the LiveDesk tools for this Client.');
       session = createMcpSession({
         runId: run.runId,
@@ -552,14 +552,14 @@ export function createCodexAgentRuntime({
                 run.abortReason = 'turn-limit';
                 run.abortController.abort();
                 session.cancel();
-                throw new AgentProviderError('codex-turn-limit-reached', 'Codex exceeded the LiveDesk turn limit.', { status: 409 });
+                throw new AgentRuntimeError('codex-turn-limit-reached', 'Codex exceeded the LiveDesk turn limit.', { status: 409 });
               }
             }
             if (run.toolCallCount > run.permissionPolicy.maxToolCalls) {
               run.abortReason = 'tool-limit';
               run.abortController.abort();
               session.cancel();
-              throw new AgentProviderError('codex-tool-limit-reached', 'Codex exceeded the LiveDesk tool-call limit.', { status: 409 });
+              throw new AgentRuntimeError('codex-tool-limit-reached', 'Codex exceeded the LiveDesk tool-call limit.', { status: 409 });
             }
             if (event.type === 'item.completed' && event.item?.type === 'mcp_tool_call' && event.item?.status === 'failed') {
               throw new Error(safeText(event.item?.error?.message, 800) || `LiveDesk tool ${safeText(event.item?.tool, 120) || 'call'} failed.`);
@@ -641,14 +641,14 @@ export function createCodexAgentRuntime({
 
   async function start(input = {}) {
     const instruction = safeText(input.instruction, 4000);
-    if (!instruction) throw new AgentProviderError('agent-invalid-instruction', 'Instruction is required.', { status: 400 });
+    if (!instruction) throw new AgentRuntimeError('agent-invalid-instruction', 'Instruction is required.', { status: 400 });
     const deviceIds = safeAgentDeviceIds(input.deviceIds);
-    if (deviceIds.length === 0) throw new AgentProviderError('agent-no-target-devices', 'Select at least one connected device.', { status: 400 });
+    if (deviceIds.length === 0) throw new AgentRuntimeError('agent-no-target-devices', 'Select at least one connected device.', { status: 400 });
     const settings = await settingsStore.get();
-    if (!settings.enabled) throw new AgentProviderError('agent-ai-disabled', 'Codex Agent is disabled in Settings.', { status: 409 });
+    if (!settings.enabled) throw new AgentRuntimeError('agent-disabled', 'Codex Agent is disabled in Settings.', { status: 409 });
     assertSecurityConfiguration();
     pruneRuns();
-    if (runs.size >= MAX_RUNS) throw new AgentProviderError('agent-run-limit', 'The LiveDesk Agent run history is full.', { status: 429, retryable: true });
+    if (runs.size >= MAX_RUNS) throw new AgentRuntimeError('agent-run-limit', 'The LiveDesk Agent run history is full.', { status: 429, retryable: true });
     const permissionPolicy = freezeAgentPermissionPolicy(input.permissionPolicy && typeof input.permissionPolicy === 'object'
       ? input.permissionPolicy
       : createAgentPermissionPolicy({ mode: input.permissionMode || 'safe-auto', deviceIds, maxToolCalls: settings.codexMaxToolCalls }));

package/src/remote-hub.js

@@ -3898,14 +3898,21 @@ export function createRemoteHub(options = {}) {
                 : null,
             nativeEncoderHardwareQueryStatus: safeString(message.nativeEncoderHardwareQueryStatus, 80),
             nativeCaptureFps: Number.isFinite(Number(message.nativeCaptureFps)) ? Number(message.nativeCaptureFps) : 0,
+            nativeCompressionFps: Number.isFinite(Number(message.nativeCompressionFps)) ? Number(message.nativeCompressionFps) : 0,
             nativeEncodedFps: Number.isFinite(Number(message.nativeEncodedFps)) ? Number(message.nativeEncodedFps) : 0,
             nativeCaptureSampleCount: Number.isFinite(Number(message.nativeCaptureSampleCount)) ? Number(message.nativeCaptureSampleCount) : 0,
             nativeEncodableFrameCount: Number.isFinite(Number(message.nativeEncodableFrameCount)) ? Number(message.nativeEncodableFrameCount) : 0,
             nativeSkippedFrameCount: Number.isFinite(Number(message.nativeSkippedFrameCount)) ? Number(message.nativeSkippedFrameCount) : 0,
+            nativeCompressionOutputCount: Number.isFinite(Number(message.nativeCompressionOutputCount)) ? Number(message.nativeCompressionOutputCount) : 0,
             nativeEncodedFrameCount: Number.isFinite(Number(message.nativeEncodedFrameCount)) ? Number(message.nativeEncodedFrameCount) : 0,
             nativeEncodeFramesInFlight: Number.isFinite(Number(message.nativeEncodeFramesInFlight)) ? Number(message.nativeEncodeFramesInFlight) : 0,
             nativeBackpressureSkippedFrameCount: Number.isFinite(Number(message.nativeBackpressureSkippedFrameCount)) ? Number(message.nativeBackpressureSkippedFrameCount) : 0,
             nativeIdleSkippedFrameCount: Number.isFinite(Number(message.nativeIdleSkippedFrameCount)) ? Number(message.nativeIdleSkippedFrameCount) : 0,
+            nativeOutputQueueDepth: Number.isFinite(Number(message.nativeOutputQueueDepth)) ? Number(message.nativeOutputQueueDepth) : 0,
+            nativeOutputQueueBytes: Number.isFinite(Number(message.nativeOutputQueueBytes)) ? Number(message.nativeOutputQueueBytes) : 0,
+            nativeOutputQueueHighWatermark: Number.isFinite(Number(message.nativeOutputQueueHighWatermark)) ? Number(message.nativeOutputQueueHighWatermark) : 0,
+            nativeOutputQueueDroppedCount: Number.isFinite(Number(message.nativeOutputQueueDroppedCount)) ? Number(message.nativeOutputQueueDroppedCount) : 0,
+            nativeOutputQueueAwaitingKeyFrame: message.nativeOutputQueueAwaitingKeyFrame === true,
             nativeCaptureTelemetryAt: safeString(message.nativeCaptureTelemetryAt, 80),
             droppedByAgent: Number.isFinite(Number(message.droppedByAgent)) ? Number(message.droppedByAgent) : 0,
             hardwareEncoder: safeString(message.hardwareEncoder, 80),
@@ -4280,14 +4287,21 @@ export function createRemoteHub(options = {}) {
                 : null,
             nativeEncoderHardwareQueryStatus: safeString(message.nativeEncoderHardwareQueryStatus, 80),
             nativeCaptureFps: Number.isFinite(Number(message.nativeCaptureFps)) ? Number(message.nativeCaptureFps) : 0,
+            nativeCompressionFps: Number.isFinite(Number(message.nativeCompressionFps)) ? Number(message.nativeCompressionFps) : 0,
             nativeEncodedFps: Number.isFinite(Number(message.nativeEncodedFps)) ? Number(message.nativeEncodedFps) : 0,
             nativeCaptureSampleCount: Number.isFinite(Number(message.nativeCaptureSampleCount)) ? Number(message.nativeCaptureSampleCount) : 0,
             nativeEncodableFrameCount: Number.isFinite(Number(message.nativeEncodableFrameCount)) ? Number(message.nativeEncodableFrameCount) : 0,
             nativeSkippedFrameCount: Number.isFinite(Number(message.nativeSkippedFrameCount)) ? Number(message.nativeSkippedFrameCount) : 0,
+            nativeCompressionOutputCount: Number.isFinite(Number(message.nativeCompressionOutputCount)) ? Number(message.nativeCompressionOutputCount) : 0,
             nativeEncodedFrameCount: Number.isFinite(Number(message.nativeEncodedFrameCount)) ? Number(message.nativeEncodedFrameCount) : 0,
             nativeEncodeFramesInFlight: Number.isFinite(Number(message.nativeEncodeFramesInFlight)) ? Number(message.nativeEncodeFramesInFlight) : 0,
             nativeBackpressureSkippedFrameCount: Number.isFinite(Number(message.nativeBackpressureSkippedFrameCount)) ? Number(message.nativeBackpressureSkippedFrameCount) : 0,
             nativeIdleSkippedFrameCount: Number.isFinite(Number(message.nativeIdleSkippedFrameCount)) ? Number(message.nativeIdleSkippedFrameCount) : 0,
+            nativeOutputQueueDepth: Number.isFinite(Number(message.nativeOutputQueueDepth)) ? Number(message.nativeOutputQueueDepth) : 0,
+            nativeOutputQueueBytes: Number.isFinite(Number(message.nativeOutputQueueBytes)) ? Number(message.nativeOutputQueueBytes) : 0,
+            nativeOutputQueueHighWatermark: Number.isFinite(Number(message.nativeOutputQueueHighWatermark)) ? Number(message.nativeOutputQueueHighWatermark) : 0,
+            nativeOutputQueueDroppedCount: Number.isFinite(Number(message.nativeOutputQueueDroppedCount)) ? Number(message.nativeOutputQueueDroppedCount) : 0,
+            nativeOutputQueueAwaitingKeyFrame: message.nativeOutputQueueAwaitingKeyFrame === true,
             nativeCaptureTelemetryAt: safeString(message.nativeCaptureTelemetryAt, 80),
             droppedByAgent: Number.isFinite(Number(message.droppedByAgent)) ? Number(message.droppedByAgent) : 0,
             hubIngressDropped: Number.isFinite(Number(message.hubIngressDropped)) ? Number(message.hubIngressDropped) : 0,

package/src/server.js

@@ -19,7 +19,7 @@ import { createAgentManager } from './agents/agent-manager.js';
 import { AgentSettingsStore } from './agents/agent-settings.js';
 import { createCodexAgentRuntime } from './agents/codex-agent-runtime.js';
 import { createAgentDeviceScope, resolveAgentTargetIds } from './agents/agent-device-scope.js';
-import { AgentProviderError } from './agents/provider-errors.js';
+import { AgentRuntimeError } from './agents/agent-runtime-error.js';
 import { AGENT_PERMISSION_MODES, createAgentPermissionPolicy, evaluateAgentToolPermission, hashAgentPermissionPolicy } from './agents/agent-permissions.js';
 import { createAgentPermissionStore } from './agents/agent-permission-store.js';
 import { createAgentAuditStore } from './agents/agent-audit-store.js';
@@ -931,7 +931,7 @@ function createAgentMcpSession({ runId, signal, allowedDeviceIds: allowedDeviceI
   const allowedDeviceIds = createAgentDeviceScope(allowedDeviceIdsInput);
   const initialResolution = resolveAgentTargetIds({ allowedDeviceIds, connectedDeviceIds: connectedAgentDeviceIds() });
   if (initialResolution.deviceIds.length === 0) {
-    throw new AgentProviderError(initialResolution.error || 'agent-no-target-devices', 'No selected connected device is available.', { status: 400 });
+    throw new AgentRuntimeError(initialResolution.error || 'agent-no-target-devices', 'No selected connected device is available.', { status: 400 });
   }
   pruneAgentMcpRunBatches();
   const effectivePermissionPolicy = permissionPolicy || createAgentPermissionPolicy({ mode: 'ask', deviceIds: allowedDeviceIdsInput, maxToolCalls });
@@ -1376,7 +1376,7 @@ function sendAgentError(res, error) {
   const code = String(error?.code || 'agent-request-failed').replace(/[^a-z0-9-]/gi, '-').toLowerCase().slice(0, 80);
   const status = Number.isInteger(error?.status) && error.status >= 400 && error.status <= 599
     ? error.status
-    : code === 'agent-api-key-missing' || code === 'agent-api-key-invalid' || code === 'codex-auth-required' ? 401
+    : code === 'codex-auth-required' ? 401
     : code === 'agent-no-target-devices' || code === 'agent-target-outside-selection' || code === 'codex-tool-not-allowed' || code === 'agent-permission-denied' || code === 'agent-approval-required' || code === 'agent-approval-rejected' || code === 'agent-approval-expired' || code === 'agent-tool-single-target-required' || code === 'agent-tool-platform-unsupported' || code === 'agent-tool-capability-unavailable' ? 400
         : code === 'agent-mcp-loopback-only' ? 403
           : code === 'codex-isolation-unavailable' || code === 'codex-environment-isolation-failed' || code === 'codex-unsupported-security-config' ? 503
@@ -2108,14 +2108,21 @@ function buildRemoteFrameBinaryPacket(frameEvent, diagnostics = {}) {
       : null,
     nativeEncoderHardwareQueryStatus: frame.nativeEncoderHardwareQueryStatus || '',
     nativeCaptureFps: Number(frame.nativeCaptureFps || 0) || 0,
+    nativeCompressionFps: Number(frame.nativeCompressionFps || 0) || 0,
     nativeEncodedFps: Number(frame.nativeEncodedFps || 0) || 0,
     nativeCaptureSampleCount: Number(frame.nativeCaptureSampleCount || 0) || 0,
     nativeEncodableFrameCount: Number(frame.nativeEncodableFrameCount || 0) || 0,
     nativeSkippedFrameCount: Number(frame.nativeSkippedFrameCount || 0) || 0,
+    nativeCompressionOutputCount: Number(frame.nativeCompressionOutputCount || 0) || 0,
     nativeEncodedFrameCount: Number(frame.nativeEncodedFrameCount || 0) || 0,
     nativeEncodeFramesInFlight: Number(frame.nativeEncodeFramesInFlight || 0) || 0,
     nativeBackpressureSkippedFrameCount: Number(frame.nativeBackpressureSkippedFrameCount || 0) || 0,
     nativeIdleSkippedFrameCount: Number(frame.nativeIdleSkippedFrameCount || 0) || 0,
+    nativeOutputQueueDepth: Number(frame.nativeOutputQueueDepth || 0) || 0,
+    nativeOutputQueueBytes: Number(frame.nativeOutputQueueBytes || 0) || 0,
+    nativeOutputQueueHighWatermark: Number(frame.nativeOutputQueueHighWatermark || 0) || 0,
+    nativeOutputQueueDroppedCount: Number(frame.nativeOutputQueueDroppedCount || 0) || 0,
+    nativeOutputQueueAwaitingKeyFrame: frame.nativeOutputQueueAwaitingKeyFrame === true,
     nativeCaptureTelemetryAt: frame.nativeCaptureTelemetryAt || '',
     droppedByAgent: Number(frame.droppedByAgent || 0) || 0,
     hubIngressDropped: Number(frame.hubIngressDropped || 0) || 0,
@@ -2925,48 +2932,7 @@ app.get('/api/settings/agent/audit', async (req, res) => {
   res.json({ ok: true, audit: await agentAuditStore.list({ runId: req.query?.runId || '', limit: req.query?.limit }) });
 });
 
-app.put('/api/settings/agent', async (req, res) => {
-  noStore(res);
-  try {
-    const patch = req.body && typeof req.body === 'object' && !Array.isArray(req.body) ? { ...req.body } : {};
-    delete patch.enabled;
-    patch.enabled = await synchronizeAgentEnablement();
-    res.json({ ok: true, settings: await agentManager.updateSettings(patch) });
-  } catch (error) {
-    sendAgentError(res, error);
-  }
-});
-
-app.post('/api/settings/agent/reset', async (_req, res) => {
-  noStore(res);
-  try {
-    await agentManager.resetSettings();
-    await synchronizeAgentEnablement();
-    res.json({ ok: true, settings: await agentManager.getSettings() });
-  } catch (error) {
-    sendAgentError(res, error);
-  }
-});
-
-app.delete('/api/settings/agent/api-key', async (_req, res) => {
-  noStore(res);
-  try {
-    res.json({ ok: true, settings: await agentManager.deleteApiKey() });
-  } catch (error) {
-    sendAgentError(res, error);
-  }
-});
-
-app.get('/api/settings/agent/models', async (_req, res) => {
-  noStore(res);
-  res.status(410).json({
-    ok: false,
-    error: 'agent-model-catalog-retired',
-    message: 'LiveDesk uses the Codex SDK defaults and does not manage models.'
-  });
-});
-
-app.post('/api/settings/agent/test', async (_req, res) => {
+app.post('/api/settings/agent/test', async (_req, res) => {
   noStore(res);
   try {
     res.json({ ok: true, connection: await agentManager.testConnection() });
@@ -3001,17 +2967,17 @@ app.post('/api/settings/agent/run', async (req, res) => {
   noStore(res);
   try {
     if (!(await synchronizeAgentEnablement())) {
-      throw new AgentProviderError('agent-ai-disabled', 'Enable Codex Agent in Settings before running commands.', { status: 409 });
+      throw new AgentRuntimeError('agent-disabled', 'Enable Codex Agent in Settings before running commands.', { status: 409 });
     }
     const instruction = typeof req.body?.instruction === 'string' ? req.body.instruction.slice(0, 4000) : '';
     const deviceIds = normalizeDeviceIds(req.body?.deviceIds).slice(0, 500);
     const connectedDeviceIds = new Set(connectedAgentDeviceIds());
     if (deviceIds.length === 0 || deviceIds.some(deviceId => !connectedDeviceIds.has(deviceId))) {
-      throw new AgentProviderError('agent-target-not-connected', 'Every selected Client must have an active Agent control channel.', { status: 409 });
+      throw new AgentRuntimeError('agent-target-not-connected', 'Every selected Client must have an active Agent control channel.', { status: 409 });
     }
     const permissionMode = String(req.body?.permissionMode || 'ask').trim().toLowerCase();
     if (!AGENT_PERMISSION_MODES.includes(permissionMode)) {
-      throw new AgentProviderError('agent-policy-invalid', 'Select a valid Agent permission mode.', { status: 400 });
+      throw new AgentRuntimeError('agent-policy-invalid', 'Select a valid Agent permission mode.', { status: 400 });
     }
     const settings = await agentSettingsStore.get();
     const customPolicy = permissionMode === 'custom' ? await agentPermissionStore.get(req.body?.customPolicyId || 'custom-default') : null;
@@ -3109,17 +3075,7 @@ app.post('/api/settings/agent/runs/cancel-all', async (_req, res) => {
   res.json({ ok: true, cancelledRuns, cancelledSessions, cancelledBatches: cancelledBatchIds.size });
 });
 
-app.post('/api/settings/agent/plan', async (req, res) => {
-  noStore(res);
-  try {
-    const instruction = typeof req.body?.instruction === 'string' ? req.body.instruction.slice(0, 2000) : '';
-    res.json({ ok: true, plan: await agentManager.createPlan({ instruction }) });
-  } catch (error) {
-    sendAgentError(res, error);
-  }
-});
-
-app.post('/api/settings/agent/summary', async (req, res) => {
+app.post('/api/settings/agent/summary', async (req, res) => {
   noStore(res);
   try {
     res.json({ ok: true, ...await agentManager.createSummary(req.body || {}) });

package/src/agents/provider-errors.js

@@ -1,12 +0,0 @@
-export class AgentProviderError extends Error {
-  constructor(code, message, { status = 502, retryable = false } = {}) {
-    super(message);
-    this.name = 'AgentProviderError';
-    this.code = code;
-    this.status = status;
-    this.retryable = retryable;
-  }
-}
-export function isRetryableProviderError(error) {
-  return error?.retryable === true || ['agent-provider-timeout', 'agent-provider-network', 'agent-provider-rate-limited', 'agent-provider-upstream'].includes(error?.code);
-}