conductor-remote 1.129.0 → 1.130.1

package/dist-node/src/agents/auto-model/provider.js

@@ -0,0 +1,228 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { routerProvider } from "./config.js";
+import { ROUTER_INSTRUCTIONS } from "./decision.js";
+/** Picker labels and CLI IDs are distinct. Restrict routing to known label shapes. */
+export function codexRouterId(label) {
+    if (!/^(?:GPT-)?\d[\d.]*(?: (?:Luna|Terra|Sol|Astra))?$/.test(label))
+        throw new Error('Unsupported Codex router.');
+    return `gpt-${label.replace(/^GPT-/, '').toLowerCase().replaceAll(' ', '-')}`;
+}
+function codexBinary() {
+    const root = path.join(os.homedir(), 'Library/Application Support/com.conductor.app/agent-binaries/codex');
+    try {
+        for (const version of fs.readdirSync(root).sort((a, b) => b.localeCompare(a, undefined, { numeric: true }))) {
+            const file = path.join(root, version, 'codex');
+            try {
+                fs.accessSync(file, fs.constants.X_OK);
+                return file;
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return 'codex';
+}
+/** Build an isolated classifier invocation; no workspace instructions or editing tools. */
+export function routerCommand(router, prompt, images, directory) {
+    const provider = routerProvider(router);
+    if (provider === 'codex') {
+        const instructions = path.join(directory, 'instructions.txt');
+        const schema = path.join(directory, 'output-schema.json');
+        fs.writeFileSync(instructions, ROUTER_INSTRUCTIONS);
+        fs.writeFileSync(schema, JSON.stringify({
+            type: 'object',
+            additionalProperties: false,
+            required: ['profile', 'reason', 'missingContext'],
+            properties: { profile: { type: 'string' }, reason: { type: 'string' }, missingContext: { type: 'boolean' } }
+        }));
+        return {
+            binary: codexBinary(),
+            cwd: directory,
+            env: { ...process.env },
+            stdin: prompt,
+            args: [
+                'exec',
+                '--ephemeral',
+                '--ignore-user-config',
+                '--ignore-rules',
+                '--skip-git-repo-check',
+                '--sandbox',
+                'read-only',
+                '--json',
+                '--output-schema',
+                schema,
+                '-m',
+                codexRouterId(router.model),
+                '-c',
+                `model_instructions_file=${JSON.stringify(instructions)}`,
+                '-c',
+                'approval_policy="never"',
+                '-c',
+                'web_search="disabled"',
+                '-c',
+                'agents.enabled=false',
+                ...[
+                    'shell_tool',
+                    'apply_patch_freeform',
+                    'code_mode',
+                    'apps',
+                    'plugins',
+                    'hooks',
+                    'codex_hooks',
+                    'multi_agent',
+                    'multi_agent_v2',
+                    'browser_use',
+                    'computer_use',
+                    'image_generation',
+                    'memories'
+                ].flatMap(name => ['-c', `features.${name}=false`]),
+                '-c',
+                `model_reasoning_effort=${JSON.stringify(router.effort ?? 'low')}`,
+                '-c',
+                `service_tier=${JSON.stringify(router.fast ? 'priority' : 'default')}`,
+                ...images.flatMap(file => ['--image', file]),
+                '-'
+            ]
+        };
+    }
+    if (provider !== 'opencode')
+        throw new Error('Unsupported Auto router.');
+    const configDir = path.join(directory, 'config');
+    fs.mkdirSync(configDir);
+    const config = path.join(configDir, 'opencode.json');
+    fs.writeFileSync(config, JSON.stringify({
+        share: 'disabled',
+        autoupdate: false,
+        permission: { '*': 'deny' },
+        agent: {
+            'auto-model-router': {
+                description: 'Select a model profile',
+                mode: 'primary',
+                prompt: ROUTER_INSTRUCTIONS,
+                permission: { '*': 'deny' },
+                steps: 1
+            }
+        }
+    }));
+    return {
+        binary: 'opencode',
+        cwd: directory,
+        stdin: prompt,
+        env: {
+            ...process.env,
+            XDG_CONFIG_HOME: configDir,
+            OPENCODE_CONFIG: config,
+            OPENCODE_CONFIG_DIR: configDir,
+            OPENCODE_CONFIG_CONTENT: '{}',
+            OPENCODE_DISABLE_PROJECT_CONFIG: 'true',
+            OPENCODE_DISABLE_CLAUDE_CODE: 'true'
+        },
+        args: [
+            '--pure',
+            'run',
+            '--format',
+            'json',
+            '--model',
+            router.model,
+            '--agent',
+            'auto-model-router',
+            '--dir',
+            directory,
+            ...images.flatMap(file => ['--file', file])
+        ]
+    };
+}
+export function runRouterCommand(command, signal) {
+    return new Promise((resolve, reject) => {
+        signal.throwIfAborted();
+        const child = spawn(command.binary, command.args, {
+            cwd: command.cwd,
+            env: command.env,
+            detached: true,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let failure;
+        const stop = () => {
+            failure ??= new Error('Router cancelled or timed out.');
+            try {
+                if (child.pid)
+                    process.kill(-child.pid, 'SIGKILL');
+            }
+            catch { }
+        };
+        signal.addEventListener('abort', stop, { once: true });
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', chunk => {
+            stdout += chunk;
+            if (stdout.length > 512_000)
+                stop();
+        });
+        // Provider diagnostics can contain the prompt or authentication details.
+        child.stderr.resume();
+        child.stdin.on('error', () => undefined);
+        child.on('error', () => {
+            failure = new Error('The router CLI could not start.');
+        });
+        child.on('close', code => {
+            signal.removeEventListener('abort', stop);
+            if (failure || code !== 0)
+                reject(failure ?? new Error('The router CLI failed.'));
+            else
+                resolve(stdout);
+        });
+        child.stdin.end(command.stdin);
+    });
+}
+export function routerOutput(output, provider) {
+    const events = output
+        .split('\n')
+        .filter(line => line.trim())
+        .map(line => JSON.parse(line));
+    if (events.some(event => event.type === 'error' || event.type === 'turn.failed' || event.type === 'tool_use'))
+        throw new Error('Router failed.');
+    return events
+        .flatMap(event => {
+        if (provider === 'codex' && event.type === 'item.completed' && event.item?.type === 'agent_message')
+            return [event.item.text];
+        if (provider === 'opencode' && event.type === 'text' && event.part?.type === 'text')
+            return [event.part.text];
+        return [];
+    })
+        .join('');
+}
+/** Authentication stays owned by the installed CLIs; no credential files are read here. */
+export async function runRouter(router, prompt, images, signal) {
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'conductor-auto-model-'));
+    try {
+        const command = routerCommand(router, prompt, images, directory);
+        const output = await runRouterCommand(command, signal);
+        const provider = routerProvider(router);
+        if (!provider)
+            throw new Error('Unsupported router.');
+        if (provider === 'opencode') {
+            const sessionId = output
+                .split('\n')
+                .filter(Boolean)
+                .map(line => {
+                try {
+                    return JSON.parse(line).sessionID;
+                }
+                catch {
+                    return undefined;
+                }
+            })
+                .find(id => typeof id === 'string' && /^ses_[a-zA-Z0-9]+$/.test(id));
+            if (sessionId) {
+                await runRouterCommand({ ...command, args: ['--pure', 'session', 'delete', sessionId], stdin: '' }, AbortSignal.timeout(2000)).catch(() => undefined);
+            }
+        }
+        return routerOutput(output, provider);
+    }
+    finally {
+        fs.rmSync(directory, { recursive: true, force: true });
+    }
+}

package/dist-node/src/agents/auto-model/queue.js

@@ -0,0 +1,266 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { atomicJson } from "./config.js";
+const pending = (job) => ['selecting', 'waiting', 'failed'].includes(job.status);
+/** One durable file per target; a process lease also keeps dev and installed relays from routing twice. */
+export class AutoModelQueue {
+    running = false;
+    now;
+    directory;
+    deps;
+    constructor(directory, deps) {
+        this.directory = directory;
+        this.deps = deps;
+        this.now = deps.now ?? Date.now;
+        fs.mkdirSync(directory, { recursive: true });
+    }
+    file(job) {
+        return path.join(this.directory, `${job.id}.json`);
+    }
+    list() {
+        return fs
+            .readdirSync(this.directory)
+            .filter(name => /^[a-f0-9]{64}\.json$/.test(name))
+            .map(name => {
+            const job = JSON.parse(fs.readFileSync(path.join(this.directory, name), 'utf8'));
+            if (!job.id || !job.config || typeof job.text !== 'string')
+                throw new Error('An Auto submission could not be read.');
+            return job;
+        });
+    }
+    get(sessionId, workspaceId) {
+        return this.list().find(job => (sessionId && job.sessionId === sessionId) || (workspaceId && job.workspaceId === workspaceId && !job.sessionId));
+    }
+    state(sessionId, workspaceId) {
+        const job = this.get(sessionId, workspaceId);
+        return (job && { status: job.status, decision: job.status === 'cancelled' ? undefined : job.decision, error: job.error });
+    }
+    pending() {
+        return this.list()
+            .filter(pending)
+            .map(job => ({
+            workspaceId: job.workspaceId,
+            sessionId: job.sessionId,
+            text: job.text,
+            createdAt: job.createdAt,
+            status: job.status === 'failed' ? 'failed' : 'waiting',
+            attempts: job.attempts,
+            reason: job.reason,
+            error: job.error,
+            autoModel: true,
+            agent: job.decision && { model: job.decision.model, effort: job.decision.effort, fast: job.decision.fast }
+        }));
+    }
+    accept(input) {
+        const existing = this.get(input.sessionId, input.workspaceId);
+        if (existing && existing.status !== 'draft' && existing.status !== 'cancelled') {
+            if (existing.text !== input.text)
+                throw new Error('This chat already has an Auto submission. Dismiss it before sending another.');
+            if (existing.status === 'failed') {
+                existing.status = 'waiting';
+                existing.attempts = 0;
+                existing.earlyAttempts = 0;
+                existing.lastAttemptAt = undefined;
+                existing.error = undefined;
+                existing.reason = 'Retrying with the saved model choice';
+                this.save(existing);
+            }
+            return existing;
+        }
+        const job = {
+            ...input,
+            config: structuredClone(input.config),
+            id: existing?.id ??
+                crypto
+                    .createHash('sha256')
+                    .update(`${input.workspaceId}:${input.sessionId ?? 'first'}`)
+                    .digest('hex'),
+            attachmentIds: input.attachmentIds ?? [],
+            sendImmediately: input.sendImmediately !== false,
+            createdAt: Math.max(this.now(), (existing?.createdAt ?? 0) + 1),
+            attempts: 0,
+            earlyAttempts: 0,
+            status: input.text ? 'waiting' : 'draft',
+            reason: 'Choosing a model…'
+        };
+        if (existing)
+            this.save(job);
+        else {
+            try {
+                fs.writeFileSync(this.file(job), JSON.stringify(job), { flag: 'wx', mode: 0o600 });
+            }
+            catch (error) {
+                if (error.code === 'EEXIST')
+                    return this.accept(input);
+                throw error;
+            }
+        }
+        return job;
+    }
+    cancel(sessionId, workspaceId) {
+        const job = this.get(sessionId, workspaceId);
+        if (!job || !['draft', 'selecting', 'waiting', 'failed'].includes(job.status))
+            return false;
+        const lease = this.readLease(job);
+        if (lease?.dispatching && this.alive(lease.pid))
+            throw new Error('Auto is sending this prompt now. Wait for its receipt before dismissing it.');
+        job.status = 'cancelled';
+        job.reason = 'Auto cancelled';
+        this.save(job);
+        return true;
+    }
+    save(job) {
+        atomicJson(this.file(job), job);
+    }
+    current(job) {
+        const saved = JSON.parse(fs.readFileSync(this.file(job), 'utf8'));
+        return saved.createdAt === job.createdAt && saved.text === job.text && pending(saved) && saved.status !== 'failed';
+    }
+    alive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            return error.code !== 'ESRCH';
+        }
+    }
+    readLease(job) {
+        try {
+            return JSON.parse(fs.readFileSync(`${this.file(job)}.lock`, 'utf8'));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    lease(job) {
+        const existing = this.readLease(job);
+        if (existing) {
+            if (this.alive(existing.pid))
+                return false;
+            fs.rmSync(`${this.file(job)}.lock`, { force: true });
+        }
+        try {
+            fs.writeFileSync(`${this.file(job)}.lock`, JSON.stringify({ pid: process.pid, dispatching: false }), {
+                flag: 'wx',
+                mode: 0o600
+            });
+            return true;
+        }
+        catch (error) {
+            if (error.code === 'EEXIST')
+                return false;
+            throw error;
+        }
+    }
+    async tick() {
+        if (this.running)
+            return;
+        this.running = true;
+        try {
+            for (const candidate of this.list()) {
+                if (!pending(candidate) || candidate.status === 'failed' || !this.lease(candidate))
+                    continue;
+                const job = JSON.parse(fs.readFileSync(this.file(candidate), 'utf8'));
+                try {
+                    if (this.current(job))
+                        await this.step(job);
+                }
+                catch (error) {
+                    if (this.current(job)) {
+                        job.status = 'failed';
+                        job.error = error instanceof Error ? error.message : 'Auto could not deliver the prompt.';
+                        this.save(job);
+                    }
+                }
+                finally {
+                    fs.rmSync(`${this.file(job)}.lock`, { force: true });
+                }
+            }
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    async step(job) {
+        if (job.sessionId && job.cursor && this.deps.received(job)) {
+            job.status = 'delivered';
+            this.save(job);
+            return;
+        }
+        if (await this.deps.locked()) {
+            if (!this.current(job))
+                return;
+            job.reason = 'Waiting for the Mac to unlock';
+            job.lastAttemptAt = this.now();
+            this.save(job);
+            return;
+        }
+        if (!this.current(job))
+            return;
+        const target = this.deps.inspect(job);
+        if (target.obsolete) {
+            job.status = 'cancelled';
+            job.reason = 'The chat started before Auto could send.';
+            this.save(job);
+            return;
+        }
+        if (target.error)
+            throw new Error(target.error);
+        if (!target.sessionId || !target.worktree || (!target.ready && (!job.sendImmediately || job.earlyAttempts >= 2))) {
+            if (this.now() - (job.lastAttemptAt ?? job.createdAt) > 15 * 60_000)
+                throw new Error('The workspace did not become ready for Auto. Retry when setup finishes.');
+            return;
+        }
+        if (job.lastAttemptAt && this.now() - job.lastAttemptAt < 5000)
+            return;
+        job.sessionId = target.sessionId;
+        this.deps.materialize(job, target.worktree);
+        job.cursor ??= this.deps.cursor(job.sessionId);
+        this.save(job);
+        if (!job.decision) {
+            job.status = 'selecting';
+            job.reason = 'Choosing a model…';
+            this.save(job);
+            const decision = await this.deps.choose(job, target.worktree);
+            if (!this.current(job))
+                return;
+            job.decision = decision;
+            job.status = 'waiting';
+            job.reason = `${decision.model} selected · ${decision.reason}`;
+            this.save(job); // Decision is durable before any UI write.
+        }
+        const result = await this.deps.deliver(job, () => this.current(job), () => {
+            atomicJson(`${this.file(job)}.lock`, { pid: process.pid, dispatching: true });
+        });
+        if (!this.current(job))
+            return;
+        if (result.cancelled)
+            job.status = 'cancelled';
+        else if (result.ok)
+            job.status = 'delivered';
+        else if (result.blocked)
+            job.reason = 'Waiting for the Mac to unlock';
+        else {
+            if (target.ready)
+                job.attempts++;
+            else
+                job.earlyAttempts++;
+            job.error = result.error ?? 'The prompt was not accepted.';
+            job.reason = job.error;
+            if (job.attempts >= 3)
+                job.status = 'failed';
+        }
+        job.lastAttemptAt = this.now();
+        this.save(job);
+    }
+    start() {
+        const tick = () => void this.tick().catch(error => console.error('[auto-model] queue failed:', error));
+        const timer = setInterval(tick, 1000);
+        timer.unref();
+        tick();
+        return () => clearInterval(timer);
+    }
+}

package/dist-node/src/agents/auto-model/types.js

@@ -0,0 +1 @@
+export {};

package/dist-node/src/contracts/agent-inputs.js

@@ -19,6 +19,7 @@ export const agentPatchSchema = z.object({
 });
 export const setAgentOptionsSchema = agentPatchSchema.extend({ workspaceId: workspaceIdSchema });
 export const sendPromptSchema = z.object({
+    auto: z.boolean().optional().describe('Select a configured model from this pristine chat’s first message.'),
     text: z.string({ error: 'prompt must be a string' }).trim().min(1, 'empty prompt'),
     workspaceId: workspaceIdSchema,
     agent: agentPatchSchema.optional(),
@@ -26,6 +27,7 @@ export const sendPromptSchema = z.object({
     queue: z.boolean().default(false)
 });
 export const createWorkspaceSchema = agentPatchSchema.extend({
+    auto: z.boolean().optional().describe('Use Auto to select the initial model. Omit manual agent settings.'),
     repo: z.string().trim().min(1).optional().describe('Exact name from list_repos.'),
     prompt: optionalText.describe('First prompt for the new agent. Omit to open an empty workspace.'),
     send: z

package/dist-node/src/http/router.js

@@ -2,6 +2,7 @@ import http from 'node:http';
 import { InputError } from "../contracts/validation.js";
 import { UiBusyError, uiQueueDepth, withUiPriority } from "../writes/ui-lock.js";
 import { NOT_HANDLED } from "./router-types.js";
+import { createAutoModelRoutes } from "./routes/auto-model.js";
 import { createCreateWorkspaceRoutes } from "./routes/create-workspace.js";
 import { createFilesRoutes } from "./routes/files.js";
 import { createPromptsRoutes } from "./routes/prompts.js";
@@ -14,6 +15,7 @@ import { createWorkspacesRoutes } from "./routes/workspaces.js";
 export function createRelayServer(services) {
     const { handleMcpHttp, serveStatic, authed, json, PayloadTooLargeError, workflowHttpError } = services;
     const handlers = [
+        createAutoModelRoutes(services),
         createStateRoutes(services),
         createWorkflowsRoutes(services),
         createVoiceRoutes(services),

package/dist-node/src/http/routes/auto-model.js

@@ -0,0 +1,26 @@
+import { autoModelIssues, decodeAutoModelConfig } from "../../agents/auto-model/config.js";
+import { isRoute, routes } from "../../routes.js";
+import { NOT_HANDLED } from "../router-types.js";
+export function createAutoModelRoutes(services) {
+    const { autoModelConfig, modelCache, readBody, json } = services;
+    return async (req, res, url) => {
+        if (isRoute(routes.autoModelConfig, req.method, url.pathname)) {
+            const config = autoModelConfig.read();
+            return json(req, res, 200, { config, issues: autoModelIssues(config, modelCache.list()) });
+        }
+        if (isRoute(routes.updateAutoModelConfig, req.method, url.pathname)) {
+            try {
+                const config = decodeAutoModelConfig(JSON.parse(await readBody(req)));
+                const issues = autoModelIssues(config, modelCache.list());
+                if (issues.length)
+                    return json(req, res, 400, { error: issues.join(' ') });
+                autoModelConfig.write(config);
+                return json(req, res, 200, { config, issues: [] });
+            }
+            catch {
+                return json(req, res, 400, { error: 'Invalid Auto settings. Check the profiles, fallback, and router.' });
+            }
+        }
+        return NOT_HANDLED;
+    };
+}

package/dist-node/src/http/routes/create-workspace.js

@@ -1,3 +1,4 @@
+import { freezeAutoModelConfig } from "../../agents/auto-model/config.js";
 import { createWorkspaceSchema, hasAgentSettings } from "../../contracts/agent-inputs.js";
 import { parseInput } from "../../contracts/validation.js";
 import { stagedAttachments } from "../../files/staged-attachments.js";
@@ -17,6 +18,21 @@ export function createCreateWorkspaceRoutes(services) {
             const body = parseInput(createWorkspaceSchema, input);
             const { attachmentIds, model, effort, plan, fast } = body;
             const requestedAgent = { model, effort, plan, fast };
+            if (body.auto && [body.model, body.effort, body.fast, body.plan].some(value => value !== undefined))
+                return json(req, res, 400, {
+                    error: 'Auto chooses the agent settings. Omit manual model, effort, Fast, and Plan.'
+                });
+            let autoConfig;
+            if (body.auto) {
+                if (!services.autoModels || !services.autoModelConfig || !services.modelCache)
+                    return json(req, res, 503, { error: 'Auto is unavailable.' });
+                try {
+                    autoConfig = freezeAutoModelConfig(services.autoModelConfig.read(), services.modelCache.list());
+                }
+                catch (error) {
+                    return json(req, res, 409, { error: error instanceof Error ? error.message : 'Invalid Auto settings.' });
+                }
+            }
             const attachments = stagedAttachments(STAGED_ATTACHMENTS_DIR, attachmentIds);
             if (!attachments)
                 return json(req, res, 409, { error: 'an attached file is no longer available; add it again' });
@@ -37,7 +53,7 @@ export function createCreateWorkspaceRoutes(services) {
                 return json(req, res, 404, { error: `unknown repo ${body.repo}` });
             if (repo && !repo.root_path)
                 return json(req, res, 409, { error: `${repo.name} has no checkout path` });
-            const { result, created } = await createWorkspaceAndRead(prompt, repo?.root_path ?? null, repo?.name);
+            const { result, created } = await createWorkspaceAndRead(prompt, repo?.root_path ?? null, repo?.name, !!body.auto);
             if (!result.ok)
                 return json(req, res, 502, result);
             if (!created) {
@@ -47,6 +63,25 @@ export function createCreateWorkspaceRoutes(services) {
                     error: 'Conductor didn’t create a workspace — check it’s running and not showing a dialog.'
                 });
             }
+            if (autoConfig && services.autoModels) {
+                const sessions = reads.listSessions(created.id);
+                services.autoModels.accept({
+                    workspaceId: created.id,
+                    sessionId: sessions.length === 1 ? sessions[0].id : undefined,
+                    text: prompt,
+                    repo: created.repo_name ?? body.repo ?? '',
+                    config: autoConfig,
+                    attachmentIds,
+                    sendImmediately: body.sendImmediately
+                });
+                return json(req, res, 200, {
+                    ok: true,
+                    workspaceId: created.id,
+                    workspace: created,
+                    pendingPrompt: prompt || undefined,
+                    sent: false
+                });
+            }
             // Return as soon as the row exists (~2s) — waiting for delivery would block the
             // request through Conductor's whole setup, measured at 30s+ on a real repo and
             // past any budget a phone should hold a request open for. The queue delivers on