@cloudcli-ai/cloudcli 1.36.3 → 1.37.0

package/server/{opencode-cli.test.js → modules/providers/list/opencode/opencode-runtime.provider.test.js}

@@ -4,7 +4,20 @@ import os from 'node:os';
 import path from 'node:path';
 import test from 'node:test';
 
-import { resolveOpenCodePermissionOptions, spawnOpenCode } from './opencode-cli.js';
+import {
+  opencodeRuntime,
+  resolveOpenCodePermissionOptions,
+} from './opencode-runtime.provider.js';
+import { OpenCodeSessionsProvider } from './opencode-sessions.provider.js';
+
+const sessionsProvider = new OpenCodeSessionsProvider();
+const runtimeContext = {
+  resolveProviderSessionId: (sessionId) => sessionId || null,
+  resolveResumeModel: async (_sessionId, requestedModel) => requestedModel || undefined,
+  getProviderModels: async () => ({ OPTIONS: [], DEFAULT: '' }),
+  normalizeMessage: (raw, sessionId) => sessionsProvider.normalizeMessage(raw, sessionId),
+  isProviderInstalled: async () => true,
+};
 
 const findEnvKey = (name) =>
   Object.keys(process.env).find((key) => key.toLowerCase() === name.toLowerCase()) || name;
@@ -71,7 +84,7 @@ test('spawnOpenCode emits session_created before normalized live messages for ne
         : `.COM;.EXE;.BAT;.CMD${previousPathExt ? `;${previousPathExt}` : ''}`;
     }
 
-    await spawnOpenCode('Hi', { cwd: tempRoot }, writer);
+    await opencodeRuntime.run('Hi', { cwd: tempRoot }, writer, runtimeContext);
 
     const sessionCreatedIndex = messages.findIndex((message) => message.kind === 'session_created');
     const assistantDeltaIndex = messages.findIndex((message) =>
@@ -98,6 +111,26 @@ test('spawnOpenCode emits session_created before normalized live messages for ne
     assert.equal(launchedArgs.includes('--auto'), false);
     assert.equal(launchedArgs.includes('--agent'), false);
     assert.equal(capture.permissionEnv, null);
+
+    const attachmentOnlyCapturePath = path.join(tempRoot, 'opencode-attachment-only.json');
+    process.env.OPENCODE_ARGS_CAPTURE = attachmentOnlyCapturePath;
+    await opencodeRuntime.run(
+      '',
+      {
+        cwd: tempRoot,
+        files: [{
+          path: path.join(tempRoot, 'brief.pdf'),
+          name: 'brief.pdf',
+          mimeType: 'application/pdf',
+        }],
+      },
+      writer,
+      runtimeContext,
+    );
+    const attachmentOnlyCapture = JSON.parse(await readFile(attachmentOnlyCapturePath, 'utf8'));
+    const attachmentPrompt = attachmentOnlyCapture.args[attachmentOnlyCapture.args.length - 1];
+    assert.match(attachmentPrompt, /<files_input>/);
+    assert.match(attachmentPrompt, /brief\.pdf/);
   } finally {
     if (previousPath === undefined) {
       delete process.env[pathKey];
@@ -186,7 +219,12 @@ test('spawnOpenCode passes permission mode flags and env to the CLI', async () =
       const argsCapturePath = path.join(tempRoot, `opencode-args-${scenario.permissionMode}.json`);
       process.env.OPENCODE_ARGS_CAPTURE = argsCapturePath;
 
-      await spawnOpenCode('Hi', { cwd: tempRoot, permissionMode: scenario.permissionMode }, writer);
+      await opencodeRuntime.run(
+        'Hi',
+        { cwd: tempRoot, permissionMode: scenario.permissionMode },
+        writer,
+        runtimeContext,
+      );
 
       const capture = JSON.parse(await readFile(argsCapturePath, 'utf8'));
       for (const expectedArg of scenario.expectArgs) {

package/server/modules/providers/list/opencode/opencode-sessions.provider.ts

@@ -2,7 +2,7 @@ import fsSync from 'node:fs';
 
 import Database from 'better-sqlite3';
 
-import { parseImagesInputTag } from '@/shared/image-attachments.js';
+import { parseFilesInputTag, parseImagesInputTag } from '@/shared/image-attachments.js';
 import type { IProviderSessions } from '@/shared/interfaces.js';
 import type { AnyRecord, FetchHistoryOptions, FetchHistoryResult, NormalizedMessage } from '@/shared/types.js';
 import {
@@ -404,10 +404,17 @@ export class OpenCodeSessionsProvider implements IProviderSessions {
         const rawContent = extractText(partData);
         // User prompts sent with attachments carry an <images_input> path
         // list; strip it for display and surface the paths as images.
-        const { text: content, attachments } = messageRole === 'user'
+        const parsedImages = messageRole === 'user'
           ? parseImagesInputTag(rawContent)
           : { text: rawContent, attachments: [] };
-        if (content.trim() || attachments.length > 0) {
+        const parsedFiles = messageRole === 'user'
+          ? parseFilesInputTag(parsedImages.text)
+          : { text: rawContent, attachments: [] };
+        if (
+          parsedFiles.text.trim()
+          || parsedImages.attachments.length > 0
+          || parsedFiles.attachments.length > 0
+        ) {
           normalized.push(createNormalizedMessage({
             id: baseId,
             sessionId,
@@ -415,8 +422,9 @@ export class OpenCodeSessionsProvider implements IProviderSessions {
             provider: PROVIDER,
             kind: 'text',
             role: messageRole === 'user' ? 'user' : 'assistant',
-            content,
-            images: attachments.length > 0 ? attachments : undefined,
+            content: parsedFiles.text,
+            images: parsedImages.attachments.length > 0 ? parsedImages.attachments : undefined,
+            files: parsedFiles.attachments.length > 0 ? parsedFiles.attachments : undefined,
           }));
         }
         continue;

package/server/modules/providers/list/opencode/opencode.provider.ts

@@ -1,5 +1,6 @@
 import { OpenCodeProviderAuth } from '@/modules/providers/list/opencode/opencode-auth.provider.js';
 import { OpenCodeProviderModels } from '@/modules/providers/list/opencode/opencode-models.provider.js';
+import { opencodeRuntime } from '@/modules/providers/list/opencode/opencode-runtime.provider.js';
 import { OpenCodeMcpProvider } from '@/modules/providers/list/opencode/opencode-mcp.provider.js';
 import { OpenCodeSessionSynchronizer } from '@/modules/providers/list/opencode/opencode-session-synchronizer.provider.js';
 import { OpenCodeSessionsProvider } from '@/modules/providers/list/opencode/opencode-sessions.provider.js';
@@ -8,12 +9,14 @@ import { AbstractProvider } from '@/modules/providers/shared/base/abstract.provi
 import type {
   IProviderAuth,
   IProviderModels,
+  IProviderRuntime,
   IProviderSessionSynchronizer,
   IProviderSkills,
   IProviderSessions,
 } from '@/shared/interfaces.js';
 
 export class OpenCodeProvider extends AbstractProvider {
+  readonly runtime: IProviderRuntime = opencodeRuntime;
   readonly models: IProviderModels = new OpenCodeProviderModels();
   readonly mcp = new OpenCodeMcpProvider();
   readonly auth: IProviderAuth = new OpenCodeProviderAuth();

package/server/modules/providers/provider.routes.ts

@@ -4,6 +4,7 @@ import { providerAuthService } from '@/modules/providers/services/provider-auth.
 import { providerCapabilitiesService } from '@/modules/providers/services/provider-capabilities.service.js';
 import { providerMcpService } from '@/modules/providers/services/mcp.service.js';
 import { providerModelsService } from '@/modules/providers/services/provider-models.service.js';
+import { providerTokenUsageService } from '@/modules/providers/services/provider-token-usage.service.js';
 import { providerSkillsService } from '@/modules/providers/services/skills.service.js';
 import { sessionConversationsSearchService } from '@/modules/providers/services/session-conversations-search.service.js';
 import { sessionsService } from '@/modules/providers/services/sessions.service.js';
@@ -11,7 +12,6 @@ import type {
   LLMProvider,
   McpScope,
   McpTransport,
-  ProviderChangeActiveModelInput,
   ProviderSkillCreateFile,
   ProviderSkillCreateInput,
   UpsertProviderMcpServerInput,
@@ -352,7 +352,7 @@ const parseSessionSearchLimit = (value: unknown): number => {
   return Math.max(1, Math.min(parsed, 100));
 };
 
-const parseChangeActiveModelPayload = (payload: unknown): ProviderChangeActiveModelInput => {
+const parseSessionModelPayload = (payload: unknown): string => {
   if (!payload || typeof payload !== 'object') {
     throw new AppError('Request body must be an object.', {
       code: 'INVALID_REQUEST_BODY',
@@ -369,10 +369,7 @@ const parseChangeActiveModelPayload = (payload: unknown): ProviderChangeActiveMo
     });
   }
 
-  return {
-    sessionId: '',
-    model,
-  };
+  return model;
 };
 
 router.get(
@@ -394,20 +391,40 @@ router.get(
   }),
 );
 
-router.post(
+/**
+ * Reports which model one session is using. `requestedModel` lets the client
+ * pass the default it would otherwise send, so a session that has not been
+ * sent on yet resolves to that instead of the catalog default.
+ */
+router.get(
   '/:provider/sessions/:sessionId/active-model',
   asyncHandler(async (req: Request, res: Response) => {
     const provider = parseProvider(req.params.provider);
     const sessionId = parseSessionId(req.params.sessionId);
-    const payload = parseChangeActiveModelPayload(req.body);
-    const result = await providerModelsService.changeActiveModel(provider, {
-      ...payload,
+    const requestedModel = readOptionalQueryString(req.query.requestedModel);
+    const result = await providerModelsService.resolveSessionModel(provider, {
       sessionId,
+      requestedModel,
     });
     res.json(createApiSuccessResponse(result));
   }),
 );
 
+router.post(
+  '/:provider/sessions/:sessionId/active-model',
+  asyncHandler(async (req: Request, res: Response) => {
+    const provider = parseProvider(req.params.provider);
+    const sessionId = parseSessionId(req.params.sessionId);
+    const model = parseSessionModelPayload(req.body);
+    const stored = providerModelsService.setSessionModel(provider, sessionId, model);
+    // A session row only exists once the gateway has allocated one. Report the
+    // selection back either way so the client can hold it until the first send.
+    res.json(createApiSuccessResponse(
+      stored ?? { provider, sessionId, model, source: 'session' as const },
+    ));
+  }),
+);
+
 // ----------------- Skills routes -----------------
 router.get(
   '/:provider/skills',
@@ -556,6 +573,26 @@ router.get(
   }),
 );
 
+router.get(
+  '/sessions/:sessionId/token-usage',
+  asyncHandler(async (req: Request, res: Response) => {
+    const sessionId = parseSessionId(req.params.sessionId);
+    const result = await providerTokenUsageService.getSessionTokenUsage(sessionId);
+    res.json(createApiSuccessResponse(result));
+  }),
+);
+
+// Must stay registered after the static `/sessions/running` and
+// `/sessions/archived` routes so those literals never match `:sessionId`.
+router.get(
+  '/sessions/:sessionId',
+  asyncHandler(async (req: Request, res: Response) => {
+    const sessionId = parseSessionId(req.params.sessionId);
+    const result = sessionsService.getSessionDetailsById(sessionId);
+    res.json(createApiSuccessResponse(result));
+  }),
+);
+
 router.delete(
   '/sessions/:sessionId',
   asyncHandler(async (req: Request, res: Response) => {

package/server/modules/providers/services/provider-capabilities.service.ts

@@ -15,6 +15,8 @@ type ProviderCapabilities = {
   defaultPermissionMode: string;
   /** Whether image attachments can be included in a chat.send. */
   supportsImages: boolean;
+  /** Whether general file attachments can be included in a chat.send. */
+  supportsFiles: boolean;
   /** Whether an in-flight run can be cancelled via chat.abort. */
   supportsAbort: boolean;
   /** Whether interactive tool permission prompts can reach the UI. */
@@ -37,6 +39,7 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     permissionModes: ['default', 'auto', 'acceptEdits', 'bypassPermissions', 'plan'],
     defaultPermissionMode: 'default',
     supportsImages: true,
+    supportsFiles: true,
     supportsAbort: true,
     supportsPermissionRequests: true,
     supportsTokenUsage: true,
@@ -47,6 +50,7 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     permissionModes: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
     defaultPermissionMode: 'default',
     supportsImages: true,
+    supportsFiles: true,
     supportsAbort: true,
     supportsPermissionRequests: false,
     supportsTokenUsage: false,
@@ -57,6 +61,7 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     permissionModes: ['default', 'acceptEdits', 'bypassPermissions'],
     defaultPermissionMode: 'default',
     supportsImages: true,
+    supportsFiles: true,
     supportsAbort: true,
     supportsPermissionRequests: false,
     supportsTokenUsage: true,
@@ -66,10 +71,11 @@ const PROVIDER_CAPABILITIES: Record<LLMProvider, ProviderCapabilities> = {
     provider: 'opencode',
     // Mapped by the runtime onto OpenCode's controls: `--agent plan` (plan),
     // `--auto` (bypassPermissions) and the OPENCODE_PERMISSION env var
-    // (acceptEdits). See resolveOpenCodePermissionOptions in opencode-cli.js.
+    // (acceptEdits). See resolveOpenCodePermissionOptions in the OpenCode runtime adapter.
     permissionModes: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
     defaultPermissionMode: 'default',
     supportsImages: true,
+    supportsFiles: true,
     supportsAbort: true,
     supportsPermissionRequests: false,
     supportsTokenUsage: true,

package/server/modules/providers/services/provider-models.service.ts

@@ -2,27 +2,32 @@ import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
+import { sessionsDb } from '@/modules/database/index.js';
 import { providerRegistry } from '@/modules/providers/provider.registry.js';
 import type { IProvider } from '@/shared/interfaces.js';
 import type {
   LLMProvider,
-  ProviderChangeActiveModelInput,
   ProviderCurrentActiveModel,
   ProviderModelsCacheInfo,
   ProviderModelsDefinition,
   ProviderModelsResult,
-  ProviderSessionActiveModelChange,
+  ProviderSessionModel,
 } from '@/shared/types.js';
-import { readProviderSessionActiveModelChange } from '@/shared/utils.js';
 
 export const PROVIDER_MODELS_CACHE_TTL_MS = 3 * 24 * 60 * 60 * 1000;
 const PROVIDER_MODELS_CACHE_VERSION = 2;
 const UNCACHED_PROVIDERS = new Set<LLMProvider>(['claude']);
 
+/** Session-row access the service needs, narrowed so tests can stub it. */
+type ProviderModelsSessionStore = {
+  getSessionById(sessionId: string): { model: string | null } | null;
+  setSessionModel(sessionId: string, model: string): void;
+};
+
 type ProviderModelsServiceDependencies = {
   resolveProvider?: (provider: LLMProvider) => Pick<IProvider, 'models'>;
   cachePath?: string;
-  activeModelChangesPath?: string;
+  sessions?: ProviderModelsSessionStore;
   now?: () => number;
 };
 
@@ -137,7 +142,7 @@ const writeProviderModelsCacheFile = async (
 export const createProviderModelsService = (dependencies: ProviderModelsServiceDependencies = {}) => {
   const resolveProvider = dependencies.resolveProvider ?? providerRegistry.resolveProvider;
   const cachePath = dependencies.cachePath ?? getProviderModelsCachePath();
-  const activeModelChangesPath = dependencies.activeModelChangesPath;
+  const sessions = dependencies.sessions ?? sessionsDb;
   const now = dependencies.now ?? (() => Date.now());
   const memoryCache = new Map<LLMProvider, ProviderModelsCacheEntry>();
   const pendingRequests = new Map<LLMProvider, Promise<ProviderModelsResult>>();
@@ -308,34 +313,138 @@ export const createProviderModelsService = (dependencies: ProviderModelsServiceD
     sessionId?: string,
   ): Promise<ProviderCurrentActiveModel> => resolveProvider(provider).models.getCurrentActiveModel(sessionId);
 
-  const changeActiveModel = async (
-    provider: LLMProvider,
-    input: ProviderChangeActiveModelInput,
-  ): Promise<ProviderSessionActiveModelChange> => resolveProvider(provider).models.changeActiveModel(input);
+  const readRecordedSessionModel = (sessionId: string): string | null => {
+    const session = sessions.getSessionById(sessionId);
+    return session?.model?.trim() || null;
+  };
 
-  const getChangedActiveModel = async (
+  /**
+   * Records the model one session runs with.
+   *
+   * Called from the active-model route when the user picks a model and from
+   * `chat.send` on every turn, so the row always matches what the session last
+   * ran with. Sessions the app has not created yet (no row) are ignored rather
+   * than treated as an error: the client keeps its own pending selection and
+   * the value lands on the row with the first send.
+   */
+  const setSessionModel = (
     provider: LLMProvider,
     sessionId: string,
-  ): Promise<ProviderSessionActiveModelChange> => readProviderSessionActiveModelChange(provider, sessionId, {
-    filePath: activeModelChangesPath,
-  });
+    model: string,
+  ): ProviderSessionModel | null => {
+    const normalizedSessionId = sessionId.trim();
+    const normalizedModel = model.trim();
+    if (!normalizedSessionId || !normalizedModel) {
+      return null;
+    }
+
+    if (!sessions.getSessionById(normalizedSessionId)) {
+      return null;
+    }
+
+    sessions.setSessionModel(normalizedSessionId, normalizedModel);
+    return {
+      provider,
+      sessionId: normalizedSessionId,
+      model: normalizedModel,
+      source: 'session',
+    };
+  };
+
+  /**
+   * Answers "which model is this session using?" for every display surface.
+   *
+   * Precedence, highest first:
+   *   1. the model recorded on the session row — the user's pick, or whatever
+   *      the last send used;
+   *   2. the provider's own session state, for sessions started outside the app
+   *      that we have never recorded a model for;
+   *   3. `requestedModel`, the client's current default, for a chat that has no
+   *      session yet;
+   *   4. the provider catalog default.
+   */
+  const resolveSessionModel = async (
+    provider: LLMProvider,
+    options: { sessionId?: string | null; requestedModel?: string | null } = {},
+  ): Promise<ProviderSessionModel> => {
+    const normalizedSessionId = typeof options.sessionId === 'string' ? options.sessionId.trim() : '';
+    const normalizedRequestedModel = typeof options.requestedModel === 'string'
+      ? options.requestedModel.trim()
+      : '';
+
+    if (normalizedSessionId) {
+      const recordedModel = readRecordedSessionModel(normalizedSessionId);
+      if (recordedModel) {
+        return {
+          provider,
+          sessionId: normalizedSessionId,
+          model: recordedModel,
+          source: 'session',
+        };
+      }
 
+      // Never sent on through the app. Ask the provider what its own session
+      // state says before falling back to anything client-supplied.
+      const catalog = (await getProviderModels(provider)).models;
+      const providerModel = await getCurrentActiveModel(provider, normalizedSessionId);
+      const resolvedProviderModel = providerModel.model?.trim();
+      if (resolvedProviderModel && resolvedProviderModel !== catalog.DEFAULT) {
+        return {
+          provider,
+          sessionId: normalizedSessionId,
+          model: resolvedProviderModel,
+          source: 'provider',
+        };
+      }
+
+      return {
+        provider,
+        sessionId: normalizedSessionId,
+        model: normalizedRequestedModel || catalog.DEFAULT,
+        source: normalizedRequestedModel ? 'session' : 'default',
+      };
+    }
+
+    if (normalizedRequestedModel) {
+      return {
+        provider,
+        sessionId: null,
+        model: normalizedRequestedModel,
+        source: 'session',
+      };
+    }
+
+    const catalog = (await getProviderModels(provider)).models;
+    return {
+      provider,
+      sessionId: null,
+      model: catalog.DEFAULT,
+      source: 'default',
+    };
+  };
+
+  /**
+   * Picks the model one run should use, for provider runtime adapters.
+   *
+   * Deliberately narrower than `resolveSessionModel`: the provider's own
+   * session state is not consulted here. Codex reports a global config value
+   * from `getCurrentActiveModel`, which would silently override the model the
+   * user picked in the composer on every single run.
+   */
   const resolveResumeModel = async (
     provider: LLMProvider,
     sessionId: string | undefined,
     requestedModel?: string | null,
   ): Promise<string | undefined> => {
+    void provider;
     const normalizedRequestedModel = typeof requestedModel === 'string' ? requestedModel.trim() : '';
-    if (!sessionId?.trim()) {
+    const normalizedSessionId = sessionId?.trim();
+    if (!normalizedSessionId) {
       return normalizedRequestedModel || undefined;
     }
 
-    const changedModel = await getChangedActiveModel(provider, sessionId);
-    if (changedModel.supported && changedModel.changed && changedModel.model?.trim()) {
-      return changedModel.model.trim();
-    }
-
-    return normalizedRequestedModel || undefined;
+    const recordedModel = readRecordedSessionModel(normalizedSessionId);
+    return recordedModel || normalizedRequestedModel || undefined;
   };
 
   const clearCache = (): void => {
@@ -347,9 +456,8 @@ export const createProviderModelsService = (dependencies: ProviderModelsServiceD
 
   return {
     getProviderModels,
-    getCurrentActiveModel,
-    getChangedActiveModel,
-    changeActiveModel,
+    setSessionModel,
+    resolveSessionModel,
     resolveResumeModel,
     clearCache,
   };

package/server/modules/providers/services/provider-runtime.service.ts

@@ -0,0 +1,109 @@
+import { providerRegistry } from '@/modules/providers/provider.registry.js';
+import { providerModelsService } from '@/modules/providers/services/provider-models.service.js';
+import { sessionsService } from '@/modules/providers/services/sessions.service.js';
+import type { IProvider } from '@/shared/interfaces.js';
+import type {
+  AnyRecord,
+  LLMProvider,
+  ProviderPermissionDecision,
+  ProviderRunFunction,
+  ProviderRuntimeContext,
+  ProviderRuntimeWriter,
+} from '@/shared/types.js';
+
+type ProviderRuntimeServiceDependencies = {
+  listProviders(): IProvider[];
+  resolveProvider(provider: string): IProvider;
+  resolveProviderSessionId(sessionId: string | null | undefined): string | null;
+  resolveResumeModel(
+    provider: LLMProvider,
+    sessionId: string | undefined,
+    requestedModel?: string | null,
+  ): Promise<string | undefined>;
+  getProviderModels: typeof providerModelsService.getProviderModels;
+};
+
+const defaultDependencies: ProviderRuntimeServiceDependencies = {
+  listProviders: () => providerRegistry.listProviders(),
+  resolveProvider: (provider) => providerRegistry.resolveProvider(provider),
+  resolveProviderSessionId: (sessionId) => sessionsService.resolveProviderSessionId(sessionId),
+  resolveResumeModel: (provider, sessionId, requestedModel) =>
+    providerModelsService.resolveResumeModel(provider, sessionId, requestedModel),
+  getProviderModels: (provider, options) => providerModelsService.getProviderModels(provider, options),
+};
+
+/**
+ * Creates the application-facing provider runtime dispatcher.
+ *
+ * The provider registry owns each concrete runtime. This service supplies the
+ * registry-backed model/session lookups at execution time so runtime adapters
+ * never import services that resolve back through the registry.
+ */
+export function createProviderRuntimeService(
+  dependencyOverrides: Partial<ProviderRuntimeServiceDependencies> = {},
+) {
+  const dependencies = { ...defaultDependencies, ...dependencyOverrides };
+
+  const createRuntimeContext = (
+    provider: IProvider,
+  ): ProviderRuntimeContext => ({
+    resolveProviderSessionId: dependencies.resolveProviderSessionId,
+    resolveResumeModel: (sessionId, requestedModel) =>
+      dependencies.resolveResumeModel(provider.id, sessionId, requestedModel),
+    getProviderModels: async () =>
+      (await dependencies.getProviderModels(provider.id)).models,
+    normalizeMessage: (raw, sessionId) => provider.sessions.normalizeMessage(raw, sessionId),
+    async isProviderInstalled() {
+      try {
+        return (await provider.auth.getStatus()).installed;
+      } catch {
+        // Preserve the runtime's original error when installation probing fails.
+        return true;
+      }
+    },
+  });
+
+  const run = (
+    providerName: LLMProvider,
+    command: string,
+    options: AnyRecord,
+    writer: ProviderRuntimeWriter,
+  ): Promise<unknown> => {
+    const provider = dependencies.resolveProvider(providerName);
+    return provider.runtime.run(command, options, writer, createRuntimeContext(provider));
+  };
+
+  return {
+    run,
+
+    hasRuntime(providerName: string): boolean {
+      try {
+        return Boolean(dependencies.resolveProvider(providerName).runtime);
+      } catch {
+        return false;
+      }
+    },
+
+    getRunner(provider: LLMProvider): ProviderRunFunction {
+      return (command, options, writer) => run(provider, command, options, writer);
+    },
+
+    async abort(providerName: LLMProvider, sessionId: string): Promise<boolean> {
+      return Boolean(await dependencies.resolveProvider(providerName).runtime.abort(sessionId));
+    },
+
+    resolveToolApproval(requestId: string, decision: ProviderPermissionDecision): void {
+      for (const provider of dependencies.listProviders()) {
+        provider.runtime.permissions?.resolve(requestId, decision);
+      }
+    },
+
+    getPendingApprovalsForSession(sessionId: string): unknown[] {
+      return dependencies.listProviders().flatMap(
+        (provider) => provider.runtime.permissions?.listPending(sessionId) ?? [],
+      );
+    },
+  };
+}
+
+export const providerRuntimeService = createProviderRuntimeService();