clilinkapi 0.1.0

package/dist/src/providers/codex.js

@@ -0,0 +1,201 @@
+import { z } from 'zod';
+import { inspectWorkspace } from '../config.js';
+import { CliLinkAPIError, normalizeError } from '../errors.js';
+import { profileArgs, probeIsolation, requireNativePlatform } from '../sandbox.js';
+import { Rpc } from './rpc.js';
+import { verifyRuntime, disabledSkillArgs } from './runtime.js';
+import { ToolSessions } from '../tool-sessions.js';
+const modelPage = z.object({ data: z.array(z.object({ model: z.string(), hidden: z.boolean(), supportedReasoningEfforts: z.array(z.object({ reasoningEffort: z.string() })), defaultReasoningEffort: z.string(), isDefault: z.boolean() })), nextCursor: z.string().nullable() });
+const agentItem = z.object({ id: z.string(), type: z.literal('agentMessage'), text: z.string(), phase: z.enum(['commentary', 'final_answer']).nullable().optional() });
+const usageSchema = z.object({ inputTokens: z.number().int().nonnegative(), outputTokens: z.number().int().nonnegative(), totalTokens: z.number().int().nonnegative() });
+export class ResponseExtractor {
+    threadId;
+    finalIds = new Set();
+    streamed = new Map();
+    finalText;
+    usage;
+    constructor(threadId) {
+        this.threadId = threadId;
+    }
+    consume(event) {
+        const p = event.params;
+        if (p.threadId !== this.threadId)
+            return;
+        if (event.method === 'error')
+            throw normalizeError(new Error(JSON.stringify(p.error)));
+        if (event.method === 'item/started' || event.method === 'item/completed') {
+            const item = agentItem.safeParse(p.item);
+            if (!item.success)
+                return;
+            if (item.data.phase === 'final_answer') {
+                if (this.finalIds.size && !this.finalIds.has(item.data.id))
+                    throw new CliLinkAPIError(502, 'ambiguous_final_response', 'Codex emitted more than one final-answer item.');
+                this.finalIds.add(item.data.id);
+                if (event.method === 'item/completed') {
+                    if ((this.streamed.get(item.data.id) ?? '') !== item.data.text) {
+                        // No fake token stream: final text is used only by non-streaming clients.
+                        if (this.streamed.has(item.data.id))
+                            throw new CliLinkAPIError(502, 'upstream_protocol', 'Codex final text disagrees with streamed deltas.');
+                    }
+                    this.finalText = item.data.text;
+                }
+            }
+            // Unlabelled historical runtimes cannot distinguish commentary safely.
+        }
+        if (event.method === 'item/agentMessage/delta') {
+            const delta = z.object({ itemId: z.string(), delta: z.string() }).parse(p);
+            if (!this.finalIds.has(delta.itemId))
+                return;
+            const text = (this.streamed.get(delta.itemId) ?? '') + delta.delta;
+            if (Buffer.byteLength(text) > 2 * 1024 * 1024)
+                throw new CliLinkAPIError(502, 'response_too_large', 'Codex response exceeded clilinkapi limits.');
+            this.streamed.set(delta.itemId, text);
+            return { type: 'delta', text: delta.delta };
+        }
+        if (event.method === 'thread/tokenUsage/updated') {
+            const result = z.object({ tokenUsage: z.object({ last: usageSchema }) }).parse(p).tokenUsage.last;
+            this.usage = { prompt_tokens: result.inputTokens, completion_tokens: result.outputTokens, total_tokens: result.totalTokens };
+        }
+        if (event.method === 'turn/completed') {
+            const turn = z.object({ turn: z.object({ status: z.string(), error: z.unknown().optional() }) }).parse(p).turn;
+            if (turn.status !== 'completed')
+                throw normalizeError(new Error(JSON.stringify(turn.error ?? turn.status)));
+            if (this.finalText === undefined)
+                throw new CliLinkAPIError(502, 'missing_final_response', 'Codex completed without a labelled final assistant response.');
+            return { type: 'complete', text: this.finalText, ...(this.usage ? { usage: this.usage } : {}) };
+        }
+        return;
+    }
+}
+export class CodexProvider {
+    config;
+    filename;
+    capabilities = { streaming: true, sessions: false };
+    active = new Set();
+    tools;
+    constructor(config, filename) {
+        this.config = config;
+        this.filename = filename;
+        this.tools = new ToolSessions(config.compatibility.maxPendingTools, config.compatibility.toolTimeoutMs, state => this.dispose(state.rpc));
+    }
+    async open(signal, args = []) {
+        await verifyRuntime(this.config.provider.codexHome);
+        const rpc = new Rpc(this.config.provider.codexHome, args);
+        this.active.add(rpc);
+        try {
+            await rpc.initialize(signal);
+            const account = z.object({ account: z.object({ type: z.string() }).nullable() }).parse(await rpc.request('account/read', { refreshToken: true }, signal));
+            if (account.account?.type !== 'chatgpt')
+                throw new CliLinkAPIError(503, 'upstream_authentication', 'Runtime requires ChatGPT sign-in. Run clilinkapi login as the clilinkapi runtime user.');
+            return rpc;
+        }
+        catch (error) {
+            await this.dispose(rpc);
+            throw normalizeError(error);
+        }
+    }
+    async dispose(rpc) { await rpc.close(); this.active.delete(rpc); }
+    async models(signal) {
+        const rpc = await this.open(signal);
+        try {
+            const models = [];
+            let cursor = null;
+            const seen = new Set();
+            do {
+                const page = modelPage.parse(await rpc.request('model/list', { limit: 100, includeHidden: false, cursor }, signal));
+                for (const item of page.data)
+                    if (!item.hidden && (!this.config.provider.allowedModels.length || this.config.provider.allowedModels.includes(item.model)))
+                        models.push({ id: item.model, efforts: item.supportedReasoningEfforts.map(e => e.reasoningEffort), defaultEffort: item.defaultReasoningEffort, isDefault: item.isDefault });
+                cursor = page.nextCursor;
+                if (cursor && (seen.has(cursor) || seen.size >= 20))
+                    throw new Error('Invalid catalog pagination');
+                if (cursor)
+                    seen.add(cursor);
+            } while (cursor);
+            return models;
+        }
+        catch (error) {
+            throw normalizeError(error);
+        }
+        finally {
+            await this.dispose(rpc);
+        }
+    }
+    async *generate(input) {
+        requireNativePlatform(this.config.provider.allowUnqualifiedWindowsExecution);
+        const resumed = this.tools.take(input);
+        if (!resumed && this.tools.hasWorkspace(input.workspace.path))
+            throw new CliLinkAPIError(409, 'workspace_busy', 'Workspace is waiting for an external tool result.');
+        if (resumed) {
+            let retained = false;
+            try {
+                resumed.value.rpc.replyTool(resumed.value.requestId, resumed.result);
+                for await (const event of this.continueTurn(input, resumed.value)) {
+                    retained = event.type === 'tool_calls';
+                    yield event;
+                }
+            }
+            finally {
+                if (!retained)
+                    await this.dispose(resumed.value.rpc);
+            }
+            return;
+        }
+        const projectSkills = await inspectWorkspace(input.workspace, this.config.provider.allowSymbolicLinks);
+        const rpc = await this.open(input.signal, [...profileArgs(input.workspace, [this.filename, this.config.provider.codexHome]), ...disabledSkillArgs(this.config.provider.codexHome, projectSkills, this.config.provider.allowProjectSkills)]);
+        let threadId;
+        let turnId;
+        let retained = false;
+        try {
+            await probeIsolation(rpc, input.workspace, this.config.provider.codexHome, input.signal, this.config.provider.allowUnqualifiedWindowsExecution);
+            const dynamicTools = input.request?.tool_choice === 'none' ? [] : (input.request?.tools ?? []).map(t => ({ type: 'function', name: t.function.name, description: t.function.description ?? '', inputSchema: t.function.parameters }));
+            const response = z.object({ thread: z.object({ id: z.string() }), model: z.string(), approvalPolicy: z.string(), activePermissionProfile: z.object({ id: z.string() }) }).parse(await rpc.request('thread/start', { model: input.model, modelProvider: 'openai', allowProviderModelFallback: false, cwd: input.workspace.path, runtimeWorkspaceRoots: [input.workspace.path], permissions: 'clilinkapi', approvalPolicy: 'never', approvalsReviewer: 'user', ephemeral: true, environments: [], selectedCapabilityRoots: [], dynamicTools, developerInstructions: input.instructions || null }, input.signal));
+            if (response.model !== input.model || response.approvalPolicy !== 'never' || response.activePermissionProfile.id !== 'clilinkapi')
+                throw new CliLinkAPIError(503, 'runtime_policy_mismatch', 'Codex did not honor the requested model or permission policy.');
+            threadId = response.thread.id;
+            const turn = z.object({ turn: z.object({ id: z.string() }) }).parse(await rpc.request('turn/start', { threadId, input: [{ type: 'text', text: input.prompt, text_elements: [] }], model: input.model, effort: input.effort, approvalPolicy: 'never', approvalsReviewer: 'user' }, input.signal));
+            turnId = turn.turn.id;
+            const extractor = new ResponseExtractor(threadId);
+            for await (const event of this.continueTurn(input, { rpc, threadId, turnId, extractor, requestId: 0 })) {
+                retained = event.type === 'tool_calls';
+                yield event;
+            }
+        }
+        catch (error) {
+            if (input.signal.aborted)
+                throw new CliLinkAPIError(499, 'cancelled', 'Request cancelled.');
+            throw normalizeError(error);
+        }
+        finally {
+            if (!retained) {
+                if (threadId && turnId)
+                    await rpc.request('turn/interrupt', { threadId, turnId }, AbortSignal.timeout(1500)).catch(() => undefined);
+                await this.dispose(rpc);
+            }
+        }
+    }
+    async *continueTurn(input, state) {
+        while (true) {
+            const notification = await state.rpc.next(input.signal);
+            if (notification.method === 'item/tool/call') {
+                const call = z.object({ threadId: z.string(), turnId: z.string(), tool: z.string(), namespace: z.string().nullable().optional(), arguments: z.record(z.string(), z.unknown()) }).parse(notification.params);
+                if (notification.requestId === undefined || call.threadId !== state.threadId || call.turnId !== state.turnId || call.namespace || input.request?.tool_choice === 'none' || !input.request?.tools?.some(t => t.function.name === call.tool))
+                    throw new CliLinkAPIError(502, 'unexpected_tool', 'Runtime requested an unregistered external tool.');
+                const args = JSON.stringify(call.arguments);
+                if (Buffer.byteLength(args) > 200000 || [this.config.auth.apiKey, this.config.provider.codexHome, this.filename].some(secret => args.includes(secret) || args.includes(JSON.stringify(secret).slice(1, -1))))
+                    throw new CliLinkAPIError(502, 'unsafe_tool_arguments', 'External tool arguments exceeded output limits or contained private runtime data.');
+                const tool = this.tools.put(input, { ...state, requestId: notification.requestId }, call.tool, call.arguments);
+                yield { type: 'tool_calls', calls: [tool] };
+                return;
+            }
+            const event = state.extractor.consume(notification);
+            if (event) {
+                yield event;
+                if (event.type === 'complete')
+                    return;
+            }
+        }
+    }
+    async close() { await this.tools.closeAll(); await Promise.all([...this.active].map(rpc => this.dispose(rpc))); }
+}
+//# sourceMappingURL=codex.js.map

package/dist/src/providers/registry.js

@@ -0,0 +1,3 @@
+import { CodexProvider } from './codex.js';
+export function createProvider(config, filename) { return new CodexProvider(config, filename); }
+//# sourceMappingURL=registry.js.map

package/dist/src/providers/rpc.js

@@ -0,0 +1,171 @@
+import { spawn, execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { once } from 'node:events';
+import { CliLinkAPIError } from '../errors.js';
+import { codexBinary, runtimeEnv, hardeningArgs, disabledSkillArgs } from './runtime.js';
+export class Rpc {
+    child;
+    sequence = 0;
+    buffer = '';
+    failure;
+    pending = new Map();
+    queue = [];
+    waiter;
+    closing = false;
+    constructor(home, extraArgs = []) {
+        this.child = spawn(codexBinary(), [...hardeningArgs, ...disabledSkillArgs(home), ...extraArgs, 'app-server', '--listen', 'stdio://'], { cwd: home, env: runtimeEnv(home), windowsHide: true, detached: process.platform !== 'win32', stdio: ['pipe', 'pipe', 'pipe'] });
+        this.child.stdout.setEncoding('utf8');
+        this.child.stdout.on('data', (chunk) => {
+            this.buffer += chunk;
+            if (Buffer.byteLength(this.buffer) > 4 * 1024 * 1024)
+                return this.fail(new CliLinkAPIError(502, 'upstream_overflow', 'Codex output exceeded protocol limits.'));
+            let end;
+            while ((end = this.buffer.indexOf('\n')) >= 0) {
+                const line = this.buffer.slice(0, end);
+                this.buffer = this.buffer.slice(end + 1);
+                try {
+                    this.receive(JSON.parse(line));
+                }
+                catch {
+                    this.fail(new CliLinkAPIError(502, 'upstream_protocol', 'Malformed Codex protocol output.'));
+                }
+            }
+        });
+        // Drain without logging credential-bearing upstream diagnostics.
+        this.child.stderr.resume();
+        this.child.stdin.on('error', () => this.fail(new CliLinkAPIError(502, 'upstream_closed', 'Codex transport closed.')));
+        this.child.on('error', () => this.fail(new CliLinkAPIError(503, 'runtime_unavailable', 'Could not start the native Codex runtime.')));
+        this.child.on('exit', () => { if (!this.closing)
+            this.fail(new CliLinkAPIError(502, 'upstream_closed', 'Codex exited before completing the request.')); });
+    }
+    fail(error) { this.failure ??= error; for (const p of this.pending.values()) {
+        clearTimeout(p.timer);
+        p.reject(error);
+    } this.pending.clear(); this.waiter?.(); }
+    receive(value) {
+        if (!value || typeof value !== 'object')
+            throw new Error('Invalid message');
+        const message = value;
+        if ('id' in message && typeof message.method === 'string') {
+            if (message.method === 'item/tool/call' && (typeof message.id === 'string' || typeof message.id === 'number')) {
+                if (this.queue.length >= 256)
+                    throw new Error('Too many requests');
+                this.queue.push({ method: message.method, params: message.params, requestId: message.id });
+                this.waiter?.();
+                return;
+            }
+            // Only registered dynamic tools reach the provider; approvals and questions are denied.
+            this.child.stdin.write(JSON.stringify({ id: message.id, error: { code: -32601, message: 'CliLinkAPI denies interactive requests and escalation.' } }) + '\n');
+            this.fail(new CliLinkAPIError(403, 'approval_required', 'Execution requires permissions or interaction outside the configured policy.'));
+        }
+        else if (typeof message.id === 'number') {
+            const p = this.pending.get(message.id);
+            if (!p)
+                return;
+            clearTimeout(p.timer);
+            this.pending.delete(message.id);
+            if (message.error)
+                p.reject(new Error(JSON.stringify(message.error)));
+            else
+                p.resolve(message.result);
+        }
+        else if (typeof message.method === 'string') {
+            // Keep only execution notifications. No prompts/tools are retained by this transport.
+            if (!['item/started', 'item/completed', 'item/agentMessage/delta', 'turn/completed', 'thread/tokenUsage/updated', 'error'].includes(message.method))
+                return;
+            const params = (message.params ?? {});
+            if (message.method === 'item/started' || message.method === 'item/completed') {
+                const item = params.item;
+                if (item?.type !== 'agentMessage')
+                    return;
+            }
+            if (this.queue.length >= 256)
+                return this.fail(new CliLinkAPIError(502, 'upstream_overflow', 'Codex event queue exceeded its limit.'));
+            this.queue.push({ method: message.method, params: (message.params ?? {}) });
+            this.waiter?.();
+        }
+    }
+    async request(method, params, signal) {
+        signal.throwIfAborted();
+        if (this.failure)
+            throw this.failure;
+        const id = ++this.sequence;
+        const response = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.pending.delete(id); reject(new CliLinkAPIError(504, 'upstream_timeout', 'Codex protocol request timed out.')); }, 30000);
+            this.pending.set(id, { resolve, reject, timer });
+        });
+        const abort = () => { const p = this.pending.get(id); if (p) {
+            clearTimeout(p.timer);
+            this.pending.delete(id);
+            p.reject(new CliLinkAPIError(499, 'cancelled', 'Request cancelled.'));
+        } };
+        signal.addEventListener('abort', abort, { once: true });
+        this.child.stdin.write(JSON.stringify({ method, params, id }) + '\n');
+        try {
+            return await response;
+        }
+        finally {
+            signal.removeEventListener('abort', abort);
+        }
+    }
+    async initialize(signal) {
+        await this.request('initialize', { clientInfo: { name: 'clilinkapi', version: '0.1.0' }, capabilities: { experimentalApi: true } }, signal);
+        this.child.stdin.write('{"method":"initialized","params":{}}\n');
+    }
+    replyTool(id, text) {
+        if (this.failure)
+            throw this.failure;
+        this.child.stdin.write(JSON.stringify({ id, result: { contentItems: [{ type: 'inputText', text }], success: true } }) + '\n');
+    }
+    async next(signal) {
+        while (true) {
+            signal.throwIfAborted();
+            if (this.failure)
+                throw this.failure;
+            const event = this.queue.shift();
+            if (event)
+                return event;
+            await new Promise(resolve => { this.waiter = () => resolve(); signal.addEventListener('abort', this.waiter, { once: true }); }).finally(() => { if (this.waiter)
+                signal.removeEventListener('abort', this.waiter); this.waiter = undefined; });
+        }
+    }
+    async close() {
+        if (this.closing)
+            return;
+        this.closing = true;
+        this.fail(new CliLinkAPIError(499, 'cancelled', 'Execution closed.'));
+        const exited = this.child.exitCode !== null || this.child.signalCode !== null;
+        if (!exited) {
+            const exit = once(this.child, 'exit').catch(() => undefined);
+            if (process.platform !== 'win32' && this.child.pid) {
+                try {
+                    process.kill(-this.child.pid, 'SIGTERM');
+                }
+                catch {
+                    this.child.kill();
+                }
+                const timer = setTimeout(() => { try {
+                    process.kill(-this.child.pid, 'SIGKILL');
+                }
+                catch { /* already gone */ } }, 1500);
+                await exit;
+                clearTimeout(timer);
+                try {
+                    process.kill(-this.child.pid, 'SIGKILL');
+                }
+                catch { /* no surviving descendants */ }
+            }
+            else {
+                if (this.child.pid)
+                    await promisify(execFile)('taskkill.exe', ['/PID', String(this.child.pid), '/T', '/F'], { windowsHide: true, timeout: 5000 }).catch(() => this.child.kill());
+                else
+                    this.child.kill();
+                await exit;
+            }
+        }
+        this.child.stdout.destroy();
+        this.child.stderr.destroy();
+        this.child.stdin.destroy();
+    }
+}
+//# sourceMappingURL=rpc.js.map

package/dist/src/providers/runtime.js

@@ -0,0 +1,98 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readdir, lstat } from 'node:fs/promises';
+import { CliLinkAPIError } from '../errors.js';
+const require = createRequire(import.meta.url);
+export const RUNTIME_VERSION = '0.155.0';
+// Bundled by the pinned runtime itself, including during login/app-server startup.
+const bundledSkills = ['imagegen', 'openai-docs', 'plugin-creator', 'review-agent', 'skill-creator', 'skill-installer'];
+export function disabledSkillArgs(home, projectSkills = [], allowProjectSkills = false) {
+    // 0.155.0 matches the SKILL.md file, not its containing directory.
+    const paths = [...bundledSkills.map(name => path.join(home, 'skills', '.system', name, 'SKILL.md')), ...(allowProjectSkills ? [] : projectSkills)];
+    return ['-c', `skills.config=[${paths.map(filename => `{path=${JSON.stringify(filename)},enabled=false}`).join(',')}]`];
+}
+export async function verifyRuntimeHome(home) {
+    const reject = (entry) => { throw new CliLinkAPIError(503, 'runtime_configuration', `Use a dedicated Codex home with no custom config, hooks, plugins, rules or skills. Remove or relocate the blocked entry: ${entry}.`); };
+    for (const name of ['config.toml', 'AGENTS.md', 'AGENTS.override.md', 'rules', 'plugins', 'hooks.json']) {
+        try {
+            await lstat(path.join(home, name));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        reject(name);
+    }
+    for (const name of await readdir(home))
+        if ((await lstat(path.join(home, name))).isSymbolicLink())
+            reject(name);
+    const skills = path.join(home, 'skills');
+    let entries;
+    try {
+        entries = await readdir(skills);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    for (const name of entries)
+        if (name !== '.system')
+            reject('skills/' + name);
+    if (!entries.length)
+        return;
+    const walk = async (directory) => {
+        const info = await lstat(directory);
+        if (info.isSymbolicLink() || (!info.isDirectory() && info.nlink > 1))
+            reject('skills');
+        if (info.isDirectory())
+            for (const name of await readdir(directory))
+                await walk(path.join(directory, name));
+        else if (path.basename(directory).toLowerCase() === 'skill.md' && !bundledSkills.some(name => directory === path.join(skills, '.system', name, 'SKILL.md')))
+            reject('skills/.system');
+    };
+    await walk(path.join(skills, '.system'));
+    for (const name of await readdir(path.join(skills, '.system')))
+        if (!bundledSkills.includes(name) && name !== '.codex-system-skills.marker')
+            reject('skills/.system/' + name);
+}
+export function codexBinary() {
+    const target = { 'linux-x64': 'x86_64-unknown-linux-musl', 'linux-arm64': 'aarch64-unknown-linux-musl', 'darwin-x64': 'x86_64-apple-darwin', 'darwin-arm64': 'aarch64-apple-darwin', 'win32-x64': 'x86_64-pc-windows-msvc', 'win32-arm64': 'aarch64-pc-windows-msvc' };
+    const platform = `${process.platform}-${process.arch}`;
+    if (!target[platform])
+        throw new Error('This platform has no supported native Codex binary.');
+    return path.join(path.dirname(require.resolve(`@openai/codex-${platform}/package.json`)), 'vendor', target[platform], 'bin', process.platform === 'win32' ? 'codex.exe' : 'codex');
+}
+export function runtimeEnv(home) {
+    const env = { CODEX_HOME: home };
+    for (const name of ['PATH', 'SystemRoot', 'WINDIR', 'SystemDrive', 'COMSPEC', 'HOME', 'USERPROFILE', 'LOCALAPPDATA', 'APPDATA', 'TMPDIR', 'TMP', 'TEMP', 'LANG'])
+        if (process.env[name])
+            env[name] = process.env[name];
+    return env;
+}
+export async function verifyRuntime(home) {
+    const { stdout } = await promisify(execFile)(codexBinary(), ['--version'], { env: runtimeEnv(home), timeout: 10000, windowsHide: true });
+    if (stdout.trim() !== `codex-cli ${RUNTIME_VERSION}`)
+        throw new CliLinkAPIError(503, 'runtime_version', 'Codex runtime version is not the audited pinned version.');
+    await verifyRuntimeHome(home);
+}
+export const hardeningArgs = [
+    '-c', 'forced_login_method="chatgpt"', '-c', 'model_provider="openai"',
+    '-c', 'approval_policy="never"', '-c', 'web_search="disabled"',
+    '-c', 'shell_environment_policy.inherit="none"',
+    '-c', 'features.apps=false', '-c', 'features.multi_agent=false',
+    '-c', 'features.js_repl=false', '-c', 'features.code_mode=false',
+    '-c', 'features.memories=false', '-c', 'features.hooks=false',
+    '-c', 'features.plugins=false', '-c', 'features.remote_plugin=false',
+    '-c', 'features.browser_use=false', '-c', 'features.browser_use_external=false',
+    '-c', 'features.computer_use=false', '-c', 'features.in_app_browser=false',
+    '-c', 'features.image_generation=false', '-c', 'features.view_image=false',
+    '-c', 'features.code_mode_host=false', '-c', 'features.multi_agent_v2=false',
+    '-c', 'features.shell_snapshot=false', '-c', 'features.workspace_dependencies=false',
+    '-c', 'features.skip_host_skill_discovery=true', '-c', 'features.skill_search=false',
+    '-c', 'features.skill_mcp_dependency_install=false', '-c', 'features.unbounded_connection_retries=false',
+];
+//# sourceMappingURL=runtime.js.map

package/dist/src/providers/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/src/redaction.js

@@ -0,0 +1,37 @@
+// Redaction applies equally to buffered and streamed text. Keep an unfinished word
+// plus a suffix long enough to catch known secrets split across delta boundaries.
+export class Redactor {
+    pending = '';
+    values;
+    constructor(values) { this.values = [...new Set(values.flatMap(v => [v, v.replaceAll('\\', '/'), v.replaceAll('\\', '\\\\')]))].sort((a, b) => b.length - a.length); }
+    clean(text) {
+        for (const value of this.values)
+            text = text.replaceAll(value, '[redacted]');
+        return text.replace(/(?:[A-Za-z]:[\\/]|(?<![:/\w])\/(?!\/))[^^\s"'`<>]*/g, '[host-path]');
+    }
+    push(text, final = false) {
+        this.pending += text;
+        if (final) {
+            const out = this.clean(this.pending);
+            this.pending = '';
+            return out;
+        }
+        const keep = Math.max(256, ...this.values.map(v => v.length));
+        if (this.pending.length <= keep)
+            return '';
+        const boundary = this.pending.lastIndexOf(' ', this.pending.length - keep);
+        if (boundary < 0)
+            return '';
+        // Avoid cutting a known secret containing whitespace.
+        let cut = boundary + 1;
+        for (const value of this.values) {
+            const start = this.pending.indexOf(value);
+            if (start >= 0 && start < cut && start + value.length > cut)
+                cut = start;
+        }
+        const out = this.clean(this.pending.slice(0, cut));
+        this.pending = this.pending.slice(cut);
+        return out;
+    }
+}
+//# sourceMappingURL=redaction.js.map

package/dist/src/requests.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { CliLinkAPIError } from './errors.js';
+const name = z.string().regex(/^[a-zA-Z0-9_-]{1,64}$/);
+const text = z.union([z.string().max(200000), z.array(z.strictObject({ type: z.literal('text'), text: z.string() })).max(256).transform(parts => parts.map(p => p.text).join(''))]);
+export const toolCallSchema = z.strictObject({ id: z.string().min(1).max(256), type: z.literal('function'), function: z.strictObject({ name, arguments: z.string().max(200000) }) });
+const message = z.discriminatedUnion('role', [
+    z.strictObject({ role: z.literal('system'), content: text }), z.strictObject({ role: z.literal('developer'), content: text }), z.strictObject({ role: z.literal('user'), content: text }),
+    z.strictObject({ role: z.literal('assistant'), content: text.nullable().optional(), tool_calls: z.array(toolCallSchema).min(1).max(32).optional() }),
+    z.strictObject({ role: z.literal('tool'), content: text, tool_call_id: z.string().min(1).max(256) })
+]);
+const tool = z.strictObject({ type: z.literal('function'), function: z.strictObject({ name, description: z.string().max(20000).optional(), parameters: z.record(z.string(), z.unknown()).default({ type: 'object', properties: {} }), strict: z.literal(false).nullable().optional() }) });
+const requestSchema = z.strictObject({
+    model: z.string().min(1).optional(), reasoning_effort: z.string().optional(), stream: z.boolean().default(false), messages: z.array(message).min(1).max(256),
+    tools: z.array(tool).max(64).optional(), tool_choice: z.enum(['auto', 'none']).optional(), parallel_tool_calls: z.boolean().optional(), n: z.literal(1).optional(), stream_options: z.strictObject({ include_usage: z.boolean() }).optional(),
+    response_format: z.strictObject({ type: z.literal('text') }).optional(),
+    temperature: z.null().optional(), top_p: z.null().optional(), frequency_penalty: z.union([z.literal(0), z.null()]).optional(), presence_penalty: z.union([z.literal(0), z.null()]).optional(),
+    max_tokens: z.null().optional(), max_completion_tokens: z.null().optional(), stop: z.union([z.null(), z.array(z.never()).max(0)]).optional(), logprobs: z.union([z.literal(false), z.null()]).optional()
+});
+export function parseRequest(input) {
+    const parsed = requestSchema.safeParse(input);
+    if (!parsed.success)
+        throw new CliLinkAPIError(400, 'unsupported_request', 'Unsupported Chat Completions request. Use text messages, function tools, tool_choice auto/none, n=1. Leave temperature, top_p, token limits, strict tool schemas and response formats unset.');
+    if (!parsed.data.messages.some(m => m.role === 'user'))
+        throw new CliLinkAPIError(400, 'missing_user_message', 'At least one user message is required.');
+    const data = parsed.data;
+    if (new Set(data.tools?.map(t => t.function.name)).size !== (data.tools?.length ?? 0))
+        throw new CliLinkAPIError(400, 'duplicate_tool', 'Tool names must be unique.');
+    const seen = new Set();
+    const pending = new Set();
+    for (const m of data.messages) {
+        if (m.role === 'tool') {
+            if (!pending.delete(m.tool_call_id))
+                throw new CliLinkAPIError(400, 'invalid_tool_history', 'Tool results must match an unanswered tool call.');
+        }
+        else {
+            if (pending.size)
+                throw new CliLinkAPIError(400, 'invalid_tool_history', 'Supply all tool results before continuing the conversation.');
+            if (m.role === 'assistant')
+                for (const call of m.tool_calls ?? []) {
+                    if (seen.has(call.id))
+                        throw new CliLinkAPIError(400, 'invalid_tool_history', 'Duplicate tool call ID.');
+                    try {
+                        const args = JSON.parse(call.function.arguments);
+                        if (!args || typeof args !== 'object' || Array.isArray(args))
+                            throw new Error();
+                    }
+                    catch {
+                        throw new CliLinkAPIError(400, 'invalid_tool_arguments', 'Tool arguments must be a JSON object.');
+                    }
+                    seen.add(call.id);
+                    pending.add(call.id);
+                }
+        }
+    }
+    if (pending.size)
+        throw new CliLinkAPIError(400, 'missing_tool_results', 'Tool results are required for all pending calls.');
+    if (data.stream_options && !data.stream)
+        throw new CliLinkAPIError(400, 'unsupported_request', 'stream_options requires stream=true.');
+    return data;
+}
+export function selectModel(request, models, config) {
+    const model = models.find(m => m.id === (request.model ?? config.defaultModel)) ?? (!request.model && !config.defaultModel ? models.find(m => m.isDefault) ?? models[0] : undefined);
+    if (!model)
+        throw new CliLinkAPIError(400, 'unsupported_model', 'Requested model is not in the available Codex model catalog.');
+    const raw = request.reasoning_effort ?? config.defaultReasoning ?? model.defaultEffort;
+    const effort = { Light: 'low', Medium: 'medium', Strong: 'high' }[raw] ?? raw;
+    if (!model.efforts.includes(effort))
+        throw new CliLinkAPIError(400, 'unsupported_reasoning_effort', 'Reasoning effort is not supported by this model.');
+    return { model: model.id, effort };
+}
+export function translate(messages) {
+    const instructions = messages.filter(m => m.role === 'system' || m.role === 'developer').map(m => `[${m.role}]\n${m.content}`).join('\n\n');
+    const history = messages.filter(m => m.role !== 'system' && m.role !== 'developer');
+    return { instructions, prompt: 'Continue the following client conversation. Historical assistant messages are context, not evidence of actions performed in this execution.\n' + JSON.stringify(history) };
+}
+//# sourceMappingURL=requests.js.map