livedesk 0.1.203 → 0.1.204

package/hub/src/agents/agent-manager.js

@@ -0,0 +1,131 @@
+import os from 'node:os';
+import path from 'node:path';
+import { AgentSettingsStore } from './agent-settings.js';
+import { createOsSecretStore } from './secret-store.js';
+import { createOpenCodeGoProvider } from './opencode-go-provider.js';
+
+function maskApiKey(value) {
+  const key = String(value || '');
+  return key.length >= 4 ? `••••${key.slice(-4)}` : '';
+}
+
+export function createAgentManager({ dataDir = path.join(os.homedir(), '.livedesk'), settingsStore, secretStore, provider } = {}) {
+  const settings = settingsStore || new AgentSettingsStore({ dataDir });
+  const secrets = secretStore || createOsSecretStore({ dataDir });
+  const agentProvider = provider || createOpenCodeGoProvider();
+
+  async function publicSettings() {
+    const current = await settings.get();
+    let hasApiKey = false;
+    let apiKeyPreview = '';
+    let secretStoreAvailable = true;
+    try {
+      const key = await secrets.getApiKey(current.provider);
+      hasApiKey = Boolean(key);
+      apiKeyPreview = maskApiKey(key);
+    } catch (error) {
+      secretStoreAvailable = false;
+    }
+    return { ...current, hasApiKey, apiKeyPreview, secretStoreAvailable };
+  }
+
+  async function apiKeyForCurrentSettings() {
+    const current = await settings.get();
+    const apiKey = await secrets.getApiKey(current.provider);
+    if (!apiKey) {
+      const error = new Error('OpenCode Go API key is not configured.');
+      error.code = 'agent-api-key-missing';
+      error.status = 401;
+      throw error;
+    }
+    return { current, apiKey };
+  }
+
+  return {
+    getSettings: publicSettings,
+    async updateSettings(patch = {}) {
+      const nextPatch = { ...patch };
+      const apiKey = typeof nextPatch.apiKey === 'string' ? nextPatch.apiKey.trim() : '';
+      delete nextPatch.apiKey;
+      const current = await settings.get();
+      if (apiKey) await secrets.setApiKey(current.provider, apiKey);
+      await settings.update(nextPatch);
+      return publicSettings();
+    },
+    async resetSettings() {
+      await settings.reset();
+      return publicSettings();
+    },
+    async deleteApiKey() {
+      const current = await settings.get();
+      await secrets.deleteApiKey(current.provider);
+      return publicSettings();
+    },
+    async getModels() {
+      const { current, apiKey } = await apiKeyForCurrentSettings();
+      return agentProvider.getModels(current, apiKey);
+    },
+    async testConnection() {
+      const { current, apiKey } = await apiKeyForCurrentSettings();
+      return agentProvider.testConnection(current, apiKey);
+    },
+    async createPlan(input) {
+      const current = await settings.get();
+      if (!current.enabled) {
+        const error = new Error('Agent AI is disabled in Settings.');
+        error.code = 'agent-ai-disabled';
+        error.status = 409;
+        throw error;
+      }
+      const apiKey = await secrets.getApiKey(current.provider);
+      if (!apiKey) {
+        const error = new Error('OpenCode Go API key is not configured.');
+        error.code = 'agent-api-key-missing';
+        error.status = 401;
+        throw error;
+      }
+      return agentProvider.createPlan(input, current, apiKey);
+    },
+    async createSummary(input) {
+      const current = await settings.get();
+      if (!current.enabled || !current.generateSummary) {
+        const error = new Error('Agent summaries are disabled in Settings.');
+        error.code = 'agent-summary-disabled';
+        error.status = 409;
+        throw error;
+      }
+      const apiKey = await secrets.getApiKey(current.provider);
+      if (!apiKey) {
+        const error = new Error('OpenCode Go API key is not configured.');
+        error.code = 'agent-api-key-missing';
+        error.status = 401;
+        throw error;
+      }
+      const source = input && typeof input === 'object' ? input : {};
+      const results = Array.isArray(source.results) ? source.results : [];
+      const safeResults = current.includeRawDeviceDetails
+        ? results.map(result => ({
+          deviceName: String(result?.deviceName || '').slice(0, 120),
+          status: String(result?.status || '').slice(0, 40),
+          result: String(result?.result || '').slice(0, 1200),
+          error: String(result?.error || '').slice(0, 500)
+        }))
+        : results.map(result => ({
+          deviceName: String(result?.deviceName || '').slice(0, 120),
+          status: String(result?.status || '').slice(0, 40),
+          hasResult: Boolean(result?.result),
+          hasError: Boolean(result?.error)
+        }));
+      return agentProvider.createSummary({
+        instruction: String(source.instruction || '').slice(0, 500),
+        operation: String(source.operation || '').slice(0, 80),
+        summary: {
+          total: Number(source.total || results.length),
+          completed: Number(source.completed || 0),
+          failed: Number(source.failed || 0),
+          results: safeResults
+        }
+      }, current, apiKey);
+    }
+  };
+}

package/hub/src/agents/agent-settings.js

@@ -0,0 +1,154 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+export const AGENT_PROVIDER = 'opencode-go';
+export const DEFAULT_AGENT_BASE_URL = 'https://opencode.ai/zen/go/v1';
+
+export const DEFAULT_AGENT_SETTINGS = Object.freeze({
+  enabled: false,
+  provider: AGENT_PROVIDER,
+  baseUrl: DEFAULT_AGENT_BASE_URL,
+  defaultModelId: 'deepseek-v4-flash',
+  planModelId: '',
+  summaryModelId: '',
+  reasoningLevel: 'auto',
+  planTemperature: 0.1,
+  summaryTemperature: 0.2,
+  topP: 1,
+  planMaxOutputTokens: 1024,
+  summaryMaxOutputTokens: 1024,
+  planTimeoutMs: 60000,
+  summaryTimeoutMs: 60000,
+  retryCount: 1,
+  retryDelayMs: 1000,
+  maxConcurrentRequests: 2,
+  streamSummary: false,
+  deterministicParserFirst: true,
+  generateSummary: true,
+  fallbackSummary: true,
+  includeRawDeviceDetails: false
+});
+
+const REASONING_LEVELS = new Set(['auto', 'low', 'medium', 'high']);
+
+export class AgentSettingsError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'AgentSettingsError';
+    this.code = code;
+    this.status = 400;
+  }
+}
+
+function booleanValue(value, fallback) {
+  return typeof value === 'boolean' ? value : fallback;
+}
+
+function numberValue(value, min, max, fallback, integer = false) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) return fallback;
+  const clamped = Math.max(min, Math.min(max, number));
+  return integer ? Math.round(clamped) : clamped;
+}
+
+function stringValue(value, fallback, maxLength = 240) {
+  if (typeof value !== 'string') return fallback;
+  return value.trim().slice(0, maxLength);
+}
+
+function normalizeBaseUrl(value) {
+  const candidate = stringValue(value, DEFAULT_AGENT_BASE_URL, 500).replace(/\/+$/, '');
+  try {
+    const parsed = new URL(candidate);
+    if (!['http:', 'https:'].includes(parsed.protocol) || !parsed.hostname) {
+      throw new Error('invalid protocol');
+    }
+    parsed.hash = '';
+    parsed.search = '';
+    return parsed.toString().replace(/\/+$/, '');
+  } catch {
+    throw new AgentSettingsError('agent-invalid-base-url', 'Base URL must be a valid HTTP or HTTPS URL.');
+  }
+}
+
+export function normalizeAgentSettings(value = {}) {
+  const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+  const provider = stringValue(source.provider, DEFAULT_AGENT_SETTINGS.provider, 40);
+  if (provider !== AGENT_PROVIDER) {
+    throw new AgentSettingsError('agent-unsupported-provider', 'Only OpenCode Go is supported by this LiveDesk build.');
+  }
+  const reasoningLevel = stringValue(source.reasoningLevel, DEFAULT_AGENT_SETTINGS.reasoningLevel, 20).toLowerCase();
+  if (!REASONING_LEVELS.has(reasoningLevel)) {
+    throw new AgentSettingsError('agent-invalid-reasoning-level', 'Reasoning level is invalid.');
+  }
+  return {
+    enabled: booleanValue(source.enabled, DEFAULT_AGENT_SETTINGS.enabled),
+    provider: AGENT_PROVIDER,
+    baseUrl: normalizeBaseUrl(source.baseUrl ?? DEFAULT_AGENT_SETTINGS.baseUrl),
+    defaultModelId: stringValue(source.defaultModelId, DEFAULT_AGENT_SETTINGS.defaultModelId, 160),
+    planModelId: stringValue(source.planModelId, DEFAULT_AGENT_SETTINGS.planModelId, 160),
+    summaryModelId: stringValue(source.summaryModelId, DEFAULT_AGENT_SETTINGS.summaryModelId, 160),
+    reasoningLevel,
+    planTemperature: numberValue(source.planTemperature, 0, 2, DEFAULT_AGENT_SETTINGS.planTemperature),
+    summaryTemperature: numberValue(source.summaryTemperature, 0, 2, DEFAULT_AGENT_SETTINGS.summaryTemperature),
+    topP: numberValue(source.topP, 0, 1, DEFAULT_AGENT_SETTINGS.topP),
+    planMaxOutputTokens: numberValue(source.planMaxOutputTokens, 128, 16384, DEFAULT_AGENT_SETTINGS.planMaxOutputTokens, true),
+    summaryMaxOutputTokens: numberValue(source.summaryMaxOutputTokens, 128, 16384, DEFAULT_AGENT_SETTINGS.summaryMaxOutputTokens, true),
+    planTimeoutMs: numberValue(source.planTimeoutMs, 5000, 180000, DEFAULT_AGENT_SETTINGS.planTimeoutMs, true),
+    summaryTimeoutMs: numberValue(source.summaryTimeoutMs, 5000, 180000, DEFAULT_AGENT_SETTINGS.summaryTimeoutMs, true),
+    retryCount: numberValue(source.retryCount, 0, 4, DEFAULT_AGENT_SETTINGS.retryCount, true),
+    retryDelayMs: numberValue(source.retryDelayMs, 100, 10000, DEFAULT_AGENT_SETTINGS.retryDelayMs, true),
+    maxConcurrentRequests: numberValue(source.maxConcurrentRequests, 1, 8, DEFAULT_AGENT_SETTINGS.maxConcurrentRequests, true),
+    streamSummary: booleanValue(source.streamSummary, DEFAULT_AGENT_SETTINGS.streamSummary),
+    deterministicParserFirst: booleanValue(source.deterministicParserFirst, DEFAULT_AGENT_SETTINGS.deterministicParserFirst),
+    generateSummary: booleanValue(source.generateSummary, DEFAULT_AGENT_SETTINGS.generateSummary),
+    fallbackSummary: booleanValue(source.fallbackSummary, DEFAULT_AGENT_SETTINGS.fallbackSummary),
+    includeRawDeviceDetails: booleanValue(source.includeRawDeviceDetails, DEFAULT_AGENT_SETTINGS.includeRawDeviceDetails)
+  };
+}
+
+async function writeJsonAtomic(filePath, value) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+  await rename(temporaryPath, filePath);
+}
+
+export class AgentSettingsStore {
+  constructor({ dataDir = path.join(os.homedir(), '.livedesk') } = {}) {
+    this.filePath = path.join(dataDir, 'agent-settings.json');
+    this.settings = null;
+  }
+
+  async get() {
+    if (this.settings) return { ...this.settings };
+    try {
+      const raw = await readFile(this.filePath, 'utf8');
+      this.settings = normalizeAgentSettings(JSON.parse(raw));
+    } catch (error) {
+      if (error?.code !== 'ENOENT') {
+        this.settings = normalizeAgentSettings(DEFAULT_AGENT_SETTINGS);
+      } else {
+        this.settings = normalizeAgentSettings(DEFAULT_AGENT_SETTINGS);
+      }
+    }
+    return { ...this.settings };
+  }
+
+  async update(patch = {}) {
+    const current = await this.get();
+    const next = normalizeAgentSettings({ ...current, ...patch });
+    await writeJsonAtomic(this.filePath, next);
+    this.settings = next;
+    return { ...next };
+  }
+
+  async reset() {
+    const next = normalizeAgentSettings(DEFAULT_AGENT_SETTINGS);
+    await writeJsonAtomic(this.filePath, next);
+    this.settings = next;
+    return { ...next };
+  }
+}
+

package/hub/src/agents/opencode-go-provider.js

@@ -0,0 +1,260 @@
+import { AgentProviderError, isRetryableProviderError } from './provider-errors.js';
+import { DEFAULT_AGENT_BASE_URL } from './agent-settings.js';
+
+export const OPENCODE_GO_DEFAULT_MODEL_ID = 'deepseek-v4-flash';
+
+const AGENT_OPERATIONS = new Set([
+  'system.health',
+  'gpu.status',
+  'disk.status',
+  'process.list',
+  'service.status',
+  'diagnostics.collect'
+]);
+
+function normalizeBaseUrl(value) {
+  try {
+    const url = new URL(String(value || DEFAULT_AGENT_BASE_URL));
+    if (!['http:', 'https:'].includes(url.protocol)) throw new Error('protocol');
+    return url.toString().replace(/\/+$/, '');
+  } catch {
+    throw new AgentProviderError('agent-invalid-base-url', 'The Agent provider URL is invalid.', { status: 400 });
+  }
+}
+
+function normalizeCapabilities(source = {}) {
+  const capabilities = source.capabilities && typeof source.capabilities === 'object' ? source.capabilities : source;
+  return {
+    supportsReasoningLevel: capabilities.supportsReasoningLevel === true || capabilities.reasoning === true,
+    reasoningParameter: typeof capabilities.reasoningParameter === 'string' ? capabilities.reasoningParameter : '',
+    supportsTemperature: capabilities.supportsTemperature !== false,
+    supportsTopP: capabilities.supportsTopP !== false,
+    supportsStreaming: capabilities.supportsStreaming !== false,
+    supportsTools: capabilities.supportsTools === true,
+    supportsJsonSchema: capabilities.supportsJsonSchema === true
+  };
+}
+
+function normalizeModel(model) {
+  const id = String(model?.id || model?.model || '').trim();
+  if (!id) return null;
+  const protocolValue = String(model?.protocol || model?.api?.protocol || model?.type || '').trim().toLowerCase();
+  const protocol = /anthropic|messages/.test(protocolValue) ? 'anthropic-messages' : 'openai-chat-completions';
+  return {
+    id,
+    name: String(model?.name || model?.display_name || id).trim().slice(0, 200),
+    protocol,
+    available: model?.available !== false && protocol === 'openai-chat-completions',
+    capabilities: normalizeCapabilities(model)
+  };
+}
+
+export function normalizeModelList(payload) {
+  const source = Array.isArray(payload) ? payload : Array.isArray(payload?.data) ? payload.data : [];
+  return source.map(normalizeModel).filter(Boolean);
+}
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function contentFromCompletion(payload) {
+  const content = payload?.choices?.[0]?.message?.content ?? payload?.choices?.[0]?.text ?? '';
+  if (Array.isArray(content)) return content.map(item => typeof item === 'string' ? item : String(item?.text || '')).join('');
+  return String(content || '');
+}
+
+function parsePlan(content) {
+  const trimmed = String(content || '').trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '').trim();
+  let candidate = trimmed;
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    const start = trimmed.indexOf('{');
+    const end = trimmed.lastIndexOf('}');
+    if (start < 0 || end <= start) throw new AgentProviderError('agent-provider-invalid-response', 'The Agent provider returned an invalid plan.', { status: 502 });
+    candidate = trimmed.slice(start, end + 1);
+    try {
+      return JSON.parse(candidate);
+    } catch {
+      throw new AgentProviderError('agent-provider-invalid-response', 'The Agent provider returned an invalid plan.', { status: 502 });
+    }
+  }
+}
+
+function validatePlan(value) {
+  const operation = String(value?.operation || '').trim();
+  if (!AGENT_OPERATIONS.has(operation)) {
+    throw new AgentProviderError('agent-provider-invalid-plan', 'The Agent provider returned an unsupported operation.', { status: 502 });
+  }
+  const targetQuery = operation === 'process.list' && typeof value?.targetQuery === 'string'
+    ? value.targetQuery.replace(/[\0\r\n]/g, ' ').trim().slice(0, 120)
+    : '';
+  return {
+    operation,
+    targetQuery: targetQuery || undefined,
+    title: typeof value?.title === 'string' ? value.title.replace(/[\0\r\n]/g, ' ').trim().slice(0, 120) || undefined : undefined
+  };
+}
+
+export function createOpenCodeGoProvider() {
+  async function requestJson({ settings, apiKey, endpoint, method = 'GET', body, timeoutMs }) {
+    if (!apiKey) throw new AgentProviderError('agent-api-key-missing', 'OpenCode Go API key is not configured.', { status: 401 });
+    const url = `${normalizeBaseUrl(settings.baseUrl)}/${String(endpoint).replace(/^\/+/, '')}`;
+    const retryCount = Math.max(0, Math.min(4, Number(settings.retryCount) || 0));
+    const retryDelayMs = Math.max(100, Math.min(10000, Number(settings.retryDelayMs) || 1000));
+    for (let attempt = 0; attempt <= retryCount; attempt += 1) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), Math.max(1000, Number(timeoutMs) || 60000));
+      try {
+        const response = await fetch(url, {
+          method,
+          headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+          body: body === undefined ? undefined : JSON.stringify(body),
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        if (response.ok) return await response.json();
+        const status = response.status;
+        const retryable = status === 408 || status === 429 || status >= 500;
+        if (retryable && attempt < retryCount) {
+          await delay(retryDelayMs * (attempt + 1));
+          continue;
+        }
+        if (status === 401 || status === 403) throw new AgentProviderError('agent-api-key-invalid', 'OpenCode Go rejected the API key.', { status: 401 });
+        if (status === 429) throw new AgentProviderError('agent-provider-rate-limited', 'OpenCode Go is rate limiting requests.', { status: 429, retryable: true });
+        throw new AgentProviderError(status >= 500 ? 'agent-provider-upstream' : 'agent-provider-request-invalid', 'OpenCode Go rejected the request.', { status: status >= 500 ? 502 : 400, retryable });
+      } catch (error) {
+        clearTimeout(timer);
+        if (error instanceof AgentProviderError) {
+          if (isRetryableProviderError(error) && attempt < retryCount) {
+            await delay(retryDelayMs * (attempt + 1));
+            continue;
+          }
+          throw error;
+        }
+        const code = error?.name === 'AbortError' ? 'agent-provider-timeout' : 'agent-provider-network';
+        const message = code === 'agent-provider-timeout' ? 'OpenCode Go request timed out.' : 'OpenCode Go could not be reached.';
+        const providerError = new AgentProviderError(code, message, { status: code === 'agent-provider-timeout' ? 504 : 502, retryable: true });
+        if (attempt < retryCount) {
+          await delay(retryDelayMs * (attempt + 1));
+          continue;
+        }
+        throw providerError;
+      }
+    }
+    throw new AgentProviderError('agent-provider-network', 'OpenCode Go could not be reached.', { status: 502, retryable: true });
+  }
+
+  async function getModels(settings, apiKey) {
+    return normalizeModelList(await requestJson({ settings, apiKey, endpoint: 'models', timeoutMs: settings.summaryTimeoutMs }));
+  }
+
+  async function selectedModel(settings, apiKey, modelId) {
+    const models = await getModels(settings, apiKey);
+    const selected = models.find(model => model.id === modelId);
+    if (models.length > 0 && (!selected || !selected.available)) {
+      throw new AgentProviderError('agent-model-unavailable', 'The selected model is not available for LiveDesk.', { status: 409 });
+    }
+    return { models, model: selected || { id: modelId, name: modelId, available: true, protocol: 'openai-chat-completions', capabilities: normalizeCapabilities() } };
+  }
+
+  function completionBody({ model, messages, temperature, topP, maxTokens, reasoningLevel }) {
+    const body = { model: model.id, messages, max_tokens: maxTokens };
+    if (model.capabilities.supportsTemperature) body.temperature = temperature;
+    if (model.capabilities.supportsTopP) body.top_p = topP;
+    if (reasoningLevel !== 'auto' && model.capabilities.supportsReasoningLevel && model.capabilities.reasoningParameter) {
+      body[model.capabilities.reasoningParameter] = reasoningLevel;
+    }
+    return body;
+  }
+
+  async function testConnection(settings, apiKey) {
+    const startedAt = Date.now();
+    const modelId = settings.defaultModelId || OPENCODE_GO_DEFAULT_MODEL_ID;
+    const { model } = await selectedModel(settings, apiKey, modelId);
+    const payload = await requestJson({
+      settings,
+      apiKey,
+      endpoint: 'chat/completions',
+      method: 'POST',
+      timeoutMs: settings.planTimeoutMs,
+      body: completionBody({
+        model,
+        messages: [
+          { role: 'system', content: 'Return only the JSON object {"ok":true}. Do not add markdown.' },
+          { role: 'user', content: 'Connection test.' }
+        ],
+        temperature: 0,
+        topP: 1,
+        maxTokens: 32,
+        reasoningLevel: 'auto'
+      })
+    });
+    if (!contentFromCompletion(payload)) throw new AgentProviderError('agent-provider-invalid-response', 'OpenCode Go returned an empty response.', { status: 502 });
+    return { ok: true, modelId: model.id, modelName: model.name, latencyMs: Date.now() - startedAt };
+  }
+
+  async function createPlan({ instruction }, settings, apiKey) {
+    const normalizedInstruction = String(instruction || '').replace(/[\0]/g, ' ').trim().slice(0, 2000);
+    if (!normalizedInstruction) throw new AgentProviderError('agent-invalid-instruction', 'Instruction is required.', { status: 400 });
+    const modelId = settings.planModelId || settings.defaultModelId || OPENCODE_GO_DEFAULT_MODEL_ID;
+    const { model } = await selectedModel(settings, apiKey, modelId);
+    const payload = await requestJson({
+      settings,
+      apiKey,
+      endpoint: 'chat/completions',
+      method: 'POST',
+      timeoutMs: settings.planTimeoutMs,
+      body: completionBody({
+        model,
+        messages: [
+          {
+            role: 'system',
+            content: 'You are the LiveDesk read-only task planner. Return JSON only with exactly these keys: operation, targetQuery, title. Allowed operation values are system.health, gpu.status, disk.status, process.list, service.status, diagnostics.collect. Never suggest shell commands, PowerShell, Bash, file changes, installs, deletion, reboot, credentials, or arbitrary tools. Use targetQuery only for process.list; otherwise use null. If the request is outside the allowlist, return {"operation":null,"targetQuery":null,"title":"Unsupported request"}.'
+          },
+          { role: 'user', content: normalizedInstruction }
+        ],
+        temperature: settings.planTemperature,
+        topP: settings.topP,
+        maxTokens: settings.planMaxOutputTokens,
+        reasoningLevel: settings.reasoningLevel
+      })
+    });
+    return validatePlan(parsePlan(contentFromCompletion(payload)));
+  }
+
+  async function createSummary({ instruction, operation, summary }, settings, apiKey) {
+    const modelId = settings.summaryModelId || settings.defaultModelId || OPENCODE_GO_DEFAULT_MODEL_ID;
+    const { model } = await selectedModel(settings, apiKey, modelId);
+    const payload = await requestJson({
+      settings,
+      apiKey,
+      endpoint: 'chat/completions',
+      method: 'POST',
+      timeoutMs: settings.summaryTimeoutMs,
+      body: completionBody({
+        model,
+        messages: [
+          {
+            role: 'system',
+            content: 'You summarize completed LiveDesk read-only checks. Return plain text only, in at most three short sentences. Never include or invent commands, credentials, file paths, or remediation instructions.'
+          },
+          {
+            role: 'user',
+            content: JSON.stringify({ instruction: String(instruction || '').slice(0, 500), operation, summary })
+          }
+        ],
+        temperature: settings.summaryTemperature,
+        topP: settings.topP,
+        maxTokens: settings.summaryMaxOutputTokens,
+        reasoningLevel: 'auto'
+      })
+    });
+    const text = contentFromCompletion(payload).replace(/[\0]/g, ' ').trim().slice(0, 1200);
+    if (!text) throw new AgentProviderError('agent-provider-invalid-response', 'OpenCode Go returned an empty summary.', { status: 502 });
+    return { summary: text, modelId: model.id };
+  }
+
+  return { getModels, testConnection, createPlan, createSummary };
+}

package/hub/src/agents/provider-errors.js

@@ -0,0 +1,14 @@
+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);
+}
+