@borgee/agents-host 0.2.2 → 0.2.26

package/dist/providers/create-provider.js

@@ -1,25 +1,144 @@
+import { FileChannelContextStore } from '../context/injection.js';
+import { createProviderConnectionsSessionStore } from '../connections-state-store.js';
+import { ProviderTurnPreparer } from '../context/turn-preparation.js';
+import { CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE, CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE, CONTEXT_INJECTION_COMPATIBILITY_GATE, CODEX_PROVIDER_COMPATIBILITY_GATE, COPILOT_PROVIDER_V2_COMPATIBILITY_GATE, INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV, LOCALHOST_GATEWAY_COMPATIBILITY_GATE, parseInternalProviderImplementationOverrides, POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE, resolveInternalPolicyMode, resolveInternalCompatibilityGates, SKILL_RUNTIME_COMPATIBILITY_GATE, } from '../compatibility-gates.js';
 import { ClaudeCliClient } from './claude/cli-client.js';
 import { ClaudeProviderAdapter } from './claude/adapter.js';
 import { FileClaudeChannelSessionStore } from './claude/session-store.js';
+import { CodexCliClient } from './codex/cli-client.js';
+import { CodexProviderAdapter } from './codex/adapter.js';
+import { FileCodexChannelSessionStore } from './codex/session-store.js';
 import { CopilotCliClient } from './copilot/cli-client.js';
 import { CopilotProviderAdapter } from './copilot/adapter.js';
 import { FileCopilotChannelSessionStore } from './copilot/session-store.js';
-import { resolveClaudeSessionMapPath, resolveCopilotSessionMapPath } from '../state-paths.js';
-export function createProvider(config) {
+import { resolveClaudeSessionMapPath, resolveCodexSessionMapPath, resolveCopilotSessionMapPath, } from '../state-paths.js';
+import { createAwaitingUserProgressHandler, parseProviderReply } from './awaiting-user.js';
+class ProviderV2CompatibilityAdapter {
+    provider;
+    turnPreparer;
+    constructor(provider, turnPreparer) {
+        this.provider = provider;
+        this.turnPreparer = turnPreparer;
+    }
+    async generateReply(input, options) {
+        const preparedTurn = await this.turnPreparer.prepare(input);
+        return this.provider.generateReply({
+            turn: preparedTurn,
+        }, options);
+    }
+    async dispose() {
+        await this.provider.shutdown?.();
+    }
+}
+class CliBackedProviderV2 {
+    cli;
+    constructor(cli) {
+        this.cli = cli;
+    }
+    async generateReply(input, options) {
+        const text = await this.cli.generateReply(input.turn, {
+            onProgress: createAwaitingUserProgressHandler(options?.onProgress),
+        });
+        return parseProviderReply(text);
+    }
+    async shutdown() {
+        await this.cli.dispose();
+    }
+}
+class ClaudeProviderV2 extends CliBackedProviderV2 {
+}
+class CopilotProviderV2 extends CliBackedProviderV2 {
+}
+const TASK_WORKSPACE_ROOT_DIR_ENV = 'AGENTS_HOST_INTERNAL_TASK_WORKSPACE_ROOT_DIR';
+const PROVIDER_V2_COMPATIBILITY_GATES = {
+    claude: CLAUDE_PROVIDER_V2_COMPATIBILITY_GATE,
+    copilot: COPILOT_PROVIDER_V2_COMPATIBILITY_GATE,
+};
+function resolveProviderImplementation(provider, routingConfig) {
+    if (!routingConfig.compatibilityGates.has(PROVIDER_V2_COMPATIBILITY_GATES[provider])) {
+        return 'v1';
+    }
+    return routingConfig.implementationOverrides[provider] ?? 'v2';
+}
+function createClaudeProvider(config, debugLogger, connectionsStateGateEnabled, implementation, turnPreparer) {
+    const cli = new ClaudeCliClient(config.claudeCommand, config.claudeArgs, {}, createProviderConnectionsSessionStore({
+        provider: 'claude',
+        legacyStore: new FileClaudeChannelSessionStore({
+            resolvePath: (agentId) => resolveClaudeSessionMapPath(config.stateRootDir, agentId),
+        }),
+        stateRootDir: config.stateRootDir,
+        gateEnabled: connectionsStateGateEnabled,
+        logger: debugLogger,
+    }), config.resolveStableAgentId, debugLogger);
+    return implementation === 'v2'
+        ? new ProviderV2CompatibilityAdapter(new ClaudeProviderV2(cli), turnPreparer)
+        : new ClaudeProviderAdapter(cli, turnPreparer);
+}
+function createCopilotProvider(config, debugLogger, connectionsStateGateEnabled, implementation, turnPreparer, policyAuditGateEnabled, authorizationAuditSink) {
+    const policyMode = resolveInternalPolicyMode(policyAuditGateEnabled);
+    const cli = new CopilotCliClient(config.copilotCommand, config.copilotArgs, {
+        idleSessionTtlMs: config.copilotSessionTtlMinutes * 60 * 1000,
+    }, createProviderConnectionsSessionStore({
+        provider: 'copilot',
+        legacyStore: new FileCopilotChannelSessionStore({
+            resolvePath: (agentId) => resolveCopilotSessionMapPath(config.stateRootDir, agentId),
+        }),
+        stateRootDir: config.stateRootDir,
+        gateEnabled: connectionsStateGateEnabled,
+        logger: debugLogger,
+    }), config.resolveStableAgentId, debugLogger, {
+        gateEnabled: policyAuditGateEnabled,
+        policyMode,
+        auditSink: authorizationAuditSink,
+    });
+    return implementation === 'v2'
+        ? new ProviderV2CompatibilityAdapter(new CopilotProviderV2(cli), turnPreparer)
+        : new CopilotProviderAdapter(cli, turnPreparer);
+}
+function createCodexProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer) {
+    const cli = new CodexCliClient(config.codexCommand, config.codexArgs, {}, createProviderConnectionsSessionStore({
+        provider: 'codex',
+        legacyStore: new FileCodexChannelSessionStore({
+            resolvePath: (agentId) => resolveCodexSessionMapPath(config.stateRootDir, agentId),
+        }),
+        stateRootDir: config.stateRootDir,
+        gateEnabled: connectionsStateGateEnabled,
+        logger: debugLogger,
+    }), config.resolveStableAgentId, debugLogger);
+    return new CodexProviderAdapter(cli, turnPreparer);
+}
+export function createProvider(config, debugLogger, options = {}) {
+    const routingConfig = {
+        compatibilityGates: options.compatibilityGates ?? resolveInternalCompatibilityGates(),
+        implementationOverrides: parseInternalProviderImplementationOverrides(process.env[INTERNAL_PROVIDER_IMPLEMENTATIONS_ENV]),
+    };
+    const connectionsStateGateEnabled = routingConfig.compatibilityGates.has(CONNECTIONS_STATE_LAYER_COMPATIBILITY_GATE);
+    const contextInjectionGateEnabled = routingConfig.compatibilityGates.has(CONTEXT_INJECTION_COMPATIBILITY_GATE);
+    const skillRuntimeGateEnabled = routingConfig.compatibilityGates.has(SKILL_RUNTIME_COMPATIBILITY_GATE);
+    const localhostGatewayGateEnabled = routingConfig.compatibilityGates.has(LOCALHOST_GATEWAY_COMPATIBILITY_GATE);
+    const policyAuditGateEnabled = routingConfig.compatibilityGates.has(POLICY_AUDIT_ENFORCEMENT_COMPATIBILITY_GATE);
+    const channelContextStore = contextInjectionGateEnabled
+        ? new FileChannelContextStore(config.stateRootDir, {
+            skillRuntimeEnabled: skillRuntimeGateEnabled,
+            taskWorkspaceRootDir: process.env[TASK_WORKSPACE_ROOT_DIR_ENV],
+            localhostGateway: skillRuntimeGateEnabled && localhostGatewayGateEnabled
+                ? options.localhostGateway
+                : undefined,
+        })
+        : undefined;
+    const turnPreparer = new ProviderTurnPreparer(channelContextStore, debugLogger);
     switch (config.provider) {
         case 'claude': {
-            const cli = new ClaudeCliClient(config.claudeCommand, config.claudeArgs, {}, new FileClaudeChannelSessionStore({
-                resolvePath: (agentId) => resolveClaudeSessionMapPath(config.stateRootDir, agentId),
-            }), config.resolveStableAgentId);
-            return new ClaudeProviderAdapter(cli);
+            return createClaudeProvider(config, debugLogger, connectionsStateGateEnabled, resolveProviderImplementation('claude', routingConfig), turnPreparer);
+        }
+        case 'codex': {
+            if (!routingConfig.compatibilityGates.has(CODEX_PROVIDER_COMPATIBILITY_GATE)) {
+                throw new Error(`Unsupported provider: ${String(config.provider)} (enable ${CODEX_PROVIDER_COMPATIBILITY_GATE})`);
+            }
+            return createCodexProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer);
         }
         case 'copilot': {
-            const cli = new CopilotCliClient(config.copilotCommand, config.copilotArgs, {
-                idleSessionTtlMs: config.copilotSessionTtlMinutes * 60 * 1000,
-            }, new FileCopilotChannelSessionStore({
-                resolvePath: (agentId) => resolveCopilotSessionMapPath(config.stateRootDir, agentId),
-            }), config.resolveStableAgentId);
-            return new CopilotProviderAdapter(cli);
+            return createCopilotProvider(config, debugLogger, connectionsStateGateEnabled, resolveProviderImplementation('copilot', routingConfig), turnPreparer, policyAuditGateEnabled, options.authorizationAuditSink);
         }
         default:
             throw new Error(`Unsupported provider: ${String(config.provider)}`);

package/dist/run.d.ts

@@ -2,6 +2,7 @@ import { parseGenerateConfigSpec, resolveLocalConfigLayout } from './local-confi
 import type { LocalConfigGenerateResult, LocalConfigGenerateSpec, LocalConfigSnapshot } from './types.js';
 export interface RunMainOptions {
     configPath?: string;
+    debug?: boolean;
 }
 export interface ValidateLocalConfigDeps {
     loadSnapshot?: (configPath: string) => Promise<LocalConfigSnapshot>;

package/dist/run.js

@@ -43,9 +43,12 @@ export async function generateLocalConfig(rootPath, specJson, sourceLabelOrDeps
     writer.log(JSON.stringify(result, null, 2));
 }
 export async function runMain(options = {}) {
+    const runtimeOptions = {
+        debug: options.debug,
+    };
     const host = options.configPath
-        ? new AgentsHostSupervisor(options.configPath)
-        : new AgentsHost(loadConfigFromEnv());
+        ? new AgentsHostSupervisor(options.configPath, runtimeOptions)
+        : new AgentsHost(loadConfigFromEnv(), { runtimeOptions });
     const shutdown = (signal) => {
         console.log(`[agents-host] received ${signal}, shutting down`);
         host

package/dist/state-paths.d.ts

@@ -1,6 +1,18 @@
-export declare function resolveSingleAgentStateRoot(env?: NodeJS.ProcessEnv, resolvedHomeDir?: string): string;
+export declare function normalizeManagedRuntimeKey(serverUrl: string): string;
+export declare function resolveSingleAgentStateRoot(env?: NodeJS.ProcessEnv, resolvedHomeDir?: string, agentKey?: string): string;
+export declare function resolveManagedRuntimeRoot(serverUrl: string, env?: NodeJS.ProcessEnv, resolvedHomeDir?: string): string;
 export declare function resolveManagedStateRoot(rootPath: string): string;
+export declare function resolveManagedDaemonSocketPath(rootPath: string): string;
+export declare function resolveManagedDaemonLogPath(rootPath: string): string;
+export declare function resolveManagedRuntimeSettingsPath(rootPath: string): string;
+export declare function resolveManagedBootstrapLockPath(rootPath: string): string;
 export declare function resolveLocalConfigAgentStateRoot(rootPath: string, agentKey: string): string;
 export declare function resolveAgentCursorPath(stateRootDir: string, agentId: string): string;
+export declare function resolveSharedProtocolKickoffDecisionPath(stateRootDir: string, channelId: string, anchorMessageId: string): string;
+export declare function resolveSharedProtocolStatusPath(stateRootDir: string, channelId: string, anchorMessageId: string): string;
+export declare function resolveConnectionsStatePath(stateRootDir: string): string;
+export declare function resolveAuthorizationAuditPath(stateRootDir: string): string;
+export declare function resolvePreviousAuthorizationAuditPath(stateRootDir: string): string;
 export declare function resolveClaudeSessionMapPath(stateRootDir: string, agentId: string): string;
+export declare function resolveCodexSessionMapPath(stateRootDir: string, agentId: string): string;
 export declare function resolveCopilotSessionMapPath(stateRootDir: string, agentId: string): string;

package/dist/state-paths.js

@@ -1,11 +1,17 @@
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 const SINGLE_AGENT_HOME_ROOT = '.borgee';
 const AGENTS_HOST_ROOT = 'agents-host';
 const SINGLE_AGENT_NAMESPACE = 'single-agent';
+const MANAGED_RUNTIME_NAMESPACE = 'managed';
 const MANAGED_STATE_DIRNAME = '.state';
+const MANAGED_DAEMON_SOCKET_FILENAME = 'ctl.sock';
+const MANAGED_DAEMON_LOG_FILENAME = 'daemon.log';
+const MANAGED_RUNTIME_SETTINGS_FILENAME = 'managed-runtime-settings.json';
+const MANAGED_BOOTSTRAP_LOCK_DIRNAME = '.bootstrap.lock';
 const STATE_ROOT_LABEL_MAX_LENGTH = 48;
+const MANAGED_RUNTIME_LABEL_MAX_LENGTH = 24;
 function encodeSegment(value) {
     return encodeURIComponent(value);
 }
@@ -22,25 +28,100 @@ function sanitizeStateRootLabel(agentKey) {
 function hashStateRootKey(agentKey) {
     return createHash('sha256').update(agentKey).digest('hex').slice(0, 12);
 }
-export function resolveSingleAgentStateRoot(env = process.env, resolvedHomeDir = homedir()) {
+export function normalizeManagedRuntimeKey(serverUrl) {
+    const trimmed = serverUrl.trim();
+    try {
+        const parsed = new URL(trimmed);
+        parsed.pathname = parsed.pathname.replace(/\/+$/u, '') || '/';
+        return parsed.toString();
+    }
+    catch {
+        return trimmed.replace(/\/+$/u, '');
+    }
+}
+function sanitizeManagedRuntimeLabel(serverUrl) {
+    const normalized = normalizeManagedRuntimeKey(serverUrl);
+    let labelSource = normalized;
+    try {
+        const parsed = new URL(normalized);
+        labelSource = `${parsed.hostname}${parsed.pathname === '/' ? '' : parsed.pathname}`;
+    }
+    catch {
+        labelSource = normalized;
+    }
+    const sanitized = encodeSegment(labelSource)
+        .toLowerCase()
+        .replace(/%/g, '-')
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, MANAGED_RUNTIME_LABEL_MAX_LENGTH);
+    return sanitized.length > 0 ? sanitized : 'server';
+}
+function hashManagedRuntimeKey(serverUrl) {
+    return createHash('sha256').update(normalizeManagedRuntimeKey(serverUrl)).digest('hex').slice(0, 12);
+}
+export function resolveSingleAgentStateRoot(env = process.env, resolvedHomeDir = homedir(), agentKey) {
+    const home = env.HOME?.trim() || resolvedHomeDir.trim();
+    if (!home) {
+        throw new Error('Unable to resolve a user home directory for agents-host state');
+    }
+    const baseRoot = join(home, SINGLE_AGENT_HOME_ROOT, AGENTS_HOST_ROOT, SINGLE_AGENT_NAMESPACE);
+    const normalizedAgentKey = agentKey?.trim();
+    if (!normalizedAgentKey) {
+        return baseRoot;
+    }
+    return join(baseRoot, `agent-${hashStateRootKey(normalizedAgentKey)}`);
+}
+export function resolveManagedRuntimeRoot(serverUrl, env = process.env, resolvedHomeDir = homedir()) {
     const home = env.HOME?.trim() || resolvedHomeDir.trim();
     if (!home) {
         throw new Error('Unable to resolve a user home directory for agents-host state');
     }
-    return join(home, SINGLE_AGENT_HOME_ROOT, AGENTS_HOST_ROOT, SINGLE_AGENT_NAMESPACE);
+    return join(home, SINGLE_AGENT_HOME_ROOT, AGENTS_HOST_ROOT, MANAGED_RUNTIME_NAMESPACE, `${sanitizeManagedRuntimeLabel(serverUrl)}-${hashManagedRuntimeKey(serverUrl)}`);
 }
 export function resolveManagedStateRoot(rootPath) {
     return join(resolve(rootPath), MANAGED_STATE_DIRNAME);
 }
+export function resolveManagedDaemonSocketPath(rootPath) {
+    return join(resolve(rootPath), MANAGED_DAEMON_SOCKET_FILENAME);
+}
+export function resolveManagedDaemonLogPath(rootPath) {
+    return join(resolve(rootPath), MANAGED_DAEMON_LOG_FILENAME);
+}
+export function resolveManagedRuntimeSettingsPath(rootPath) {
+    return join(resolve(rootPath), MANAGED_RUNTIME_SETTINGS_FILENAME);
+}
+export function resolveManagedBootstrapLockPath(rootPath) {
+    return join(resolve(rootPath), MANAGED_BOOTSTRAP_LOCK_DIRNAME);
+}
 export function resolveLocalConfigAgentStateRoot(rootPath, agentKey) {
     return join(resolveManagedStateRoot(rootPath), `${sanitizeStateRootLabel(agentKey)}-${hashStateRootKey(agentKey)}`);
 }
 export function resolveAgentCursorPath(stateRootDir, agentId) {
     return join(stateRootDir, `bpp-cursor-${encodeSegment(agentId)}.json`);
 }
+export function resolveSharedProtocolKickoffDecisionPath(stateRootDir, channelId, anchorMessageId) {
+    return join(dirname(resolve(stateRootDir)), 'protocol-kickoff-decisions', `${encodeSegment(channelId)}--${encodeSegment(anchorMessageId)}.json`);
+}
+export function resolveSharedProtocolStatusPath(stateRootDir, channelId, anchorMessageId) {
+    return join(dirname(resolve(stateRootDir)), 'protocol-status', `${encodeSegment(channelId)}--${encodeSegment(anchorMessageId)}.json`);
+}
+export function resolveConnectionsStatePath(stateRootDir) {
+    return join(stateRootDir, 'connections-state.sqlite');
+}
+export function resolveAuthorizationAuditPath(stateRootDir) {
+    return join(stateRootDir, 'authorization-audit.jsonl');
+}
+export function resolvePreviousAuthorizationAuditPath(stateRootDir) {
+    return join(stateRootDir, 'authorization-audit.previous.jsonl');
+}
 export function resolveClaudeSessionMapPath(stateRootDir, agentId) {
     return join(stateRootDir, `claude-channel-sessions-${encodeSegment(agentId)}.json`);
 }
+export function resolveCodexSessionMapPath(stateRootDir, agentId) {
+    return join(stateRootDir, `codex-channel-sessions-${encodeSegment(agentId)}.json`);
+}
 export function resolveCopilotSessionMapPath(stateRootDir, agentId) {
     return join(stateRootDir, `copilot-channel-sessions-${encodeSegment(agentId)}.json`);
 }

package/dist/task-thread-resolution.d.ts

@@ -0,0 +1,10 @@
+import type { ChatControlPlane } from './chat/chat-control-plane.js';
+import type { Task } from './types.js';
+interface WaitForTaskForThreadOptions {
+    preferredTaskId?: string;
+    attempts?: number;
+    delayMs?: number;
+}
+export declare function findTaskForThread(controlPlane: ChatControlPlane, threadId: string, preferredTaskId?: string): Promise<Task | null>;
+export declare function waitForTaskForThread(controlPlane: ChatControlPlane, threadId: string, options?: WaitForTaskForThreadOptions): Promise<Task | null>;
+export {};

package/dist/task-thread-resolution.js

@@ -0,0 +1,48 @@
+export async function findTaskForThread(controlPlane, threadId, preferredTaskId) {
+    if (preferredTaskId) {
+        try {
+            const task = await controlPlane.getTask({ taskId: preferredTaskId });
+            if (task.threadId === threadId) {
+                return task;
+            }
+        }
+        catch {
+            // Fall through to the visibility-based compatibility scan.
+        }
+    }
+    const channels = await controlPlane.listChannels();
+    let matchedTask = null;
+    for (const channel of channels) {
+        let tasks;
+        try {
+            tasks = await controlPlane.listTasks({ channelId: channel.id });
+        }
+        catch {
+            continue;
+        }
+        for (const task of tasks) {
+            if (task.threadId !== threadId) {
+                continue;
+            }
+            if (matchedTask && matchedTask.id !== task.id) {
+                throw new Error(`multiple tasks matched thread ${threadId}`);
+            }
+            matchedTask = task;
+        }
+    }
+    return matchedTask;
+}
+export async function waitForTaskForThread(controlPlane, threadId, options = {}) {
+    const attempts = Math.max(1, options.attempts ?? 1);
+    const delayMs = Math.max(0, options.delayMs ?? 0);
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        const task = await findTaskForThread(controlPlane, threadId, options.preferredTaskId);
+        if (task) {
+            return task;
+        }
+        if (attempt < attempts - 1 && delayMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+    return null;
+}

package/dist/types.d.ts

@@ -1,7 +1,9 @@
-export type ProviderKind = 'claude' | 'copilot';
+export type ProviderKind = 'claude' | 'codex' | 'copilot';
 export interface ProviderCommandConfig {
     claudeCommand: string;
     claudeArgs: string[];
+    codexCommand: string;
+    codexArgs: string[];
     copilotCommand: string;
     copilotArgs: string[];
     copilotSessionTtlMinutes: number;
@@ -83,6 +85,7 @@ export interface LocalConfigGenerateResult {
 }
 export interface ChannelMessageEvent {
     type?: string;
+    message_type?: string;
     channel_id: string;
     channel_type?: string;
     message_id?: string;
@@ -99,19 +102,189 @@ export interface MeResponseUser {
     display_name?: string;
     role?: string;
 }
+export interface DirectoryUser {
+    id: string;
+    display_name?: string;
+    kind: 'user' | 'agent';
+}
+export interface ChannelHistoryEntry {
+    id: string;
+    channelId: string;
+    authorId: string;
+    body: string;
+    contentType?: string;
+    type?: string;
+    replyToId?: string;
+    createdAt: number;
+    editedAt?: number;
+}
+export interface ReadChannelHistoryInput {
+    channelId: string;
+    before?: number;
+    after?: number;
+    limit: number;
+}
+export interface ChannelSummary {
+    id: string;
+    name: string;
+    kind?: string;
+}
+export interface CollaborationDraftSnapshot {
+    draftId: string;
+    channelId: string;
+    turnExecutionId: string;
+    replyToId?: string;
+    body: string;
+    status: 'streaming' | 'finalized';
+    updatedAt: number;
+    finalMessageId?: string;
+}
+export type ProviderCollaborationTurnMode = 'ordinary' | 'silent-kickoff' | 'protocol-managed';
+export interface ProviderCollaborationContext {
+    enabled: boolean;
+    turnExecutionId?: string;
+    sendRoutesAllowed?: boolean;
+    turnMode?: ProviderCollaborationTurnMode;
+    kickoff?: ProviderProtocolKickoffContext;
+    protocol?: ProviderProtocolContext;
+    grounding?: ProviderTurnGroundingContext;
+}
 export interface ProviderInput {
     agentName: string;
     provider: ProviderKind;
     channelId: string;
     incomingAuthorId: string;
     incomingContent: string;
+    incomingEventKind?: string;
+    incomingMessageType?: string;
+    collaboration?: ProviderCollaborationContext;
+}
+export interface ProviderProtocolContext {
+    anchorMessageId: string;
+    anchorSummary: string;
+    issuerId: string;
+    role: 'issuer' | 'intermediate' | 'final';
+    targetPeerId: string;
+    turnIndex: number;
+    maxTurnCount: number;
+}
+export interface ProviderProtocolKickoffContext {
+    anchorMessageId: string;
+    participantIds: [string, string];
+    issuerId: string;
+}
+export interface ProviderTurnIdentity {
+    id: string;
+    displayName?: string;
+    kind: 'human' | 'agent' | 'unknown';
 }
+export interface ProviderTurnGroundingContext {
+    self: ProviderTurnIdentity;
+    incomingAuthor: ProviderTurnIdentity;
+    peer?: ProviderTurnIdentity;
+    participants?: ProviderTurnIdentity[];
+    hostRecognizedKickoffCandidate?: boolean;
+}
+export interface SkillRuntimeBootstrapMetadata {
+    skillDirectoryPath: string;
+    skillMarkdownPath: string;
+    nodeCliPath: string;
+    pythonCliPath: string;
+}
+export interface LocalhostGatewayBootstrapMetadata {
+    baseUrl: string;
+    collaboration?: {
+        enabled: true;
+    };
+}
+export interface TaskAssignmentThreadContext {
+    active: true;
+    currentTaskId?: string;
+}
+export interface TaskWorkspaceContext {
+    currentTaskId: string;
+    rootPath: string;
+}
+export interface PreparedPromptContext {
+    channelContextPayloadPath?: string;
+    gatewayAuthPath?: string;
+    collaborationTurnExecutionId?: string;
+    collaborationTurnMode?: ProviderCollaborationTurnMode;
+    kickoff?: ProviderProtocolKickoffContext;
+    protocol?: ProviderProtocolContext;
+    grounding?: ProviderTurnGroundingContext;
+    skillRuntime?: SkillRuntimeBootstrapMetadata;
+    localhostGateway?: LocalhostGatewayBootstrapMetadata;
+    taskAssignmentContext?: TaskAssignmentThreadContext;
+    taskWorkspace?: TaskWorkspaceContext;
+}
+export interface PreparedProviderSessionRouting {
+    key: string;
+    persistence: 'persistent' | 'ephemeral';
+}
+export interface PreparedProviderTurnInput {
+    channelId: string;
+    incomingEventKind?: string;
+    incomingMessageType?: string;
+    prompt: string;
+    promptContext?: PreparedPromptContext;
+    providerSessionRouting?: PreparedProviderSessionRouting;
+}
+export interface ProviderAwaitingUser {
+    question: string;
+    reason?: string;
+}
+export type ProviderTurnControl = {
+    kind: 'continue-to-peer';
+} | {
+    kind: 'conclude-locally';
+} | {
+    kind: 'start-protocol';
+    rounds: number;
+} | ({
+    kind: 'awaiting-user';
+} & ProviderAwaitingUser);
 export interface ProviderReply {
     text: string;
+    awaitingUser?: ProviderAwaitingUser;
+    control?: ProviderTurnControl;
+    controlMalformed?: boolean;
 }
 export interface PostedMessage {
     messageId: string;
 }
+export interface PostMessageInput {
+    channelId: string;
+    body: string;
+    replyToId?: string;
+}
+export interface Task {
+    id: string;
+    channelId: string;
+    guildId: string;
+    seq?: number;
+    title: string;
+    description: string;
+    status: string;
+    assigneeId: string | null;
+    createdBy: string;
+    messageId: string | null;
+    threadId: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface CreateTaskInput {
+    channelId: string;
+    title: string;
+    description?: string;
+    assigneeId?: string;
+}
+export interface UpdateTaskInput {
+    taskId: string;
+    status?: string;
+    assigneeId?: string;
+    title?: string;
+}
 export interface ProviderProgressUpdate {
     text: string;
 }

package/dist/visible-mentions.d.ts

@@ -0,0 +1,3 @@
+export declare function extractVisibleMentionIds(content: string): string[];
+export declare function hasVisibleMention(content: string, participantId: string): boolean;
+export declare function appendVisibleMention(content: string, participantId: string): string;

package/dist/visible-mentions.js

@@ -0,0 +1,15 @@
+export function extractVisibleMentionIds(content) {
+    return [...content.matchAll(/<@([^>\s]+)>/gu)]
+        .map((match) => match[1]?.trim())
+        .filter((value) => Boolean(value));
+}
+export function hasVisibleMention(content, participantId) {
+    return extractVisibleMentionIds(content).includes(participantId);
+}
+export function appendVisibleMention(content, participantId) {
+    if (hasVisibleMention(content, participantId)) {
+        return content;
+    }
+    const separator = /\s$/u.test(content) ? '' : ' ';
+    return `${content}${separator}<@${participantId}>`;
+}

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@borgee/agents-host",
-  "version": "0.2.2",
+  "version": "0.2.26",
   "private": false,
   "publishConfig": {
     "access": "public"
   },
   "type": "module",
-  "description": "Minimal local agents host: connects a local Claude/Copilot CLI to a Borgee agent over @borgee/plugin-sdk",
+  "description": "Minimal local agents host: connects local Claude/Codex/Copilot runtimes to a Borgee agent over @borgee/plugin-sdk",
   "bin": {
-    "agents-host": "dist/cli.js"
+    "agents-host": "./dist/cli.js"
   },
   "files": [
     "dist",
+    "skills",
     "README.md"
   ],
   "repository": {
@@ -20,6 +21,20 @@
     "directory": "packages/agents-host"
   },
   "license": "MIT",
+  "dependencies": {
+    "@agentclientprotocol/codex-acp": "1.1.7",
+    "@agentclientprotocol/sdk": "1.3.0",
+    "cross-spawn": "^7.0.6",
+    "yaml": "^2.8.1",
+    "@borgee/plugin-sdk": "0.2.4"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^24.3.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.5"
+  },
   "scripts": {
     "predev": "pnpm --filter @borgee/plugin-sdk build",
     "dev": "tsx src/index.ts",
@@ -33,18 +48,5 @@
     "pretest": "pnpm --filter @borgee/plugin-sdk build",
     "test": "vitest run --testTimeout=10000",
     "pretypecheck": "pnpm --filter @borgee/plugin-sdk build"
-  },
-  "dependencies": {
-    "@agentclientprotocol/sdk": "^1.2.1",
-    "@borgee/plugin-sdk": "0.1.5",
-    "cross-spawn": "^7.0.6",
-    "yaml": "^2.8.1"
-  },
-  "devDependencies": {
-    "@types/cross-spawn": "^6.0.6",
-    "@types/node": "^24.3.0",
-    "tsx": "^4.20.5",
-    "typescript": "^5.9.3",
-    "vitest": "^4.1.5"
   }
-}
+}