neoagent 2.3.1-beta.0 → 2.3.1-beta.100

package/server/services/ai/integrated_tools/shared.js

@@ -0,0 +1,204 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { APP_DIR } = require('../../../../runtime/paths');
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+  return dirPath;
+}
+
+function ensureRepoNodeModulesLink(targetDir) {
+  ensureDir(targetDir);
+  const sourceNodeModules = path.join(APP_DIR, 'node_modules');
+  const targetNodeModules = path.join(targetDir, 'node_modules');
+  if (fs.existsSync(targetNodeModules)) {
+    return targetNodeModules;
+  }
+  fs.symlinkSync(sourceNodeModules, targetNodeModules, 'junction');
+  return targetNodeModules;
+}
+
+function shellEscape(value) {
+  const text = String(value ?? '');
+  if (!text.length) return "''";
+  return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+
+function normalizeFilenameBase(value, fallback = 'artifact') {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return normalized || fallback;
+}
+
+function resolveRepoBinary(...segments) {
+  const parts = [...segments];
+  if (process.platform === 'win32' && parts.length > 0 && !parts[parts.length - 1].endsWith('.cmd')) {
+    parts[parts.length - 1] = `${parts[parts.length - 1]}.cmd`;
+  }
+  return path.join(APP_DIR, 'node_modules', '.bin', ...parts);
+}
+
+function assertExistingFile(filePath, label = 'file') {
+  const absolutePath = path.resolve(String(filePath || ''));
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`${label} does not exist: ${absolutePath}`);
+  }
+  const stat = fs.statSync(absolutePath);
+  if (!stat.isFile()) {
+    throw new Error(`${label} is not a file: ${absolutePath}`);
+  }
+  return absolutePath;
+}
+
+function writeTextFile(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, String(content || ''), 'utf8');
+  return filePath;
+}
+
+function writeJsonFile(filePath, payload) {
+  writeTextFile(filePath, `${JSON.stringify(payload, null, 2)}\n`);
+  return filePath;
+}
+
+function copyAssetIntoJob(sourcePath, targetDir, preferredName = 'asset', workspaceManager = null, userId = null) {
+  if (!workspaceManager || userId == null) {
+    throw new Error('Workspace manager is required for integrated tool assets.');
+  }
+  const absolutePath = workspaceManager.resolvePath(userId, sourcePath, 'asset');
+  ensureDir(targetDir);
+  const extension = path.extname(absolutePath).toLowerCase();
+  const basename = normalizeFilenameBase(path.basename(absolutePath, extension), preferredName);
+  const filename = `${basename}-${crypto.randomBytes(3).toString('hex')}${extension}`;
+  const targetPath = path.join(targetDir, filename);
+  fs.copyFileSync(absolutePath, targetPath);
+  return {
+    sourcePath: absolutePath,
+    targetPath,
+    relativePath: filename,
+  };
+}
+
+async function runCheckedCommand(executor, command, options = {}) {
+  if (!executor || typeof executor.execute !== 'function') {
+    throw new Error('CLI executor is unavailable for integrated tools.');
+  }
+  const result = await executor.execute(command, {
+    cwd: options.cwd,
+    timeout: options.timeout,
+    env: options.env,
+  });
+  if (result.exitCode !== 0) {
+    const stderr = String(result.stderr || '').trim();
+    const stdout = String(result.stdout || '').trim();
+    const details = stderr || stdout || `Command failed: ${command}`;
+    throw new Error(
+      options.errorPrefix
+        ? `${options.errorPrefix} ${details}`.trim()
+        : details
+    );
+  }
+  return result;
+}
+
+async function createJobDir(toolName, filenameBase, workspaceManager = null, userId = null) {
+  const prefix = normalizeFilenameBase(toolName, 'tool');
+  const suffix = normalizeFilenameBase(filenameBase, 'output');
+  const jobId = `${Date.now()}-${crypto.randomBytes(4).toString('hex')}-${suffix}`;
+  if (workspaceManager && userId != null) {
+    const toolingRoot = await workspaceManager.getToolingRoot(userId, prefix);
+    return ensureDir(path.join(toolingRoot, jobId));
+  }
+  throw new Error('Workspace manager is required for integrated tool jobs.');
+}
+
+function inferArtifactExtension(filePath) {
+  return path.extname(String(filePath || '')).toLowerCase().replace(/^\./, '') || 'bin';
+}
+
+function inferContentType(filePath) {
+  const extension = path.extname(String(filePath || '')).toLowerCase();
+  switch (extension) {
+    case '.pdf': return 'application/pdf';
+    case '.ppt': return 'application/vnd.ms-powerpoint';
+    case '.pptx': return 'application/vnd.openxmlformats-officedocument.presentationml.presentation';
+    case '.md': return 'text/markdown';
+    case '.png': return 'image/png';
+    case '.jpg':
+    case '.jpeg': return 'image/jpeg';
+    case '.svg': return 'image/svg+xml';
+    case '.mp4': return 'video/mp4';
+    case '.mov': return 'video/quicktime';
+    case '.webm': return 'video/webm';
+    default: return 'application/octet-stream';
+  }
+}
+
+function inferArtifactKind(filePath) {
+  const extension = path.extname(String(filePath || '')).toLowerCase();
+  if (['.ppt', '.pptx'].includes(extension)) return 'slides';
+  if (['.pdf', '.md'].includes(extension)) return 'document';
+  if (['.png', '.jpg', '.jpeg', '.svg'].includes(extension)) return 'image';
+  if (['.mp4', '.mov', '.webm'].includes(extension)) return 'video';
+  return 'artifact';
+}
+
+function createArtifactDescriptor(filePath, options = {}) {
+  const absolutePath = assertExistingFile(filePath, 'output');
+  const stat = fs.statSync(absolutePath);
+  return {
+    kind: options.kind || inferArtifactKind(absolutePath),
+    label: options.label || path.basename(absolutePath),
+    path: absolutePath,
+    mimeType: options.mimeType || inferContentType(absolutePath),
+    size: stat.size,
+  };
+}
+
+function promoteArtifactDescriptor(descriptor, artifactStore, userId) {
+  if (!artifactStore || userId == null || !descriptor?.path) {
+    return descriptor;
+  }
+  const extension = inferArtifactExtension(descriptor.path);
+  const allocation = artifactStore.allocateFile(userId, {
+    kind: descriptor.kind || inferArtifactKind(descriptor.path),
+    extension,
+    contentType: descriptor.mimeType || inferContentType(descriptor.path),
+    filenameBase: normalizeFilenameBase(descriptor.label || descriptor.kind || 'artifact', 'artifact'),
+    originalFilename: path.basename(descriptor.path),
+    metadata: {
+      sourceTool: 'integrated-media',
+      originalPath: descriptor.path,
+    },
+  });
+  fs.copyFileSync(descriptor.path, allocation.storagePath);
+  const finalized = artifactStore.finalizeFile(allocation.artifactId, allocation.storagePath);
+  return {
+    kind: descriptor.kind || inferArtifactKind(descriptor.path),
+    label: descriptor.label || path.basename(descriptor.path),
+    url: finalized.url,
+    mimeType: descriptor.mimeType || inferContentType(descriptor.path),
+    size: finalized.byteSize,
+  };
+}
+
+module.exports = {
+  copyAssetIntoJob,
+  createArtifactDescriptor,
+  createJobDir,
+  ensureDir,
+  ensureRepoNodeModulesLink,
+  normalizeFilenameBase,
+  promoteArtifactDescriptor,
+  resolveRepoBinary,
+  runCheckedCommand,
+  shellEscape,
+  writeJsonFile,
+  writeTextFile,
+};

package/server/services/ai/integrated_tools/slidev.js

@@ -0,0 +1,207 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const {
+  copyAssetIntoJob,
+  createArtifactDescriptor,
+  createJobDir,
+  ensureDir,
+  ensureRepoNodeModulesLink,
+  normalizeFilenameBase,
+  promoteArtifactDescriptor,
+  resolveRepoBinary,
+  runCheckedCommand,
+  shellEscape,
+  writeTextFile,
+} = require('./shared');
+
+const SLIDEV_BIN = resolveRepoBinary('slidev');
+const DEFAULT_EXPORT_FORMATS = ['pdf'];
+const ALLOWED_EXPORT_FORMATS = new Set(['pdf', 'pptx', 'png']);
+const ALLOWED_LAYOUTS = new Set(['cover', 'intro', 'statement', 'quote', 'section', 'two-cols', 'default']);
+
+function normalizeArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function normalizeExportFormats(value) {
+  const formats = normalizeArray(value)
+    .map((item) => String(item || '').trim().toLowerCase())
+    .filter((item) => ALLOWED_EXPORT_FORMATS.has(item));
+  return formats.length > 0 ? [...new Set(formats)] : [...DEFAULT_EXPORT_FORMATS];
+}
+
+function buildFrontmatter(args = {}) {
+  const lines = [
+    '---',
+    `theme: ${String(args.theme || 'default').trim() || 'default'}`,
+  ];
+  if (args.title) lines.push(`title: ${JSON.stringify(String(args.title).trim())}`);
+  if (args.subtitle) lines.push(`info: ${JSON.stringify(String(args.subtitle).trim())}`);
+  lines.push('layout: cover');
+  lines.push('transition: fade-out');
+  lines.push('mdc: true');
+  lines.push('---');
+  return lines.join('\n');
+}
+
+function materializeSlideAsset(value, assetsDir, workspaceManager, userId) {
+  if (!value) return '';
+  const text = String(value).trim();
+  if (!text) return '';
+  if (/^https?:\/\//i.test(text)) {
+    return text;
+  }
+  const asset = copyAssetIntoJob(text, assetsDir, 'slide-asset', workspaceManager, userId);
+  return `./assets/${asset.relativePath}`;
+}
+
+function buildStructuredDeckMarkdown(args, jobDir, workspaceManager, userId) {
+  const slides = normalizeArray(args.slides);
+  if (slides.length === 0) {
+    throw new Error('generate_slide_deck requires a non-empty slides array or deck_markdown.');
+  }
+  const assetsDir = ensureDir(path.join(jobDir, 'assets'));
+  const sections = [buildFrontmatter(args)];
+  const coverTitle = String(args.title || 'Presentation').trim();
+  const coverSubtitle = String(args.subtitle || '').trim();
+  sections.push(`# ${coverTitle}${coverSubtitle ? `\n\n${coverSubtitle}` : ''}`);
+
+  for (const slide of slides) {
+    const title = String(slide?.title || '').trim();
+    const layout = ALLOWED_LAYOUTS.has(String(slide?.layout || '').trim()) ? String(slide.layout).trim() : 'default';
+    const body = String(slide?.body || '').trim();
+    const notes = String(slide?.notes || '').trim();
+    const bullets = normalizeArray(slide?.bullets)
+      .map((item) => String(item || '').trim())
+      .filter(Boolean);
+    const imageRef = materializeSlideAsset(slide?.image_path || slide?.image_url, assetsDir, workspaceManager, userId);
+    const slideLines = ['---'];
+    if (layout !== 'default') slideLines.push(`layout: ${layout}`);
+    if (slide?.className) slideLines.push(`class: ${JSON.stringify(String(slide.className).trim())}`);
+    slideLines.push('---');
+    if (title) slideLines.push(`# ${title}`);
+    if (body) slideLines.push('', body);
+    if (bullets.length > 0) {
+      if (!body) slideLines.push('');
+      slideLines.push(...bullets.map((item) => `- ${item}`));
+    }
+    if (imageRef) {
+      slideLines.push('', `![](${imageRef})`);
+    }
+    if (notes) {
+      slideLines.push('', `<!--\n${notes}\n-->`);
+    }
+    sections.push(slideLines.join('\n'));
+  }
+
+  return `${sections.join('\n\n')}\n`;
+}
+
+function buildDeckMarkdown(args, jobDir, workspaceManager, userId) {
+  const rawMarkdown = String(args.deck_markdown || '').trim();
+  if (rawMarkdown) {
+    if (rawMarkdown.startsWith('---')) {
+      return `${rawMarkdown}\n`;
+    }
+    return `${buildFrontmatter(args)}\n\n${rawMarkdown}\n`;
+  }
+  return buildStructuredDeckMarkdown(args, jobDir, workspaceManager, userId);
+}
+
+function resolveExportPath(jobDir, filenameBase, format) {
+  if (format === 'png') {
+    return path.join(jobDir, `${filenameBase}-png`);
+  }
+  return path.join(jobDir, `${filenameBase}.${format}`);
+}
+
+function collectPngArtifacts(outputDir) {
+  if (!fs.existsSync(outputDir)) return [];
+  return fs.readdirSync(outputDir)
+    .filter((entry) => entry.toLowerCase().endsWith('.png'))
+    .sort()
+    .map((entry) => createArtifactDescriptor(path.join(outputDir, entry), {
+      kind: 'image',
+      label: entry,
+      mimeType: 'image/png',
+    }));
+}
+
+async function generateSlideDeck(args, context = {}) {
+  if (!fs.existsSync(SLIDEV_BIN)) {
+    throw new Error('Slidev CLI is not installed.');
+  }
+  const filenameBase = normalizeFilenameBase(args.filename_base || args.title || 'slide-deck', 'slide-deck');
+  const workspaceManager = context.workspaceManager;
+  const userId = context.userId;
+  const jobDir = await createJobDir('slidev', filenameBase, workspaceManager, userId);
+  ensureRepoNodeModulesLink(jobDir);
+  const markdownPath = path.join(jobDir, `${filenameBase}.md`);
+  const exportFormats = normalizeExportFormats(args.export_formats);
+  const deckMarkdown = buildDeckMarkdown(args, jobDir, workspaceManager, userId);
+  writeTextFile(markdownPath, deckMarkdown);
+
+  const executor = context.cliExecutor;
+  const commandOutputs = [];
+  for (const format of exportFormats) {
+    const outputPath = resolveExportPath(jobDir, filenameBase, format);
+    const command = [
+      shellEscape(SLIDEV_BIN),
+      'export',
+      shellEscape(markdownPath),
+      '--format',
+      shellEscape(format),
+      '--output',
+      shellEscape(outputPath),
+    ].join(' ');
+    const result = await runCheckedCommand(executor, command, {
+      cwd: jobDir,
+      timeout: 15 * 60 * 1000,
+      errorPrefix: `Slidev export failed for ${format}.`,
+    });
+    commandOutputs.push({ format, result });
+  }
+
+  const descriptors = [
+    createArtifactDescriptor(markdownPath, {
+      kind: 'document',
+      label: path.basename(markdownPath),
+      mimeType: 'text/markdown',
+    }),
+  ];
+
+  for (const format of exportFormats) {
+    const outputPath = resolveExportPath(jobDir, filenameBase, format);
+    if (format === 'png') {
+      descriptors.push(...collectPngArtifacts(outputPath));
+      continue;
+    }
+    descriptors.push(createArtifactDescriptor(outputPath, {
+      kind: format === 'pptx' ? 'slides' : 'document',
+      label: path.basename(outputPath),
+    }));
+  }
+
+  const promotedArtifacts = descriptors.map((descriptor) => (
+    promoteArtifactDescriptor(descriptor, context.artifactStore, context.userId)
+  ));
+
+  return {
+    success: true,
+    tool: 'generate_slide_deck',
+    title: String(args.title || '').trim() || null,
+    exportFormats,
+    artifacts: promotedArtifacts,
+    message: `Generated slide deck with ${exportFormats.join(', ')} output.`,
+    logs: commandOutputs.map((item) => ({
+      format: item.format,
+      durationMs: item.result.durationMs,
+    })),
+  };
+}
+
+module.exports = {
+  generateSlideDeck,
+};

package/server/services/ai/loopPolicy.js

@@ -0,0 +1,146 @@
+/**
+ * loopPolicy.js
+ *
+ * Single source of truth for every tunable limit in the agent loop.
+ * No magic numbers live in engine.js — everything flows from here.
+ *
+ * Values resolve in priority order:
+ *   1. Per-run option override (options.*)
+ *   2. Agent AI settings (aiSettings.*)
+ *   3. Hardcoded sane default
+ *
+ * "Open but stable": limits exist as safety nets, not as the primary
+ * exit signal. The AI signals completion via task_complete; these
+ * numbers only fire when something goes wrong.
+ */
+
+const DEFAULT_MAX_ITERATIONS = 20;
+const DEFAULT_WIDGET_MAX_ITERATIONS = 30;
+const DEFAULT_PLAN_EXECUTE_MAX_ITERATIONS = 40;
+const DEFAULT_COMPACTION_THRESHOLD = 0.82;
+const DEFAULT_MAX_CONSECUTIVE_TOOL_FAILURES = 5;
+const DEFAULT_MAX_MODEL_FAILURE_RECOVERIES = 3;
+
+// Hard ceilings — protect against runaway config values
+const MAX_ALLOWED_ITERATIONS = 200;
+const MAX_ALLOWED_TOOL_FAILURES = 50;
+const MAX_ALLOWED_MODEL_RECOVERIES = 10;
+const MAX_ALLOWED_BUDGET_CHARS = 500_000;
+
+/** Return n if finite and positive, otherwise fallback. */
+function finitePositive(n, fallback) {
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+/** Clamp n to [lo, hi]; return fallback if not finite. */
+function clampFinite(n, lo, hi, fallback) {
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(Math.max(n, lo), hi);
+}
+
+/**
+ * @param {object} aiSettings   - from getAiSettings()
+ * @param {string} triggerType  - 'chat' | 'schedule' | 'subagent' | etc.
+ * @param {string} analysisMode - 'direct_answer' | 'execute' | 'plan_execute'
+ * @param {object} options      - per-run options (may override anything)
+ * @returns {LoopPolicy}
+ */
+function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = 'execute', options = {}) {
+  // ── maxIterations ────────────────────────────────────────────────────────
+  // Resolve raw value from options → aiSettings → mode/context defaults,
+  // then clamp to [1, MAX_ALLOWED_ITERATIONS] and floor to integer.
+  let rawIterations;
+  if (options.maxIterations != null) {
+    rawIterations = Number(options.maxIterations);
+  } else if (aiSettings.max_iterations != null) {
+    rawIterations = Number(aiSettings.max_iterations);
+  } else if (options.widgetId) {
+    rawIterations = DEFAULT_WIDGET_MAX_ITERATIONS;
+  } else if (analysisMode === 'plan_execute') {
+    rawIterations = DEFAULT_PLAN_EXECUTE_MAX_ITERATIONS;
+  } else {
+    rawIterations = DEFAULT_MAX_ITERATIONS;
+  }
+  const maxIterations = clampFinite(
+    Math.floor(rawIterations),
+    1,
+    MAX_ALLOWED_ITERATIONS,
+    DEFAULT_MAX_ITERATIONS,
+  );
+
+  // ── Tool result size budget ───────────────────────────────────────────────
+  // Must be a finite positive integer; bad values fall back to 2400.
+  const defaultBudget = clampFinite(
+    Math.floor(Number(aiSettings.tool_replay_budget_chars) || 0),
+    500,
+    MAX_ALLOWED_BUDGET_CHARS,
+    2400,
+  );
+
+  // ── Scalar policy fields ─────────────────────────────────────────────────
+  const maxConsecutiveToolFailures = clampFinite(
+    Math.floor(Number(aiSettings.max_consecutive_tool_failures)),
+    1,
+    MAX_ALLOWED_TOOL_FAILURES,
+    DEFAULT_MAX_CONSECUTIVE_TOOL_FAILURES,
+  );
+
+  const maxModelFailureRecoveries = clampFinite(
+    Math.floor(Number(aiSettings.max_model_failure_recoveries)),
+    0,
+    MAX_ALLOWED_MODEL_RECOVERIES,
+    DEFAULT_MAX_MODEL_FAILURE_RECOVERIES,
+  );
+
+  // compactionThreshold must be in (0, 1]; clamp to [0.1, 1].
+  const compactionThreshold = clampFinite(
+    Number(aiSettings.compaction_threshold),
+    0.1,
+    1,
+    DEFAULT_COMPACTION_THRESHOLD,
+  );
+
+  return {
+    maxIterations,
+    maxConsecutiveToolFailures,
+    maxModelFailureRecoveries,
+
+    // Fill ratio at which context compaction triggers (0–1)
+    compactionThreshold,
+
+    // Per-category tool result size budgets (chars)
+    toolResultBudget: {
+      default: defaultBudget,
+      file:    clampFinite(Math.floor(Number(aiSettings.tool_replay_budget_file_chars)),    500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 6000)),
+      browser: clampFinite(Math.floor(Number(aiSettings.tool_replay_budget_browser_chars)), 500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 4000)),
+      command: clampFinite(Math.floor(Number(aiSettings.tool_replay_budget_command_chars)), 500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 4000)),
+    },
+
+    // Hard ceiling is always 2× soft, capped at a reasonable absolute max
+    hardLimitMultiplier: 2,
+    absoluteHardLimit: 12000,
+  };
+}
+
+/**
+ * Map a tool name to its result-size category.
+ */
+function getToolCategory(toolName) {
+  if (!toolName) return 'default';
+  if (/^(read_file|write_file|search_files|list_directory|file_)/.test(toolName)) return 'file';
+  if (/^browser_/.test(toolName)) return 'browser';
+  if (/^(execute_command|android_shell|android_)/.test(toolName)) return 'command';
+  return 'default';
+}
+
+/**
+ * Resolve soft + hard limits for a specific tool from the policy.
+ */
+function resolveToolResultLimits(toolName, policy) {
+  const category = getToolCategory(toolName);
+  const soft = policy.toolResultBudget[category] ?? policy.toolResultBudget.default;
+  const hard = Math.min(soft * policy.hardLimitMultiplier, policy.absoluteHardLimit);
+  return { softLimit: soft, hardLimit: hard };
+}
+
+module.exports = { buildLoopPolicy, getToolCategory, resolveToolResultLimits };

package/server/services/ai/models.js

@@ -3,6 +3,8 @@ const { GoogleProvider } = require('./providers/google');
 const { GrokProvider } = require('./providers/grok');
 const { OllamaProvider } = require('./providers/ollama');
 const { OpenAIProvider } = require('./providers/openai');
+const { GithubCopilotProvider } = require('./providers/githubCopilot');
+const { OpenAICodexProvider } = require('./providers/openaiCodex');
 const {
     AI_PROVIDER_DEFINITIONS,
     getProviderConfigs,
@@ -16,6 +18,36 @@ const STATIC_MODELS = [
         provider: 'grok',
         purpose: 'general'
     },
+    {
+        id: 'gpt-5.3',
+        label: 'GPT-5.3 (Copilot Default)',
+        provider: 'github-copilot',
+        purpose: 'general'
+    },
+    {
+        id: 'gpt-4.1',
+        label: 'GPT-4.1 (Copilot Fast)',
+        provider: 'github-copilot',
+        purpose: 'coding'
+    },
+    {
+        id: 'gpt-5.5',
+        label: 'GPT-5.5 (Codex Default)',
+        provider: 'openai-codex',
+        purpose: 'general'
+    },
+    {
+        id: 'gpt-5.4-mini',
+        label: 'GPT-5.4 mini (Codex Fast)',
+        provider: 'openai-codex',
+        purpose: 'coding'
+    },
+    {
+        id: 'gpt-5.4',
+        label: 'GPT-5.4 (Codex Fallback)',
+        provider: 'openai-codex',
+        purpose: 'general'
+    },
     {
         id: 'gpt-5-nano',
         label: 'GPT-5 Nano (Fast / Subagents)',
@@ -302,6 +334,10 @@ function createProviderInstance(providerStr, userId = null, configOverrides = {}
         return new AnthropicProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...providerOverrides });
     } else if (providerStr === 'ollama') {
         return new OllamaProvider({ baseUrl: runtime.baseUrl, ...providerOverrides });
+    } else if (providerStr === 'github-copilot') {
+        return new GithubCopilotProvider({ apiKey: runtime.apiKey, ...providerOverrides });
+    } else if (providerStr === 'openai-codex') {
+        return new OpenAICodexProvider({ apiKey: runtime.apiKey, ...providerOverrides });
     }
     throw new Error(`Unknown provider: ${providerStr}`);
 }