@playcraft/cli 0.1.15 → 0.1.17

package/dist/workspace-runtime/codex/app-server.js

@@ -1,9 +1,10 @@
 import { spawn } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
 import { startLauncherProcess } from './launcher-client.js';
-import { readFile } from 'node:fs/promises';
+import { chmod, mkdtemp, rm } from 'node:fs/promises';
 import { join } from 'node:path';
-import { writePlaycraftCodexConfig } from './config-toml.js';
+import { tmpdir } from 'node:os';
+import { portableCodexConfig, writePortableCodexCatalog } from './config-toml.js';
 import { createJsonRpcStdioClient } from './jsonrpc-stdio.js';
 import { projectNativeThread } from '@playcraft/common/cloud-workspace/runtime';
 import { collectedEvent, NativePreparationError } from './native-adapter.js';
@@ -38,18 +39,6 @@ function spawnCommand(bin) {
     }
     return { command: bin, prefix: [] };
 }
-async function readToken(options) {
-    if (options.token?.trim())
-        return options.token.trim();
-    const fromEnv = process.env.PLAYCRAFT_MODEL_PROXY_TOKEN?.trim() || process.env.OPENAI_API_KEY?.trim() || '';
-    if (fromEnv)
-        return fromEnv;
-    const tokenFile = options.tokenFile || process.env.PLAYCRAFT_MODEL_PROXY_TOKEN_FILE;
-    if (tokenFile) {
-        return (await readFile(tokenFile, 'utf8')).trim();
-    }
-    throw new Error('model_proxy_token_missing');
-}
 export function createCodexAppServerAdapter(options) {
     const launcherSocket = options.launcherSocket || process.env.PLAYCRAFT_LAUNCHER_SOCKET;
     const homeDir = options.homeDir || process.env.PLAYCRAFT_CODEX_HOME ||
@@ -64,6 +53,7 @@ export function createCodexAppServerAdapter(options) {
     let readyFlag = false;
     let closed = false;
     let startPromise;
+    let catalogDirectory;
     let skillsRestartFailed = false;
     let preparationQueue = Promise.resolve();
     let live;
@@ -107,24 +97,25 @@ export function createCodexAppServerAdapter(options) {
         startPromise ??= start();
         await startPromise;
     }
-    async function threadConfig(cwd) {
+    async function threadConfig(cwd, modelConfigId, sessionId) {
         try {
-            return await options.modelBroker?.threadConfig(cwd) ?? {};
+            return await options.modelBroker?.prepareThreadConfig(cwd, modelConfigId, sessionId)
+                ?? { modelConfigId: undefined, activate: () => { } };
         }
         catch (error) {
             const reason = error instanceof Error ? error.message : '';
-            throw new NativePreparationError(['model_config_required', 'model_callback_insecure',
-                'model_credential_scope_mismatch', 'workspace_not_registered'].includes(reason)
+            throw new NativePreparationError(['model_config_required',
+                'model_credential_scope_mismatch', 'model_config_denied', 'workspace_not_registered'].includes(reason)
                 ? reason : 'model_credential_unavailable');
         }
     }
-    async function lockedThreadConfig(cwd) {
-        const modelConfig = await threadConfig(cwd);
+    async function lockedThreadConfig(cwd, selectedConfigId, sessionId) {
+        const { modelConfigId, activate, ...modelConfig } = await threadConfig(cwd, selectedConfigId, sessionId);
         // Single-workspace legacy runners retain their prior behaviour until explicitly adopted.
         if (await readProjectSkillsLockFile(cwd) === null) {
             if (options.config.workspaceMode === 'multi')
                 throw new NativePreparationError('workspace_skills_unavailable');
-            return { params: modelConfig, skillsHash: undefined, discoveryHash: undefined };
+            return { params: modelConfig, modelConfigId, activate, skillsHash: undefined, discoveryHash: undefined };
         }
         try {
             const frozen = await freezeWorkspaceSkills(cwd, join(options.config.stateDir, 'skill-artifacts'), options.loadSkillArtifact ? entry => options.loadSkillArtifact(cwd, entry) : undefined);
@@ -145,13 +136,13 @@ export function createCodexAppServerAdapter(options) {
                 ...(frozen.skills.length ? [] : ['(No workspace skills are enabled.)']),
             ].join('\n');
             const discoveryHash = createHash('sha256').update(JSON.stringify(listing.skills.map(skill => skill.path).sort())).digest('hex');
-            return { params: { ...modelConfig, config, developerInstructions }, skillsHash: frozen.lockHash, discoveryHash };
+            return { params: { ...modelConfig, config, developerInstructions }, modelConfigId, activate, skillsHash: frozen.lockHash, discoveryHash };
         }
         catch {
             throw new NativePreparationError('workspace_skills_unavailable');
         }
     }
-    async function restartForSkills(threadId) {
+    async function restartForSkills(threadId, selectedConfigId) {
         if ([...threads.values()].some(thread => thread.turnActive) || approvals.size)
             throw new NativePreparationError('skills_reload_pending');
         const previous = live;
@@ -182,7 +173,7 @@ export function createCodexAppServerAdapter(options) {
             // Other workspaces resume lazily, so a damaged unrelated lock cannot block this workspace.
             const thread = threads.get(threadId);
             if (thread?.hasNativeHistory && thread.cwd)
-                await resumePreparedThread(threadId, thread, await lockedThreadConfig(thread.cwd));
+                await resumePreparedThread(threadId, thread, await lockedThreadConfig(thread.cwd, selectedConfigId ?? thread.modelConfigId, thread.sessionId));
         }
         catch {
             readyFlag = false;
@@ -209,24 +200,33 @@ export function createCodexAppServerAdapter(options) {
         if (closed)
             throw new Error('codex_not_started');
         await options.modelBroker?.start();
-        const token = options.modelBroker ? 'workspace-broker-managed' : await readToken(options);
         if (closed)
             throw new Error('codex_not_started');
         const bin = options.command || process.env.PLAYCRAFT_CODEX_BIN || (launcherSocket ? '/usr/local/bin/codex' : 'codex');
         const { command, prefix } = spawnCommand(bin);
+        const launchArgs = [...prefix, ...(options.args ?? ['app-server'])];
+        const catalogArgs = launchArgs.at(-1) === 'app-server' ? launchArgs.slice(0, -1) : launchArgs;
+        let catalogPath;
+        try {
+            // Only public model metadata is shared with the development identity.
+            // A private, control-owned directory keeps it outside writable project files.
+            catalogDirectory ??= await mkdtemp(join(tmpdir(), 'playcraft-codex-catalog-'));
+            await chmod(catalogDirectory, 0o755);
+            catalogPath = await writePortableCodexCatalog({ directory: catalogDirectory, command, args: catalogArgs });
+        }
+        catch {
+            throw new NativePreparationError('codex_model_catalog_unavailable');
+        }
+        if (closed)
+            throw new Error('codex_not_started');
         const args = [...prefix, ...(options.args ?? ['app-server'])];
         if (launcherSocket) {
-            // Configuration travels as non-secret overrides: control cannot write dev's home.
+            // Thread model access comes from the broker. These overrides carry no proxy address or token.
             for (const [key, value] of Object.entries({
                 model,
-                model_provider: 'playcraft',
                 approval_policy: 'never',
                 sandbox_mode: 'danger-full-access',
-                'model_providers.playcraft.name': 'PlayCraft Model Proxy',
-                'model_providers.playcraft.base_url': options.config.modelProxyUrl.replace(/\/+$/, ''),
-                'model_providers.playcraft.env_key': 'OPENAI_API_KEY',
-                'model_providers.playcraft.wire_api': 'responses',
-                'model_providers.playcraft.requires_openai_auth': false,
+                ...portableCodexConfig(catalogPath),
             }))
                 args.push('-c', `${key}=${JSON.stringify(value)}`);
             child = await startLauncherProcess({
@@ -237,16 +237,15 @@ export function createCodexAppServerAdapter(options) {
                 // The launcher admits the dev home, not the shared /workspaces root.
                 // Each thread supplies its registered workspace separately.
                 cwd: options.config.workspaceMode === 'multi' ? '/home/playcraft-dev' : options.config.workspaceRoot,
-                env: { CODEX_HOME: homeDir, OPENAI_API_KEY: token },
+                env: { CODEX_HOME: homeDir },
             });
         }
         else {
-            await writePlaycraftCodexConfig({ homeDir, modelProxyUrl: options.config.modelProxyUrl, model });
             if (closed)
                 throw new Error('codex_not_started');
             const local = spawn(command, args, {
                 cwd: options.config.workspaceRoot,
-                env: { ...process.env, ...options.env, CODEX_HOME: homeDir, OPENAI_API_KEY: token, PLAYCRAFT_SKIP_UPDATE_CHECK: '1' },
+                env: { ...process.env, ...options.env, CODEX_HOME: homeDir, PLAYCRAFT_SKIP_UPDATE_CHECK: '1' },
                 stdio: ['pipe', 'pipe', 'pipe'],
             });
             await new Promise((resolve, reject) => { local.once('spawn', resolve); local.once('error', reject); });
@@ -389,18 +388,21 @@ export function createCodexAppServerAdapter(options) {
                 if (!rpc)
                     return false;
                 try {
-                    const prepared = await lockedThreadConfig(input.cwd ?? '');
                     const existing = threads.get(input.threadId);
                     if (existing && existing.sessionId !== input.sessionId)
                         return false;
+                    if (existing?.turnActive)
+                        return false;
+                    const prepared = await lockedThreadConfig(input.cwd ?? '', input.modelConfigId, input.sessionId);
                     if (existing?.needsRecreate)
                         return false;
                     if (existing?.loaded) {
                         if (existing.skillsHash !== prepared.skillsHash || existing.discoveryHash !== prepared.discoveryHash) {
                             if (!existing.hasNativeHistory)
                                 return false;
-                            await restartForSkills(input.threadId);
+                            await restartForSkills(input.threadId, prepared.modelConfigId);
                         }
+                        prepared.activate();
                         return threads.get(input.threadId)?.sessionId === input.sessionId;
                     }
                     const result = await rpc.request('thread/resume', { threadId: input.threadId, cwd: input.cwd,
@@ -408,8 +410,9 @@ export function createCodexAppServerAdapter(options) {
                     const resumedId = result.thread?.id ?? result.threadId;
                     if (resumedId !== input.threadId)
                         return false;
+                    prepared.activate();
                     threads.set(input.threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
-                        discoveryHash: prepared.discoveryHash, hasNativeHistory: true, loaded: true });
+                        discoveryHash: prepared.discoveryHash, modelConfigId: prepared.modelConfigId, hasNativeHistory: true, loaded: true });
                     return true;
                 }
                 catch {
@@ -452,7 +455,7 @@ export function createCodexAppServerAdapter(options) {
                 await ensureStarted();
                 if (!rpc)
                     throw new Error('codex_not_started');
-                const prepared = await lockedThreadConfig(input.cwd);
+                const prepared = await lockedThreadConfig(input.cwd, input.modelConfigId, input.sessionId);
                 const result = await rpc.request('thread/start', {
                     cwd: input.cwd,
                     model,
@@ -461,9 +464,10 @@ export function createCodexAppServerAdapter(options) {
                 const threadId = result.thread?.id;
                 if (!threadId)
                     throw new Error('native_receipt_lost');
+                prepared.activate();
                 threads.set(threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
-                    discoveryHash: prepared.discoveryHash, hasNativeHistory: false, loaded: true });
-                return { threadId };
+                    discoveryHash: prepared.discoveryHash, modelConfigId: prepared.modelConfigId, hasNativeHistory: false, loaded: true });
+                return { threadId, modelConfigId: prepared.modelConfigId };
             });
         },
         async startTurn(input) {
@@ -475,18 +479,26 @@ export function createCodexAppServerAdapter(options) {
                     return { outcome: 'failed', error: 'unknown_thread' };
                 }
                 const thread = threads.get(input.threadId);
+                if (thread.turnActive)
+                    return { outcome: 'failed', error: 'turn_already_active' };
                 if (thread.needsRecreate)
                     return { outcome: 'failed', error: 'workspace_skills_changed' };
-                if (thread.skillsHash && thread.cwd) {
+                let selectedModel;
+                let modelConfigId = thread.modelConfigId;
+                let activateModel = () => { };
+                if (thread.cwd) {
                     try {
-                        const prepared = await lockedThreadConfig(thread.cwd);
+                        const prepared = await lockedThreadConfig(thread.cwd, input.modelConfigId ?? thread.modelConfigId, input.sessionId);
+                        selectedModel = 'model' in prepared.params ? prepared.params.model : undefined;
+                        modelConfigId = prepared.modelConfigId;
+                        activateModel = prepared.activate;
                         // Codex does not persist an empty thread rollout until its first turn.
-                        if (!thread.hasNativeHistory) {
+                        if (thread.skillsHash && !thread.hasNativeHistory) {
                             if (prepared.skillsHash !== thread.skillsHash || prepared.discoveryHash !== thread.discoveryHash)
                                 return { outcome: 'failed', error: 'workspace_skills_changed' };
                         }
-                        else if (prepared.skillsHash !== thread.skillsHash || prepared.discoveryHash !== thread.discoveryHash) {
-                            await restartForSkills(input.threadId);
+                        else if (thread.skillsHash && (prepared.skillsHash !== thread.skillsHash || prepared.discoveryHash !== thread.discoveryHash)) {
+                            await restartForSkills(input.threadId, prepared.modelConfigId);
                         }
                         if (!thread.loaded)
                             await resumePreparedThread(input.threadId, thread, prepared);
@@ -498,7 +510,9 @@ export function createCodexAppServerAdapter(options) {
                     }
                 }
                 const requestId = rpc.reserveRequest();
-                await input.persistReservation({ nativeRequestId: String(requestId) });
+                await input.persistReservation({ nativeRequestId: String(requestId), modelConfigId });
+                activateModel();
+                thread.modelConfigId = modelConfigId;
                 if (input.simulateLostReceipt)
                     return { outcome: 'uncertain', threadId: input.threadId };
                 try {
@@ -506,7 +520,7 @@ export function createCodexAppServerAdapter(options) {
                     const started = await rpc.sendReserved(requestId, 'turn/start', { threadId: input.threadId, input: [
                             { type: 'text', text: input.text },
                             ...(input.images ?? []).map((path) => ({ type: 'localImage', path })),
-                        ] }, turnTimeoutMs);
+                        ], ...(selectedModel ? { model: selectedModel } : {}) }, turnTimeoutMs);
                     const turnId = started.turn?.id;
                     if (!turnId)
                         return { outcome: 'uncertain', threadId: input.threadId };
@@ -514,9 +528,10 @@ export function createCodexAppServerAdapter(options) {
                     if (acceptedThread) {
                         acceptedThread.lastTurnId = turnId;
                         acceptedThread.hasNativeHistory = true;
+                        acceptedThread.modelConfigId = modelConfigId;
                         acceptedThread.turnActive = acceptedThread.lastCompletedTurnId !== turnId;
                     }
-                    return { outcome: 'accepted', threadId: input.threadId, turnId };
+                    return { outcome: 'accepted', threadId: input.threadId, turnId, modelConfigId };
                 }
                 catch {
                     return { outcome: 'uncertain', threadId: input.threadId };
@@ -534,6 +549,9 @@ export function createCodexAppServerAdapter(options) {
                 return { outcome: 'uncertain' };
             try {
                 await rpc.request('turn/interrupt', { threadId: input.threadId, turnId });
+                const cwd = threads.get(input.threadId)?.cwd;
+                if (cwd)
+                    options.modelBroker?.cancelSession(cwd, input.sessionId);
             }
             catch {
                 return { outcome: 'uncertain', turnId };
@@ -573,6 +591,8 @@ export function createCodexAppServerAdapter(options) {
             child = undefined;
             live = undefined;
             await options.modelBroker?.close();
+            if (catalogDirectory)
+                await rm(catalogDirectory, { recursive: true, force: true });
         },
     };
 }

package/dist/workspace-runtime/codex/config-toml.js

@@ -1,8 +1,90 @@
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { promisify } from 'node:util';
+const exec = promisify(execFile);
 function tomlString(value) {
     return JSON.stringify(value);
 }
+/** Keep workspace turns portable between native Responses and function-tool conversion. */
+export function portableCodexConfig(catalogPath) {
+    return {
+        web_search: 'disabled',
+        'features.multi_agent': false,
+        'features.goals': false,
+        'features.apps': false,
+        'features.plugins': false,
+        'features.code_mode': false,
+        'features.code_mode_host': false,
+        'features.code_mode_only': false,
+        model_reasoning_summary: 'none',
+        ...(catalogPath ? { model_catalog_json: catalogPath } : {}),
+    };
+}
+/** Retain real model identities and limits while declaring this gateway's portable tools. */
+export function portableCodexCatalog(raw) {
+    if (!raw ||
+        typeof raw !== 'object' ||
+        Array.isArray(raw) ||
+        !Array.isArray(raw.models)) {
+        throw new Error('codex_model_catalog_invalid');
+    }
+    const catalog = raw;
+    const models = catalog.models.map((value) => {
+        if (!value ||
+            typeof value !== 'object' ||
+            Array.isArray(value) ||
+            typeof value.slug !== 'string') {
+            throw new Error('codex_model_catalog_invalid');
+        }
+        return {
+            ...value,
+            tool_mode: null,
+            use_responses_lite: false,
+            apply_patch_tool_type: null,
+            multi_agent_version: null,
+            supports_search_tool: false,
+            experimental_supported_tools: [],
+            default_reasoning_level: null,
+            supported_reasoning_levels: [],
+        };
+    });
+    return { ...catalog, models };
+}
+/** The installed binary supplies its own schema; unsupported binaries fail before inference. */
+export async function writePortableCodexCatalog(input) {
+    const command = input.command || process.env.PLAYCRAFT_CODEX_BIN || 'codex';
+    const prefix = input.args ?? [];
+    let body;
+    let version;
+    try {
+        const bundled = await exec(command, [...prefix, 'debug', 'models', '--bundled'], {
+            encoding: 'utf8',
+            timeout: 10_000,
+            maxBuffer: 16 * 1024 * 1024,
+        });
+        const metadata = await exec(command, [...prefix, '--version'], {
+            encoding: 'utf8',
+            timeout: 10_000,
+            maxBuffer: 64 * 1024,
+        });
+        version = metadata.stdout.trim();
+        body = JSON.stringify(portableCodexCatalog(JSON.parse(bundled.stdout)));
+    }
+    catch {
+        // Continuing with an unverified catalog can silently remove every coding tool.
+        throw new Error('codex_model_catalog_unavailable');
+    }
+    await mkdir(input.directory, { recursive: true });
+    const path = join(input.directory, 'portable-models.json');
+    await writeFile(path, body, { encoding: 'utf8', mode: 0o644 });
+    await writeFile(join(input.directory, 'portable-models.version.json'), JSON.stringify({
+        version,
+        sha256: createHash('sha256').update(body).digest('hex'),
+    }), { encoding: 'utf8', mode: 0o644 });
+    return path;
+}
 export async function writePlaycraftCodexConfig(input) {
     await mkdir(input.homeDir, { recursive: true, mode: 0o700 });
     const path = join(input.homeDir, 'config.toml');
@@ -11,6 +93,7 @@ export async function writePlaycraftCodexConfig(input) {
         'model_provider = "playcraft"',
         'approval_policy = "never"',
         'sandbox_mode = "danger-full-access"',
+        ...Object.entries(portableCodexConfig(input.catalogPath)).map(([key, value]) => `${key} = ${JSON.stringify(value)}`),
         '',
         '[model_providers.playcraft]',
         'name = "PlayCraft Model Proxy"',

package/dist/workspace-runtime/codex/model-broker.js

@@ -1,10 +1,11 @@
-import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
 import { createServer } from 'node:http';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { basename } from 'node:path';
 import { z } from 'zod';
 import { workspaceRoot } from '../workspaces/registry.js';
+import { PLATFORM_ROUTES, modelResponsesPath, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
 const credentialSchema = z.object({
     token: z.string().min(1), expiresAt: z.string().datetime(),
     configId: z.string().uuid(), model: z.string().min(1).max(128),
@@ -19,8 +20,10 @@ export class WorkspaceModelBroker {
     server;
     baseUrl = '';
     entries = new Map();
+    routes = new Map();
     pending = new Map();
     requests = new Set();
+    sessionRequests = new Map();
     constructor(state) {
         this.state = state;
     }
@@ -40,24 +43,47 @@ export class WorkspaceModelBroker {
             throw new Error('model_broker_unavailable');
         this.baseUrl = `http://127.0.0.1:${address.port}`;
     }
-    async threadConfig(cwd) {
+    async threadConfig(cwd, modelConfigId, sessionId) {
+        const { activate, ...settings } = await this.prepareThreadConfig(cwd, modelConfigId, sessionId);
+        activate();
+        return settings;
+    }
+    async prepareThreadConfig(cwd, modelConfigId, sessionId) {
         const workspaceId = basename(cwd);
         if (!this.server || await workspaceRoot(this.state, workspaceId) !== cwd)
             throw new Error('workspace_not_registered');
-        let entry = this.entries.get(workspaceId);
+        if (modelConfigId !== undefined && !z.string().uuid().safeParse(modelConfigId).success)
+            throw new Error('model_config_denied');
+        const routeKey = sessionId ? `${workspaceId}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}` : workspaceId;
+        let route = this.routes.get(routeKey);
+        const selected = modelConfigId ?? (route?.epoch === this.state.runtimeEpoch ? route.selected?.entry.modelConfigId : undefined);
+        const cacheKey = `${workspaceId}:${selected ?? 'default'}`;
+        let entry = this.entries.get(cacheKey) ?? [...this.entries.values()].find(item => item.workspaceId === workspaceId && item.epoch === this.state.runtimeEpoch && item.modelConfigId === selected);
         if (!entry || entry.epoch !== this.state.runtimeEpoch) {
-            entry = { workspaceId, epoch: this.state.runtimeEpoch, capability: randomBytes(32).toString('base64url') };
-            this.entries.set(workspaceId, entry);
+            entry = { workspaceId, epoch: this.state.runtimeEpoch, cacheKey, modelConfigId: selected };
+            this.entries.set(cacheKey, entry);
+        }
+        // Resolve current model metadata and permission at every native turn boundary.
+        const credential = await this.credential(entry, true);
+        if (!route || route.epoch !== this.state.runtimeEpoch) {
+            route = { workspaceId, epoch: this.state.runtimeEpoch, capability: randomBytes(32).toString('base64url') };
+            this.routes.set(routeKey, route);
         }
-        const credential = await this.credential(entry);
+        // Each session pins its prepared model; shared credential renewal cannot change an active turn.
         return {
+            activate: () => {
+                if (!this.valid(entry) || this.routes.get(routeKey) !== route)
+                    throw new Error('model_access_denied');
+                route.selected = { entry, model: credential.model };
+            },
             model: credential.model,
+            modelConfigId: credential.configId,
             modelProvider: 'playcraft_workspace',
             config: {
                 'model_providers.playcraft_workspace': {
-                    name: 'PlayCraft Workspace', base_url: `${this.baseUrl}/${workspaceId}`,
+                    name: 'PlayCraft Workspace', base_url: `${this.baseUrl}/${routeKey}`,
                     wire_api: 'responses', requires_openai_auth: false,
-                    http_headers: { Authorization: `Bearer ${entry.capability}` },
+                    http_headers: { Authorization: `Bearer ${route.capability}` },
                 },
             },
         };
@@ -65,12 +91,12 @@ export class WorkspaceModelBroker {
     valid(entry) {
         return Boolean(this.server && !this.state.journal.destroyed()
             && this.state.runtimeEpoch === entry.epoch && this.state.journal.getWorkspace(entry.workspaceId)
-            && this.entries.get(entry.workspaceId) === entry);
+            && this.entries.get(entry.cacheKey) === entry);
     }
-    async credential(entry) {
+    async credential(entry, refresh = false) {
         if (!this.valid(entry))
             throw new Error('model_access_denied');
-        if (entry.credential && Date.parse(entry.credential.expiresAt) > Date.now() + 60_000)
+        if (!refresh && entry.credential && Date.parse(entry.credential.expiresAt) > Date.now() + 60_000)
             return entry.credential;
         let pending = this.pending.get(entry);
         if (!pending) {
@@ -81,46 +107,54 @@ export class WorkspaceModelBroker {
     }
     async renew(entry) {
         const config = this.state.config;
-        const endpoint = new URL('/runtime/internal/model-credentials', config.callbackUrl);
-        if (endpoint.protocol !== 'https:' && !(endpoint.protocol === 'http:'
-            && ['127.0.0.1', 'localhost', '[::1]'].includes(endpoint.hostname)))
-            throw new Error('model_callback_insecure');
+        const endpoint = platformEndpoint(config.publicBaseUrl, PLATFORM_ROUTES.modelCredentials);
         const response = await fetch(endpoint, {
             method: 'POST', redirect: 'error', signal: AbortSignal.timeout(10_000),
             headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
             body: JSON.stringify({ runtimeId: config.runtimeId, generation: config.generation,
-                runtimeEpoch: entry.epoch, workspaceId: entry.workspaceId }),
+                runtimeEpoch: entry.epoch, workspaceId: entry.workspaceId,
+                ...(entry.modelConfigId ? { modelConfigId: entry.modelConfigId } : {}) }),
         });
         if (!response.ok) {
             const error = await response.json().catch(() => ({}));
-            throw new Error(error.reason === 'model_config_required' ? 'model_config_required' : 'model_credential_unavailable');
+            throw new Error(['model_config_required', 'model_config_denied'].includes(error.reason ?? '') ? error.reason : 'model_credential_unavailable');
         }
         const credential = credentialSchema.parse(await response.json());
         const claims = credential.claims;
         if (!this.valid(entry) || claims.workspaceId !== entry.workspaceId || claims.runtimeId !== config.runtimeId
             || claims.userId !== config.userId || claims.environment !== config.environment
             || claims.generation !== config.generation || claims.runtimeEpoch !== entry.epoch
+            || (entry.modelConfigId !== undefined && credential.configId !== entry.modelConfigId)
             || Date.parse(credential.expiresAt) <= Date.now() + 1000)
             throw new Error('model_credential_scope_mismatch');
+        entry.modelConfigId = credential.configId;
         entry.credential = credential;
         return credential;
     }
     async forward(request, response) {
         const abort = new AbortController();
         this.requests.add(abort);
+        let activeRoute;
         const cancel = () => abort.abort();
         response.once('close', cancel);
         try {
-            const match = /^\/([0-9a-f-]{36})\/responses$/.exec(request.url ?? '');
-            const entry = match && this.entries.get(match[1]);
+            const match = /^\/([0-9a-f-]{36}(?:\/[0-9a-f]{32})?)\/responses$/.exec(request.url ?? '');
+            const route = match ? this.routes.get(match[1]) : undefined;
+            const selected = route?.selected;
+            const entry = selected?.entry;
             const presented = Buffer.from(request.headers.authorization ?? '');
-            const expected = Buffer.from(entry ? `Bearer ${entry.capability}` : '');
+            const expected = Buffer.from(route ? `Bearer ${route.capability}` : '');
             if (request.method !== 'POST' || !entry || !expected.length || presented.length !== expected.length
                 || !timingSafeEqual(presented, expected) || !this.valid(entry)) {
                 response.writeHead(403);
                 response.end();
                 return;
             }
+            activeRoute = route;
+            const active = this.sessionRequests.get(route) ?? new Set();
+            active.add(abort);
+            this.sessionRequests.set(route, active);
+            const credential = await this.credential(entry);
             const chunks = [];
             let size = 0;
             for await (const chunk of request) {
@@ -132,15 +166,22 @@ export class WorkspaceModelBroker {
                 }
                 chunks.push(Buffer.from(chunk));
             }
-            const credential = await this.credential(entry);
             if (!this.valid(entry))
                 throw new Error('model_access_denied');
+            const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            if (!body || typeof body !== 'object' || Array.isArray(body)) {
+                response.writeHead(400);
+                response.end();
+                return;
+            }
+            // The browser selects a configuration, never an arbitrary billable upstream model.
+            body.model = selected.model;
             const expires = setTimeout(cancel, Math.max(0, Date.parse(credential.expiresAt) - Date.now()));
             try {
-                const upstream = await fetch(`${this.state.config.modelProxyUrl.replace(/\/+$/, '')}/v1/${credential.configId}/responses`, {
+                const upstream = await fetch(platformEndpoint(this.state.config.publicBaseUrl, modelResponsesPath(credential.configId)), {
                     method: 'POST', redirect: 'error', signal: abort.signal,
                     headers: { authorization: `Bearer ${credential.token}`, 'content-type': 'application/json' },
-                    body: Buffer.concat(chunks),
+                    body: JSON.stringify(body),
                 });
                 if (upstream.status === 401 || upstream.status === 403)
                     entry.credential = undefined;
@@ -167,12 +208,27 @@ export class WorkspaceModelBroker {
         finally {
             response.off('close', cancel);
             this.requests.delete(abort);
+            if (activeRoute) {
+                const active = this.sessionRequests.get(activeRoute);
+                active?.delete(abort);
+                if (!active?.size)
+                    this.sessionRequests.delete(activeRoute);
+            }
         }
     }
+    cancelSession(cwd, sessionId) {
+        const routeKey = `${basename(cwd)}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}`;
+        const route = this.routes.get(routeKey);
+        if (route)
+            for (const request of this.sessionRequests.get(route) ?? [])
+                request.abort();
+    }
     async close() {
         const server = this.server;
         this.server = undefined;
         this.entries.clear();
+        this.routes.clear();
+        this.sessionRequests.clear();
         for (const request of this.requests)
             request.abort();
         if (server) {

package/dist/workspace-runtime/previews/publish.js

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 import { spawn } from 'node:child_process';
+import { platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
 import { constants } from 'node:fs';
 import { lstat, open, readdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -222,10 +223,7 @@ function git(cwd, args) {
     });
 }
 async function postControl(state, path, body) {
-    const endpoint = new URL(path, state.config.callbackUrl);
-    const local = endpoint.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(endpoint.hostname);
-    if (endpoint.protocol !== 'https:' && !local)
-        throw new PreviewFailure('preview_upload_failed');
+    const endpoint = platformEndpoint(state.config.publicBaseUrl, path);
     const response = await fetch(endpoint, {
         method: 'POST',
         redirect: 'error',

package/dist/workspace-runtime/serve.js

@@ -96,7 +96,7 @@ export async function startWorkspaceRuntime(config, options = {}) {
         }
         catch (error) {
             const code = error instanceof Error ? error.message : '';
-            state.nativeError = code === 'model_proxy_token_missing' ? code : 'codex_start_failed';
+            state.nativeError = code === 'codex_model_catalog_unavailable' ? code : 'codex_start_failed';
             console.error(`[workspace-runtime] ${state.nativeError}`);
         }
         const server = createServer((request, response) => {
@@ -180,11 +180,15 @@ function defaultNativeAdapter(state) {
     const config = state.config;
     if (process.env.PLAYCRAFT_NATIVE_ADAPTER === 'loopback')
         return createLoopbackNativeAdapter();
-    const managed = config.workspaceMode === 'multi' && Boolean(process.env.PLAYCRAFT_LAUNCHER_SOCKET);
-    if (process.env.PLAYCRAFT_NATIVE_ADAPTER === 'codex'
-        || (!process.env.PLAYCRAFT_NATIVE_ADAPTER && managed)) {
-        return createCodexAppServerAdapter({ config,
-            ...(managed ? { modelBroker: new WorkspaceModelBroker(state) } : {}),
+    const hasLauncher = Boolean(process.env.PLAYCRAFT_LAUNCHER_SOCKET);
+    const multi = config.workspaceMode === 'multi';
+    if (process.env.PLAYCRAFT_NATIVE_ADAPTER === 'codex' && !multi && !hasLauncher) {
+        throw new Error('codex_requires_managed_launcher');
+    }
+    if (process.env.PLAYCRAFT_NATIVE_ADAPTER === 'codex' || (multi && hasLauncher)) {
+        return createCodexAppServerAdapter({
+            config,
+            ...(multi ? { modelBroker: new WorkspaceModelBroker(state) } : {}),
             loadSkillArtifact: async (cwd, entry) => {
                 const id = basename(cwd);
                 if (await workspaceRoot(state, id) !== cwd)