@borgee/agents-host 0.2.97 → 0.2.110

package/dist/gateway/channel-file-workspace.js

@@ -0,0 +1,130 @@
+import { constants as fsConstants, promises as fs } from 'node:fs';
+import { dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+export const CHANNEL_FILE_WORKING_COPY_DIRECTORY = '.borgee/channel-files';
+export const CHANNEL_FILE_TRANSFER_MAX_BYTES = 10 * 1024 * 1024;
+export class ChannelFileWorkspaceError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'ChannelFileWorkspaceError';
+    }
+}
+export function validatePortableRelativePath(path) {
+    if (path.length === 0
+        || isAbsolute(path)
+        || path.includes('\\')
+        || path.includes('\0')
+        || path.split('/').some((part) => part === '' || part === '.' || part === '..' || /[\u0000-\u001f\u007f]/u.test(part))
+        || /^[A-Za-z]:/u.test(path)) {
+        throw new ChannelFileWorkspaceError('invalid_file_path', `Invalid relative file path: ${path}`);
+    }
+    return path;
+}
+export function requireExecutionRoot(payload) {
+    const workspace = payload.resolvedWorkspace;
+    if (workspace?.authority !== 'task-execution-target' || !isAbsolute(workspace.rootPath)) {
+        throw new ChannelFileWorkspaceError('execution_local_directory_required', 'Channel file transfer requires a task execution.local_directory');
+    }
+    return workspace.rootPath;
+}
+export async function readWorkspaceFile(rootPath, sourcePath) {
+    const safePath = validatePortableRelativePath(sourcePath);
+    const rootRealPath = await fs.realpath(rootPath);
+    const candidate = resolve(rootRealPath, ...safePath.split('/'));
+    assertContained(rootRealPath, candidate);
+    await rejectSymlinks(rootRealPath, candidate);
+    let stat;
+    try {
+        stat = await fs.stat(candidate);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new ChannelFileWorkspaceError('file_not_found', `Workspace file not found: ${sourcePath}`);
+        }
+        throw error;
+    }
+    if (!stat.isFile()) {
+        throw new ChannelFileWorkspaceError('file_not_found', `Workspace path is not a file: ${sourcePath}`);
+    }
+    if (stat.size > CHANNEL_FILE_TRANSFER_MAX_BYTES) {
+        throw new ChannelFileWorkspaceError('file_too_large', 'File too large (max 10MB)');
+    }
+    return await fs.readFile(candidate);
+}
+export async function writeWorkingCopy(rootPath, channelPath, content, overwrite) {
+    if (content.byteLength > CHANNEL_FILE_TRANSFER_MAX_BYTES) {
+        throw new ChannelFileWorkspaceError('file_too_large', 'File too large (max 10MB)');
+    }
+    const safePath = validatePortableRelativePath(channelPath);
+    const executionRoot = await fs.realpath(rootPath);
+    const workingRoot = resolve(executionRoot, ...CHANNEL_FILE_WORKING_COPY_DIRECTORY.split('/'));
+    assertContained(executionRoot, workingRoot);
+    await ensureSafeDirectory(executionRoot, workingRoot);
+    const destination = resolve(workingRoot, ...safePath.split('/'));
+    assertContained(workingRoot, destination);
+    await ensureSafeDirectory(workingRoot, dirname(destination));
+    await rejectSymlinks(workingRoot, destination, true);
+    try {
+        await fs.writeFile(destination, content, { flag: overwrite ? 'w' : 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        if (error.code === 'EEXIST') {
+            throw new ChannelFileWorkspaceError('file_exists', `Working copy already exists: ${channelPath}`);
+        }
+        throw error;
+    }
+    return destination;
+}
+async function ensureSafeDirectory(rootPath, directoryPath) {
+    const rel = relative(rootPath, directoryPath);
+    if (rel === '') {
+        return;
+    }
+    let current = rootPath;
+    for (const segment of rel.split(sep)) {
+        current = resolve(current, segment);
+        try {
+            const stat = await fs.lstat(current);
+            if (stat.isSymbolicLink()) {
+                throw new ChannelFileWorkspaceError('symlink_not_allowed', `Symbolic link is not allowed: ${current}`);
+            }
+            if (!stat.isDirectory()) {
+                throw new ChannelFileWorkspaceError('invalid_file_path', `Path component is not a directory: ${current}`);
+            }
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            await fs.mkdir(current, { mode: 0o700 });
+        }
+    }
+}
+async function rejectSymlinks(rootPath, candidate, allowMissingLeaf = false) {
+    const rel = relative(rootPath, candidate);
+    let current = rootPath;
+    const parts = rel.split(sep);
+    for (const [index, segment] of parts.entries()) {
+        current = resolve(current, segment);
+        try {
+            const stat = await fs.lstat(current);
+            if (stat.isSymbolicLink()) {
+                throw new ChannelFileWorkspaceError('symlink_not_allowed', `Symbolic link is not allowed: ${current}`);
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT' && allowMissingLeaf && index === parts.length - 1) {
+                return;
+            }
+            throw error;
+        }
+    }
+    await fs.access(candidate, fsConstants.F_OK);
+}
+function assertContained(rootPath, candidate) {
+    const rel = relative(rootPath, candidate);
+    if (rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+        throw new ChannelFileWorkspaceError('invalid_file_path', 'Path escapes the execution directory');
+    }
+}

package/dist/gateway/localhost-gateway.js

@@ -7,6 +7,7 @@ import { evaluateGatewayAuthorization, } from '../policy/gateway-authorization.j
 import { resolveConnectionsStatePath } from '../state-paths.js';
 import { findTaskForThread } from '../task-thread-resolution.js';
 import { extractVisibleMentionIds } from '../visible-mentions.js';
+import { ChannelFileWorkspaceError, readWorkspaceFile, requireExecutionRoot, validatePortableRelativePath, writeWorkingCopy, } from './channel-file-workspace.js';
 const LOOPBACK_HOST = '127.0.0.1';
 export const LOCALHOST_GATEWAY_HISTORY_LIMIT = 20;
 const LOCALHOST_GATEWAY_BODY_LIMIT_BYTES = 32 * 1024;
@@ -60,13 +61,15 @@ class RestartableConnectionsStateStore {
 class InMemoryGatewayTokenRegistry {
     resolveBaseUrl;
     tokenFactory;
+    resolveStableAgentId;
     activateRollback;
     byChannel = new Map();
     byToken = new Map();
     pendingTokensByChannel = new Map();
-    constructor(resolveBaseUrl, tokenFactory, activateRollback = () => { }) {
+    constructor(resolveBaseUrl, tokenFactory, resolveStableAgentId, activateRollback = () => { }) {
         this.resolveBaseUrl = resolveBaseUrl;
         this.tokenFactory = tokenFactory;
+        this.resolveStableAgentId = resolveStableAgentId;
         this.activateRollback = activateRollback;
     }
     activate() {
@@ -133,6 +136,7 @@ class InMemoryGatewayTokenRegistry {
         const created = {
             channelId,
             token: this.issueUniqueToken(),
+            agentId: this.resolveStableAgentId?.()?.trim() || undefined,
         };
         this.byChannel.set(channelId, created);
         this.byToken.set(created.token, created);
@@ -422,6 +426,89 @@ class LoopbackLocalhostGatewayController {
                     this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
                     return;
                 }
+                case 'files': {
+                    const files = await this.controlPlane.listChannelFiles({ channelId: this.resolveFileScopeChannelId(binding) });
+                    this.sendJson(response, 200, { files });
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
+                    return;
+                }
+                case 'file-content': {
+                    const url = new URL(request.url ?? '/', baseUrl);
+                    const path = readRequiredQueryString(url, 'path');
+                    if (!path) {
+                        throw new GatewayHttpError(400, { error: 'missing_file_path' }, 'bad-request');
+                    }
+                    validatePortableRelativePath(path);
+                    const content = await this.controlPlane.readChannelFile({
+                        channelId: this.resolveFileScopeChannelId(binding),
+                        path,
+                        textOnly: true,
+                    });
+                    this.sendJson(response, 200, content);
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'GET', decision.binding);
+                    return;
+                }
+                case 'file-download': {
+                    const body = parseFileTransferBody(await readGatewayJsonBody(request));
+                    const rootPath = requireExecutionRoot(binding.payload ?? {});
+                    const content = await this.controlPlane.readChannelFile({
+                        channelId: this.resolveFileScopeChannelId(binding),
+                        path: body.path,
+                        textOnly: false,
+                    });
+                    if (content.base64 == null) {
+                        throw new GatewayHttpError(502, { error: 'invalid_file_content' }, 'invalid-file-content');
+                    }
+                    const localPath = await writeWorkingCopy(rootPath, body.path, Buffer.from(content.base64, 'base64'), body.overwrite);
+                    this.sendJson(response, 200, { path: body.path, localPath, sizeBytes: content.sizeBytes });
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'POST', decision.binding);
+                    return;
+                }
+                case 'file-sync': {
+                    const body = parseFileSyncBody(await readGatewayJsonBody(request));
+                    const rootPath = requireExecutionRoot(binding.payload ?? {});
+                    const entries = (await this.controlPlane.listChannelFiles({ channelId: this.resolveFileScopeChannelId(binding) }))
+                        .filter((file) => !file.isDirectory)
+                        .filter((file) => body.path == null || file.path === body.path || file.path.startsWith(`${body.path}/`));
+                    const synced = [];
+                    for (const file of entries) {
+                        const content = await this.controlPlane.readChannelFile({
+                            channelId: this.resolveFileScopeChannelId(binding),
+                            path: file.path,
+                            textOnly: false,
+                        });
+                        if (content.base64 == null) {
+                            throw new GatewayHttpError(502, { error: 'invalid_file_content' }, 'invalid-file-content');
+                        }
+                        synced.push({
+                            path: file.path,
+                            localPath: await writeWorkingCopy(rootPath, file.path, Buffer.from(content.base64, 'base64'), body.overwrite),
+                            sizeBytes: content.sizeBytes,
+                        });
+                    }
+                    this.sendJson(response, 200, { synced });
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'POST', decision.binding);
+                    return;
+                }
+                case 'file-publish': {
+                    const body = parseFilePublishBody(await readGatewayJsonBody(request));
+                    const rootPath = requireExecutionRoot(binding.payload ?? {});
+                    const workspace = binding.payload?.resolvedWorkspace;
+                    if (workspace?.authority !== 'task-execution-target' || !binding.agentId) {
+                        throw new GatewayHttpError(403, { error: 'publish_context_required' }, 'publish-context-required');
+                    }
+                    const content = await readWorkspaceFile(rootPath, body.sourcePath);
+                    const file = await this.controlPlane.publishChannelFile({
+                        channelId: this.resolveFileScopeChannelId(binding),
+                        path: body.channelPath,
+                        contentType: body.contentType ?? inferContentType(body.sourcePath),
+                        base64: content.toString('base64'),
+                        overwrite: body.overwrite,
+                    });
+                    this.sendJson(response, 200, { file });
+                    this.recordAudit('authorized', 200, decision.path, request.method ?? 'POST', decision.binding);
+                    return;
+                }
                 case 'draft': {
                     if (!binding.payload?.localhostGateway?.collaboration?.enabled) {
                         this.sendJson(response, 404, { error: 'not_found' });
@@ -599,6 +686,20 @@ class LoopbackLocalhostGatewayController {
             }
         }
         catch (error) {
+            if (error instanceof ChannelFileWorkspaceError) {
+                const statusCode = error.code === 'file_not_found'
+                    ? 404
+                    : error.code === 'file_exists'
+                        ? 409
+                        : error.code === 'file_too_large'
+                            ? 413
+                            : error.code === 'execution_local_directory_required'
+                                ? 403
+                                : 400;
+                this.sendJson(response, statusCode, { error: error.code });
+                this.recordAudit(error.code, statusCode, decision.path, request.method ?? 'GET', decision.binding);
+                return;
+            }
             const gatewayError = error instanceof GatewayHttpError
                 ? error
                 : mapGatewayControlPlaneError(error, 'authorized');
@@ -611,6 +712,12 @@ class LoopbackLocalhostGatewayController {
             throw error;
         }
     }
+    resolveFileScopeChannelId(binding) {
+        const taskChannelId = binding.payload?.taskAssignmentContext?.taskChannelId;
+        return typeof taskChannelId === 'string' && taskChannelId.trim().length > 0
+            ? taskChannelId
+            : binding.channelId;
+    }
     async loadAuthorizedTask(boundChannelId, route) {
         let task;
         try {
@@ -757,6 +864,48 @@ async function readGatewayJsonBody(request) {
         throw new GatewayHttpError(400, { error: 'invalid_json' }, 'invalid-json');
     }
 }
+function parseFileTransferBody(value) {
+    if (!isRecord(value) || typeof value.path !== 'string') {
+        throw new GatewayHttpError(400, { error: 'invalid_file_request' }, 'bad-request');
+    }
+    return { path: validatePortableRelativePath(value.path), overwrite: value.overwrite === true };
+}
+function parseFileSyncBody(value) {
+    if (!isRecord(value) || (value.path != null && typeof value.path !== 'string')) {
+        throw new GatewayHttpError(400, { error: 'invalid_file_request' }, 'bad-request');
+    }
+    return {
+        ...(typeof value.path === 'string' ? { path: validatePortableRelativePath(value.path) } : {}),
+        overwrite: value.overwrite === true,
+    };
+}
+function parseFilePublishBody(value) {
+    if (!isRecord(value)
+        || typeof value.sourcePath !== 'string'
+        || typeof value.channelPath !== 'string'
+        || (value.contentType != null && typeof value.contentType !== 'string')) {
+        throw new GatewayHttpError(400, { error: 'invalid_file_request' }, 'bad-request');
+    }
+    return {
+        sourcePath: validatePortableRelativePath(value.sourcePath),
+        channelPath: validatePortableRelativePath(value.channelPath),
+        ...(typeof value.contentType === 'string' ? { contentType: value.contentType } : {}),
+        overwrite: value.overwrite === true,
+    };
+}
+function inferContentType(path) {
+    const extension = path.toLowerCase().split('.').at(-1);
+    const byExtension = {
+        css: 'text/css', csv: 'text/csv', gif: 'image/gif', html: 'text/html',
+        jpeg: 'image/jpeg', jpg: 'image/jpeg', js: 'text/javascript',
+        json: 'application/json', md: 'text/markdown', pdf: 'application/pdf',
+        png: 'image/png', py: 'text/x-python', toml: 'application/toml',
+        ts: 'text/typescript', txt: 'text/plain', webp: 'image/webp',
+        xml: 'application/xml', yaml: 'application/yaml', yml: 'application/yaml',
+        zip: 'application/zip',
+    };
+    return (extension && byExtension[extension]) || 'application/octet-stream';
+}
 async function readCollaborationRequestBody(request) {
     const bodyText = await readRequestBody(request, LOCALHOST_GATEWAY_COLLABORATION_BODY_LIMIT_BYTES);
     if (!bodyText.ok) {
@@ -891,7 +1040,23 @@ function mapGatewayControlPlaneError(error, fallbackReason) {
             case 'bpp.task_not_found':
             case 'bpp.channel_not_found':
             case 'bpp.guild_not_found':
+            case 'bpp.file_not_found':
                 return new GatewayHttpError(404, { error: 'not_found' }, 'not-found');
+            case 'bpp.file_invalid':
+            case 'bpp.file_content_invalid':
+                return new GatewayHttpError(400, { error: 'invalid_file_content' }, 'bad-request');
+            case 'bpp.file_input_required':
+                return new GatewayHttpError(422, { error: 'file_input_required' }, 'bad-request');
+            case 'bpp.file_conflict':
+                return new GatewayHttpError(409, { error: 'file_conflict' }, 'conflict');
+            case 'bpp.file_too_large':
+            case 'bpp.file_extracted_content_too_large':
+                return new GatewayHttpError(413, { error: 'file_too_large' }, 'bad-request');
+            case 'bpp.file_unsupported_media_type':
+            case 'bpp.file_extractor_required':
+                return new GatewayHttpError(415, { error: 'file_extractor_required' }, 'bad-request');
+            case 'bpp.file_extraction_failed':
+                return new GatewayHttpError(502, { error: 'file_extraction_failed' }, 'invalid-file-content');
             case 'bpp.task_title_required':
                 return new GatewayHttpError(400, { error: 'title_required' }, 'bad-request');
             case 'bpp.task_no_updates':
@@ -948,7 +1113,7 @@ export function createLocalhostGatewayController(options) {
     }
     const contextPublisherFactory = (resolveBaseUrl) => {
         if (!options.tokenBindingGateEnabled) {
-            return new InMemoryGatewayTokenRegistry(resolveBaseUrl, options.tokenFactory ?? (() => randomUUID()), () => revokeDurableTokenBindingsIfPresent(options.stateRootDir));
+            return new InMemoryGatewayTokenRegistry(resolveBaseUrl, options.tokenFactory ?? (() => randomUUID()), options.resolveStableAgentId, () => revokeDurableTokenBindingsIfPresent(options.stateRootDir));
         }
         const stateRootDir = options.stateRootDir?.trim();
         if (!stateRootDir) {

package/dist/hosted-turn-content.js

@@ -27,7 +27,7 @@ export function buildHostedTurnContentParts(input) {
     return parts;
 }
 export function extractHostedMessageAttachments(parts) {
-    return parts.flatMap((part) => ('attachment' in part ? [normalizeHostedMessageAttachment(part.attachment)] : []));
+    return parts.flatMap((part) => 'attachment' in part ? [normalizeHostedMessageAttachment(part.attachment)] : []);
 }
 export function buildHostedIncomingContentText(parts) {
     const text = parts
@@ -42,7 +42,8 @@ export function buildHostedIncomingContentText(parts) {
         `[Attachment metadata was received for ${nonTextParts.length} attachment${nonTextParts.length === 1 ? '' : 's'}]`,
         ...nonTextParts.map((part, index) => {
             const filename = part.attachment.filename?.trim();
-            return `${index + 1}. ${part.type};${filename ? ` filename: ${filename};` : ''} content type: ${part.attachment.contentType}`;
+            const size = part.attachment.sizeBytes;
+            return `${index + 1}. ${part.type};${filename ? ` filename: ${filename};` : ''} content type: ${part.attachment.contentType}${size !== undefined ? `; size: ${size} bytes` : ''}`;
         }),
     ];
     const summary = summaryLines.join('\n');

package/dist/local-config.js

@@ -2,7 +2,7 @@ import { promises as fs } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
 import { parseDocument, stringify } from 'yaml';
-import { assertProviderCompatibility, assertProviderCommandCompatibility, optionalNonEmptyString, optionalStringArray, parseCopilotSessionTtlMinutesValue, parseBooleanValue, parseProviderIdleShutdownMinutesValue, requireNonEmptyString, resolveProvider, resolveProviderCommandConfig, } from './config.js';
+import { assertProviderCompatibility, assertProviderCommandCompatibility, optionalNonEmptyString, optionalStringArray, parseCopilotSessionTtlMinutesValue, parseBooleanValue, parseProviderIdleShutdownMinutesValue, parseProviderOutputMode, parseCodexConnectionMode, requireNonEmptyString, resolveProvider, resolveProviderCommandConfig, } from './config.js';
 import { resolveLocalConfigAgentStateRoot } from './state-paths.js';
 const SUPPORTED_CONFIG_EXTENSIONS = new Set(['.json', '.yaml', '.yml']);
 export const DEFAULT_LOCAL_HOST_CONFIG_FILENAME = 'agents-host.yaml';
@@ -107,6 +107,21 @@ function parseProviderCommandOverrides(value, sourceLabel) {
     if (claudeArgs !== undefined) {
         overrides.claudeArgs = claudeArgs;
     }
+    if (value.providerOutputMode !== undefined)
+        overrides.providerOutputMode = parseProviderOutputMode(value.providerOutputMode);
+    if (value.codexConnectionMode !== undefined)
+        overrides.codexConnectionMode = parseCodexConnectionMode(value.codexConnectionMode);
+    const sessionWorkspaceRoot = optionalNonEmptyString(value.sessionWorkspaceRoot, 'sessionWorkspaceRoot', sourceLabel);
+    if (sessionWorkspaceRoot !== undefined)
+        overrides.sessionWorkspaceRoot = sessionWorkspaceRoot;
+    const nativeProviderCommand = optionalNonEmptyString(value.nativeProviderCommand, 'nativeProviderCommand', sourceLabel);
+    if (nativeProviderCommand !== undefined)
+        overrides.nativeProviderCommand = nativeProviderCommand;
+    const codexSharedSocketPath = optionalNonEmptyString(value.codexSharedSocketPath, 'codexSharedSocketPath', sourceLabel);
+    if (codexSharedSocketPath !== undefined)
+        overrides.codexSharedSocketPath = codexSharedSocketPath;
+    if (value.codexTrustShared !== undefined)
+        overrides.codexTrustShared = parseBooleanValue(value.codexTrustShared, 'codexTrustShared', sourceLabel);
     const codexCommand = optionalNonEmptyString(value.codexCommand, 'codexCommand', sourceLabel);
     if (codexCommand !== undefined) {
         overrides.codexCommand = codexCommand;
@@ -688,6 +703,18 @@ function renderAgentConfigYaml(agent) {
     if (agent.enabled !== undefined) {
         config.enabled = agent.enabled;
     }
+    if (agent.providerOutputMode !== undefined)
+        config.providerOutputMode = agent.providerOutputMode;
+    if (agent.sessionWorkspaceRoot !== undefined)
+        config.sessionWorkspaceRoot = agent.sessionWorkspaceRoot;
+    if (agent.nativeProviderCommand !== undefined)
+        config.nativeProviderCommand = agent.nativeProviderCommand;
+    if (agent.codexConnectionMode !== undefined)
+        config.codexConnectionMode = agent.codexConnectionMode;
+    if (agent.codexSharedSocketPath !== undefined)
+        config.codexSharedSocketPath = agent.codexSharedSocketPath;
+    if (agent.codexTrustShared !== undefined)
+        config.codexTrustShared = agent.codexTrustShared;
     if (agent.claudeCommand !== undefined) {
         config.claudeCommand = agent.claudeCommand;
     }
@@ -742,6 +769,12 @@ function buildManagedAgentSnapshot(host, stateRootBaseDir, sourcePath, agent) {
 function resolveAgentProviderCommandConfig(hostDefaults, agent) {
     return resolveProviderCommandConfig({
         ...hostDefaults,
+        ...(agent.providerOutputMode !== undefined ? { providerOutputMode: agent.providerOutputMode } : {}),
+        ...(agent.sessionWorkspaceRoot !== undefined ? { sessionWorkspaceRoot: agent.sessionWorkspaceRoot } : {}),
+        ...(agent.nativeProviderCommand !== undefined ? { nativeProviderCommand: agent.nativeProviderCommand } : {}),
+        ...(agent.codexConnectionMode !== undefined ? { codexConnectionMode: agent.codexConnectionMode } : {}),
+        ...(agent.codexSharedSocketPath !== undefined ? { codexSharedSocketPath: agent.codexSharedSocketPath } : {}),
+        ...(agent.codexTrustShared !== undefined ? { codexTrustShared: agent.codexTrustShared } : {}),
         ...(agent.claudeCommand !== undefined ? { claudeCommand: agent.claudeCommand } : {}),
         ...(agent.claudeArgs !== undefined ? { claudeArgs: agent.claudeArgs } : {}),
         ...(agent.codexCommand !== undefined ? { codexCommand: agent.codexCommand } : {}),

package/dist/managed-daemon.js

@@ -351,6 +351,11 @@ export function buildManagedLocalAgentConfig(options) {
             apiKey: config.agent.agentApiKey,
             provider: config.agent.provider,
             enabled: true,
+            ...(config.providerOutputMode !== undefined ? { providerOutputMode: config.providerOutputMode } : {}),
+            ...(config.nativeProviderCommand !== undefined ? { nativeProviderCommand: config.nativeProviderCommand } : {}),
+            ...(config.codexConnectionMode !== undefined ? { codexConnectionMode: config.codexConnectionMode } : {}),
+            ...(config.codexSharedSocketPath !== undefined ? { codexSharedSocketPath: config.codexSharedSocketPath } : {}),
+            ...(config.codexTrustShared !== undefined ? { codexTrustShared: config.codexTrustShared } : {}),
             claudeCommand: config.claudeCommand,
             claudeArgs: [...config.claudeArgs],
             codexCommand: config.codexCommand,
@@ -382,6 +387,11 @@ function mergeManagedLocalAgentConfig(hostDefaults, existingAgent, generatedAgen
         enabled: true,
         name: hasOverride('BORGEE_AGENT_NAME') ? generatedAgent.name : existingAgent.name,
         provider: hasOverride('RUNTIME_PROVIDER') ? generatedAgent.provider : existingAgent.provider,
+        providerOutputMode: hasOverride('PROVIDER_OUTPUT_MODE') ? generatedAgent.providerOutputMode : existingAgent.providerOutputMode,
+        nativeProviderCommand: hasOverride('NATIVE_PROVIDER_COMMAND') ? generatedAgent.nativeProviderCommand : existingAgent.nativeProviderCommand,
+        codexConnectionMode: hasOverride('CODEX_CONNECTION_MODE') ? generatedAgent.codexConnectionMode : existingAgent.codexConnectionMode,
+        codexSharedSocketPath: hasOverride('CODEX_SHARED_SOCKET_PATH') ? generatedAgent.codexSharedSocketPath : existingAgent.codexSharedSocketPath,
+        codexTrustShared: hasOverride('CODEX_TRUST_SHARED') ? generatedAgent.codexTrustShared : existingAgent.codexTrustShared,
         claudeCommand: hasOverride('CLAUDE_COMMAND') || shouldRefreshLegacyClaudeDefaults
             ? generatedAgent.claudeCommand
             : existingAgent.claudeCommand,
@@ -416,6 +426,11 @@ function collectExplicitManagedAgentEnvOverrides(processEnv, optionEnv) {
     for (const key of [
         'BORGEE_AGENT_NAME',
         'RUNTIME_PROVIDER',
+        'PROVIDER_OUTPUT_MODE',
+        'NATIVE_PROVIDER_COMMAND',
+        'CODEX_CONNECTION_MODE',
+        'CODEX_SHARED_SOCKET_PATH',
+        'CODEX_TRUST_SHARED',
         'CLAUDE_COMMAND',
         'CLAUDE_ARGS',
         'CODEX_COMMAND',

package/dist/native-environment.d.ts

@@ -0,0 +1,2 @@
+/** Explicit undefined values survive the native adapters' process.env merge. */
+export declare function filterNativeEnvironment(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;

package/dist/native-environment.js

@@ -0,0 +1,9 @@
+/** Explicit undefined values survive the native adapters' process.env merge. */
+export function filterNativeEnvironment(env) {
+    const native = { ...env };
+    for (const key of Object.keys(native)) {
+        if (/^(?:BORGEE_|AGENT_HOST_|AGENT_REMOTE_|GATEWAY_|RELAY_)/i.test(key))
+            native[key] = undefined;
+    }
+    return native;
+}

package/dist/native-protocol-types/codec.d.ts

@@ -0,0 +1,49 @@
+import { type AgentStreamMessage as AgentStreamMessageValue } from './envelope.js';
+import { type HistoryPage as HistoryPageValue } from './history.js';
+import { type AgentSessionResponse as AgentSessionResponseValue, type ClientMessage as ClientMessageValue, type CommandAcknowledgementMessage as CommandAcknowledgementMessageValue, type CreateAgentRequest as CreateAgentRequestValue, type IncompatibleProtocolVersionErrorMessage as IncompatibleProtocolVersionErrorMessageValue, type ProviderListResponse as ProviderListResponseValue, type ResumeAgentRequest as ResumeAgentRequestValue, type ServerMessage as ServerMessageValue } from './messages.js';
+import { type ResourceResponse as ResourceResponseValue, type ResourceUpdate as ResourceUpdateValue } from './resources.js';
+import { type AgentSnapshot as AgentSnapshotValue } from './snapshot.js';
+export interface WireIssue {
+    code: 'invalid_json' | 'invalid_shape' | 'incompatible_protocol_version' | 'not_json_serializable';
+    path: string;
+    message: string;
+}
+export type WireDecodeResult<T> = {
+    status: 'ok';
+    value: T;
+} | {
+    status: 'rejected';
+    issues: WireIssue[];
+};
+export type WireEncodeResult = {
+    status: 'ok';
+    json: string;
+} | {
+    status: 'rejected';
+    issues: WireIssue[];
+};
+export declare function decodeAgentSnapshot(json: string): WireDecodeResult<AgentSnapshotValue>;
+export declare function encodeAgentSnapshot(value: AgentSnapshotValue): WireEncodeResult;
+export declare function decodeHistoryPage(json: string): WireDecodeResult<HistoryPageValue>;
+export declare function encodeHistoryPage(value: HistoryPageValue): WireEncodeResult;
+export declare function decodeAgentStreamMessage(json: string): WireDecodeResult<AgentStreamMessageValue>;
+export declare function encodeAgentStreamMessage(value: AgentStreamMessageValue): WireEncodeResult;
+export declare function decodeResourceResponse(json: string): WireDecodeResult<ResourceResponseValue>;
+export declare function encodeResourceResponse(value: ResourceResponseValue): WireEncodeResult;
+export declare function decodeResourceUpdate(json: string): WireDecodeResult<ResourceUpdateValue>;
+export declare function encodeResourceUpdate(value: ResourceUpdateValue): WireEncodeResult;
+export declare function decodeCreateAgentRequest(json: string): WireDecodeResult<CreateAgentRequestValue>;
+export declare function encodeCreateAgentRequest(value: CreateAgentRequestValue): WireEncodeResult;
+export declare function decodeResumeAgentRequest(json: string): WireDecodeResult<ResumeAgentRequestValue>;
+export declare function encodeResumeAgentRequest(value: ResumeAgentRequestValue): WireEncodeResult;
+export declare function decodeAgentSessionResponse(json: string): WireDecodeResult<AgentSessionResponseValue>;
+export declare function encodeAgentSessionResponse(value: AgentSessionResponseValue): WireEncodeResult;
+export declare function decodeProviderListResponse(json: string): WireDecodeResult<ProviderListResponseValue>;
+export declare function encodeProviderListResponse(value: ProviderListResponseValue): WireEncodeResult;
+export declare function decodeCommandAcknowledgementMessage(json: string): WireDecodeResult<CommandAcknowledgementMessageValue>;
+export declare function encodeCommandAcknowledgementMessage(value: CommandAcknowledgementMessageValue): WireEncodeResult;
+export declare function decodeClientMessage(json: string): WireDecodeResult<ClientMessageValue>;
+export declare function encodeClientMessage(value: ClientMessageValue): WireEncodeResult;
+export declare function decodeServerMessage(json: string): WireDecodeResult<ServerMessageValue>;
+export declare function decodeIncompatibleProtocolVersionError(json: string): WireDecodeResult<IncompatibleProtocolVersionErrorMessageValue>;
+export declare function encodeServerMessage(value: ServerMessageValue): WireEncodeResult;

package/dist/native-protocol-types/commands.d.ts

@@ -0,0 +1,71 @@
+import { type Static } from '@sinclair/typebox';
+export declare const AgentCommand: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+    name: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TString;
+    kind: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"command">, import("@sinclair/typebox").TLiteral<"skill">, import("@sinclair/typebox").TLiteral<"prompt">]>;
+    inputHint: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    shortDescription: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    documentation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        locator: import("@sinclair/typebox").TString;
+        resourceId: import("@sinclair/typebox").TString;
+        status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"pending">, import("@sinclair/typebox").TLiteral<"available">, import("@sinclair/typebox").TLiteral<"failed">, import("@sinclair/typebox").TLiteral<"unavailable">]>;
+    }>>;
+}>;
+export type AgentCommand = Static<typeof AgentCommand>;
+export declare const AgentCommandResult: import("@sinclair/typebox").TObject<{
+    text: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export type AgentCommandResult = Static<typeof AgentCommandResult>;
+export declare const ListCommandsRequest: import("@sinclair/typebox").TObject<{
+    protocolVersion: import("@sinclair/typebox").TLiteral<"1.7.0">;
+    type: import("@sinclair/typebox").TLiteral<"list_commands">;
+    payload: import("@sinclair/typebox").TObject<{
+        requestId: import("@sinclair/typebox").TString;
+        agentId: import("@sinclair/typebox").TString;
+    }>;
+}>;
+export declare const CommandListResponse: import("@sinclair/typebox").TObject<{
+    protocolVersion: import("@sinclair/typebox").TLiteral<"1.7.0">;
+    type: import("@sinclair/typebox").TLiteral<"command_list">;
+    payload: import("@sinclair/typebox").TObject<{
+        commands: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            id: import("@sinclair/typebox").TString;
+            name: import("@sinclair/typebox").TString;
+            description: import("@sinclair/typebox").TString;
+            kind: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"command">, import("@sinclair/typebox").TLiteral<"skill">, import("@sinclair/typebox").TLiteral<"prompt">]>;
+            inputHint: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            shortDescription: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            documentation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                locator: import("@sinclair/typebox").TString;
+                resourceId: import("@sinclair/typebox").TString;
+                status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"pending">, import("@sinclair/typebox").TLiteral<"available">, import("@sinclair/typebox").TLiteral<"failed">, import("@sinclair/typebox").TLiteral<"unavailable">]>;
+            }>>;
+        }>>;
+        requestId: import("@sinclair/typebox").TString;
+        agentId: import("@sinclair/typebox").TString;
+    }>;
+}>;
+export type CommandListResponse = Static<typeof CommandListResponse>;
+export declare const ExecuteCommandRequest: import("@sinclair/typebox").TObject<{
+    protocolVersion: import("@sinclair/typebox").TLiteral<"1.7.0">;
+    type: import("@sinclair/typebox").TLiteral<"execute_command">;
+    payload: import("@sinclair/typebox").TObject<{
+        commandId: import("@sinclair/typebox").TString;
+        args: import("@sinclair/typebox").TString;
+        requestId: import("@sinclair/typebox").TString;
+        agentId: import("@sinclair/typebox").TString;
+    }>;
+}>;
+export declare const CommandResultResponse: import("@sinclair/typebox").TObject<{
+    protocolVersion: import("@sinclair/typebox").TLiteral<"1.7.0">;
+    type: import("@sinclair/typebox").TLiteral<"command_result">;
+    payload: import("@sinclair/typebox").TObject<{
+        result: import("@sinclair/typebox").TObject<{
+            text: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        }>;
+        requestId: import("@sinclair/typebox").TString;
+        agentId: import("@sinclair/typebox").TString;
+    }>;
+}>;
+export type CommandResultResponse = Static<typeof CommandResultResponse>;

package/dist/native-protocol-types/compatibility.d.ts

@@ -0,0 +1,5 @@
+import { PROTOCOL_VERSION } from './version.js';
+export type NormalizedProtocolVersion = typeof PROTOCOL_VERSION | '1.6.0' | '1.5.0' | '1.4.0' | '1.1.0';
+export declare function isSupportedNormalizedVersion(version: unknown): version is NormalizedProtocolVersion;
+/** Validate committed bytes in their declared schema before adapting a projection copy. */
+export declare function validateNormalizedEventVersion(version: string, event: unknown): boolean;

package/dist/native-protocol-types/cursor.d.ts

@@ -0,0 +1,7 @@
+import { type Static } from '@sinclair/typebox';
+export declare const SafeNonNegativeInteger: import("@sinclair/typebox").TInteger;
+export declare const TimelineCursor: import("@sinclair/typebox").TObject<{
+    epoch: import("@sinclair/typebox").TString;
+    seq: import("@sinclair/typebox").TInteger;
+}>;
+export type TimelineCursor = Static<typeof TimelineCursor>;