@borgee/agents-host 0.2.2 → 0.2.28

package/dist/connections-state-store.js

@@ -0,0 +1,228 @@
+import { chmodSync, mkdirSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname } from 'node:path';
+import { HostLogger, summarizeError } from './debug.js';
+import { resolveConnectionsStatePath } from './state-paths.js';
+const DEFAULT_BUSY_TIMEOUT_MS = 5_000;
+const PRIVATE_STATE_FILE_MODE = 0o600;
+const require = createRequire(import.meta.url);
+function loadDatabaseSync() {
+    const sqliteModule = require('node:sqlite');
+    if (typeof sqliteModule.DatabaseSync !== 'function') {
+        throw new Error('node:sqlite DatabaseSync is unavailable');
+    }
+    return sqliteModule.DatabaseSync;
+}
+export class SqliteConnectionsStateStore {
+    options;
+    database = null;
+    closed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    loadProviderSessions(provider, agentId) {
+        const rows = this.ensureDatabase().prepare(`SELECT channel_id, session_id
+         FROM provider_channel_sessions
+        WHERE provider = ? AND agent_id = ?
+        ORDER BY channel_id ASC`).all(provider, agentId);
+        return Object.fromEntries(rows.map((row) => [row.channel_id, row.session_id]));
+    }
+    saveProviderSessions(provider, agentId, sessions) {
+        const database = this.ensureDatabase();
+        const entries = Object.entries(sessions).sort(([left], [right]) => left.localeCompare(right));
+        database.exec('BEGIN IMMEDIATE');
+        try {
+            database.prepare(`DELETE FROM provider_channel_sessions
+          WHERE provider = ? AND agent_id = ?`).run(provider, agentId);
+            if (entries.length > 0) {
+                const insert = database.prepare(`INSERT INTO provider_channel_sessions (provider, agent_id, channel_id, session_id)
+           VALUES (?, ?, ?, ?)`);
+                for (const [channelId, sessionId] of entries) {
+                    insert.run(provider, agentId, channelId, sessionId);
+                }
+            }
+            database.exec('COMMIT');
+        }
+        catch (error) {
+            database.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    hasTokenBinding(token) {
+        const row = this.ensureDatabase().prepare(`SELECT 1
+         FROM channel_token_bindings
+        WHERE token = ?
+        LIMIT 1`).get(token);
+        return row != null;
+    }
+    loadTokenBinding(token) {
+        const row = this.ensureDatabase().prepare(`SELECT token, agent_id, channel_id
+         FROM channel_token_bindings
+        WHERE token = ? AND revoked_at IS NULL`).get(token);
+        if (!row) {
+            return null;
+        }
+        return {
+            token: row.token,
+            agentId: row.agent_id,
+            channelId: row.channel_id,
+        };
+    }
+    loadTokenBindingForChannel(agentId, channelId) {
+        const row = this.ensureDatabase().prepare(`SELECT token, agent_id, channel_id
+         FROM channel_token_bindings
+        WHERE agent_id = ? AND channel_id = ? AND revoked_at IS NULL
+        ORDER BY rowid DESC
+        LIMIT 1`).get(agentId, channelId);
+        if (!row) {
+            return null;
+        }
+        return {
+            token: row.token,
+            agentId: row.agent_id,
+            channelId: row.channel_id,
+        };
+    }
+    replaceTokenBinding(binding) {
+        const database = this.ensureDatabase();
+        database.exec('BEGIN IMMEDIATE');
+        try {
+            const bindingByToken = this.loadStoredTokenBinding(binding.token);
+            if (bindingByToken) {
+                if (bindingByToken.revokedAt != null) {
+                    throw new Error(`channel token ${binding.token} was revoked and cannot be reused`);
+                }
+                if (bindingByToken.agentId !== binding.agentId || bindingByToken.channelId !== binding.channelId) {
+                    throw new Error(`channel token is already bound to ${bindingByToken.agentId}/${bindingByToken.channelId}`);
+                }
+            }
+            database.prepare(`UPDATE channel_token_bindings
+            SET revoked_at = unixepoch()
+          WHERE agent_id = ? AND channel_id = ? AND token <> ? AND revoked_at IS NULL`).run(binding.agentId, binding.channelId, binding.token);
+            database.prepare(`INSERT INTO channel_token_bindings (token, agent_id, channel_id, revoked_at)
+         VALUES (?, ?, ?, NULL)
+         ON CONFLICT(token) DO UPDATE SET
+           agent_id = excluded.agent_id,
+           channel_id = excluded.channel_id,
+           revoked_at = NULL`).run(binding.token, binding.agentId, binding.channelId);
+            database.exec('COMMIT');
+        }
+        catch (error) {
+            database.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    deleteTokenBinding(token) {
+        this.ensureDatabase().prepare(`DELETE FROM channel_token_bindings
+        WHERE token = ?`).run(token);
+    }
+    revokeTokenBinding(token) {
+        this.ensureDatabase().prepare(`UPDATE channel_token_bindings
+          SET revoked_at = unixepoch()
+        WHERE token = ? AND revoked_at IS NULL`).run(token);
+    }
+    revokeAllTokenBindings() {
+        this.ensureDatabase().exec('UPDATE channel_token_bindings SET revoked_at = unixepoch() WHERE revoked_at IS NULL');
+    }
+    close() {
+        this.database?.close();
+        this.database = null;
+        this.closed = true;
+    }
+    ensureDatabase() {
+        if (this.closed) {
+            throw new Error('connections state store is closed');
+        }
+        if (this.database) {
+            return this.database;
+        }
+        const path = (this.options.resolveDatabasePath ?? resolveConnectionsStatePath)(this.options.stateRootDir);
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        const database = (this.options.openDatabase ?? ((databasePath) => new (loadDatabaseSync())(databasePath)))(path);
+        try {
+            chmodSync(path, PRIVATE_STATE_FILE_MODE);
+            database.exec(`PRAGMA busy_timeout = ${this.options.busyTimeoutMs ?? DEFAULT_BUSY_TIMEOUT_MS}`);
+            database.exec('PRAGMA journal_mode = DELETE');
+            database.exec(`CREATE TABLE IF NOT EXISTS provider_channel_sessions (
+           provider TEXT NOT NULL,
+           agent_id TEXT NOT NULL,
+           channel_id TEXT NOT NULL,
+           session_id TEXT NOT NULL,
+           PRIMARY KEY (provider, agent_id, channel_id)
+         )`);
+            database.exec(`CREATE TABLE IF NOT EXISTS channel_token_bindings (
+           token TEXT PRIMARY KEY,
+           agent_id TEXT NOT NULL,
+           channel_id TEXT NOT NULL,
+           revoked_at INTEGER
+         )`);
+            const columns = database.prepare(`SELECT name
+           FROM pragma_table_info('channel_token_bindings')
+          WHERE name = 'revoked_at'
+          LIMIT 1`).all();
+            if (columns.length === 0) {
+                database.exec('ALTER TABLE channel_token_bindings ADD COLUMN revoked_at INTEGER');
+            }
+        }
+        catch (error) {
+            database.close();
+            throw error;
+        }
+        this.database = database;
+        return database;
+    }
+    loadStoredTokenBinding(token) {
+        const row = this.ensureDatabase().prepare(`SELECT token, agent_id, channel_id, revoked_at
+         FROM channel_token_bindings
+        WHERE token = ?`).get(token);
+        if (!row) {
+            return null;
+        }
+        return {
+            token: row.token,
+            agentId: row.agent_id,
+            channelId: row.channel_id,
+            revokedAt: row.revoked_at,
+        };
+    }
+}
+export class ConnectionsStateBackedChannelSessionStore {
+    options;
+    logger;
+    constructor(options) {
+        this.options = options;
+        this.logger = options.logger ?? new HostLogger();
+    }
+    async load(agentId) {
+        return this.options.legacyStore.load(agentId);
+    }
+    async save(agentId, sessions) {
+        await this.options.legacyStore.save(agentId, sessions);
+        if (!this.options.sqliteStateStore) {
+            return;
+        }
+        try {
+            this.options.sqliteStateStore.saveProviderSessions(this.options.provider, agentId, sessions);
+        }
+        catch (error) {
+            this.logger.error(`failed to mirror ${this.options.provider} session map into connections state`, {
+                provider: this.options.provider,
+                error: summarizeError(error),
+            });
+        }
+    }
+    close() {
+        this.options.sqliteStateStore?.close();
+        this.options.legacyStore.close?.();
+    }
+}
+export function createProviderConnectionsSessionStore(options) {
+    return new ConnectionsStateBackedChannelSessionStore({
+        provider: options.provider,
+        legacyStore: options.legacyStore,
+        sqliteStateStore: options.gateEnabled
+            ? new SqliteConnectionsStateStore({ stateRootDir: options.stateRootDir })
+            : undefined,
+        logger: options.logger,
+    });
+}

package/dist/context/attention.d.ts

@@ -0,0 +1,12 @@
+import type { AttentionClaimActivation, AttentionClaimContext, AttentionClaimState, AttentionDeliveryMode, AttentionSnapshot, AttentionWakeMode } from '../types.js';
+export declare function deriveAttentionWakeMode(snapshot: Pick<AttentionSnapshot, 'deliveryMode' | 'claimState' | 'claimActivation'>): AttentionWakeMode;
+export declare function buildNormalizedAttentionSnapshot(params?: {
+    deliveryMode?: AttentionDeliveryMode;
+    claimState?: AttentionClaimState;
+    claimActivation?: AttentionClaimActivation;
+    observedAt?: number;
+    turnExecutionId?: string;
+    claimContext?: AttentionClaimContext;
+}): AttentionSnapshot;
+export declare function parsePersistedAttentionSnapshot(raw: unknown): AttentionSnapshot;
+export declare function buildAttentionSummaryLines(snapshot: AttentionSnapshot | undefined): string[];

package/dist/context/attention.js

@@ -0,0 +1,137 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isDeliveryMode(value) {
+    return value === 'default' || value === 'follow' || value === 'muted';
+}
+function isClaimState(value) {
+    return value === 'unclaimed' || value === 'claimed';
+}
+function isClaimActivation(value) {
+    return value === 'inactive' || value === 'active' || value === 'dormant';
+}
+function isUsableTaskId(value) {
+    return value.length > 0 && !/[\u0000-\u001f\u007f\s]/u.test(value);
+}
+function normalizeClaimContext(value) {
+    if (!isRecord(value) || typeof value.scope !== 'string' || typeof value.taskId !== 'string') {
+        return undefined;
+    }
+    const taskId = value.taskId.trim();
+    if (value.scope === 'task-thread') {
+        return isUsableTaskId(taskId) ? { scope: 'task-thread', taskId } : undefined;
+    }
+    if (value.scope === 'channel') {
+        return isUsableTaskId(taskId) ? { scope: 'channel', taskId } : undefined;
+    }
+    return undefined;
+}
+export function deriveAttentionWakeMode(snapshot) {
+    if (snapshot.deliveryMode === 'muted') {
+        return 'mute-non-mention';
+    }
+    if (snapshot.deliveryMode === 'follow') {
+        return 'follow-visible-human';
+    }
+    if (snapshot.claimState === 'claimed' && snapshot.claimActivation === 'active') {
+        return 'follow-visible-human';
+    }
+    return 'current-policy';
+}
+export function buildNormalizedAttentionSnapshot(params) {
+    let deliveryMode = params?.deliveryMode ?? 'default';
+    let claimState = params?.claimState ?? 'unclaimed';
+    let claimActivation = params?.claimActivation ?? 'inactive';
+    let claimContext = params?.claimContext;
+    if (claimState === 'unclaimed') {
+        claimActivation = 'inactive';
+        claimContext = undefined;
+    }
+    else if (claimActivation === 'inactive') {
+        claimState = 'unclaimed';
+        claimContext = undefined;
+    }
+    if (claimActivation === 'dormant') {
+        deliveryMode = 'default';
+    }
+    if (claimContext?.scope === 'task-thread' && !isUsableTaskId(claimContext.taskId)) {
+        claimState = 'unclaimed';
+        claimActivation = 'inactive';
+        claimContext = undefined;
+        deliveryMode = 'default';
+    }
+    const snapshot = {
+        source: 'host-observed',
+        deliveryMode,
+        claimState,
+        claimActivation,
+        wakeMode: deriveAttentionWakeMode({
+            deliveryMode,
+            claimState,
+            claimActivation,
+        }),
+        observedAt: params?.observedAt ?? Date.now(),
+        ...(params?.turnExecutionId ? { turnExecutionId: params.turnExecutionId } : {}),
+        ...(claimContext ? { claimContext } : {}),
+    };
+    return snapshot;
+}
+export function parsePersistedAttentionSnapshot(raw) {
+    if (!isRecord(raw)) {
+        return buildNormalizedAttentionSnapshot();
+    }
+    const deliveryMode = isDeliveryMode(raw.deliveryMode) ? raw.deliveryMode : 'default';
+    const claimState = isClaimState(raw.claimState) ? raw.claimState : 'unclaimed';
+    const claimActivation = isClaimActivation(raw.claimActivation) ? raw.claimActivation : 'inactive';
+    const observedAt = typeof raw.observedAt === 'number' && Number.isFinite(raw.observedAt)
+        ? raw.observedAt
+        : Date.now();
+    const turnExecutionId = typeof raw.turnExecutionId === 'string' && raw.turnExecutionId.trim().length > 0
+        ? raw.turnExecutionId
+        : undefined;
+    const claimContext = normalizeClaimContext(raw.claimContext);
+    const normalized = buildNormalizedAttentionSnapshot({
+        deliveryMode,
+        claimState,
+        claimActivation,
+        observedAt,
+        turnExecutionId,
+        claimContext,
+    });
+    if (normalized.claimContext?.scope === 'task-thread') {
+        return buildNormalizedAttentionSnapshot({
+            deliveryMode: 'default',
+            claimState: normalized.claimState,
+            claimActivation: 'dormant',
+            observedAt: normalized.observedAt,
+            turnExecutionId: normalized.turnExecutionId,
+            claimContext: normalized.claimContext,
+        });
+    }
+    return normalized;
+}
+function formatObservedAt(observedAt) {
+    return new Date(observedAt).toISOString();
+}
+export function buildAttentionSummaryLines(snapshot) {
+    if (!snapshot) {
+        return [];
+    }
+    return [
+        'Host-observed attention snapshot for this channel (projection only; not server-authoritative truth).',
+        `Delivery mode: ${snapshot.deliveryMode}`,
+        `Claim state: ${snapshot.claimState}`,
+        `Claim activation: ${snapshot.claimActivation}`,
+        `Wake mode: ${snapshot.wakeMode}`,
+        ...(snapshot.claimContext
+            ? [
+                `Claim scope: ${snapshot.claimContext.scope}`,
+                `Claim task id: ${snapshot.claimContext.taskId}`,
+            ]
+            : []),
+        `Observed at: ${formatObservedAt(snapshot.observedAt)}`,
+        ...(snapshot.turnExecutionId
+            ? [`Observed turn execution id: ${snapshot.turnExecutionId}`]
+            : []),
+    ];
+}

package/dist/context/collaboration-capabilities-diagnostics.d.ts

@@ -0,0 +1,3 @@
+import type { CollaborationCapabilityDeclaration, MissedCollaborationDiagnostic } from '../types.js';
+export declare function buildCollaborationCapabilityDeclarationSummaryLines(declaration: CollaborationCapabilityDeclaration | undefined): string[];
+export declare function buildMissedCollaborationDiagnosticSummaryLines(diagnostic: MissedCollaborationDiagnostic | undefined): string[];

package/dist/context/collaboration-capabilities-diagnostics.js

@@ -0,0 +1,18 @@
+export function buildCollaborationCapabilityDeclarationSummaryLines(declaration) {
+    if (!declaration) {
+        return [];
+    }
+    return [
+        'Shared hosted collaboration capability declaration (projection only; hosted-path vocabulary only, not authorization, action availability, thread-binding authority, or standalone-runtime parity).',
+        `Capability declaration: ${JSON.stringify(declaration)}`,
+    ];
+}
+export function buildMissedCollaborationDiagnosticSummaryLines(diagnostic) {
+    if (!diagnostic) {
+        return [];
+    }
+    return [
+        'Latest hosted missed-collaboration diagnostic (projection only; delivery, wake, or response explanation only).',
+        `Missed-collaboration diagnostic: ${JSON.stringify(diagnostic)}`,
+    ];
+}

package/dist/context/collaboration-outcome.d.ts

@@ -0,0 +1,2 @@
+import type { CollaborationOutcomeSnapshot } from '../types.js';
+export declare function buildCollaborationOutcomeSummaryLines(snapshot: CollaborationOutcomeSnapshot | undefined): string[];

package/dist/context/collaboration-outcome.js

@@ -0,0 +1,26 @@
+function formatObservedAt(observedAt) {
+    return new Date(observedAt).toISOString();
+}
+export function buildCollaborationOutcomeSummaryLines(snapshot) {
+    if (!snapshot) {
+        return [];
+    }
+    return [
+        'Host-observed collaboration outcome snapshot for this channel (projection only; not provider-authoritative truth).',
+        `Response state: ${snapshot.responseState}`,
+        `Delivery state: ${snapshot.deliveryState}`,
+        ...(snapshot.wakeState ? [`Wake state: ${snapshot.wakeState}`] : []),
+        ...(snapshot.blockedDetails
+            ? [
+                `Blocked question: ${snapshot.blockedDetails.question}`,
+                ...(snapshot.blockedDetails.reason
+                    ? [`Blocked reason: ${snapshot.blockedDetails.reason}`]
+                    : []),
+            ]
+            : []),
+        `Observed at: ${formatObservedAt(snapshot.observedAt)}`,
+        ...(snapshot.turnExecutionId
+            ? [`Observed turn execution id: ${snapshot.turnExecutionId}`]
+            : []),
+    ];
+}

package/dist/context/injection.d.ts

@@ -0,0 +1,134 @@
+import type { AttentionSnapshot, CollaborationCapabilityDeclaration, CollaborationOutcomeSnapshot, LocalhostGatewayBootstrapMetadata, MissedCollaborationDiagnostic, ProviderCollaborationContext, SkillRuntimeBootstrapMetadata, TaskThreadCollaborationContract, TaskAssignmentThreadContext, TaskWorkspaceContext } from '../types.js';
+export interface SkillRuntimeBootstrapPayload {
+    skillDirectoryPath: string;
+    nodeCliPath: string;
+    pythonCliPath: string;
+}
+export interface ChannelContextPayload {
+    schemaVersion: 1;
+    channelId: string;
+    collaborationOutcome?: CollaborationOutcomeSnapshot;
+    attentionSnapshot?: AttentionSnapshot;
+    taskThreadCollaborationContract?: TaskThreadCollaborationContract;
+    collaborationCapabilities?: CollaborationCapabilityDeclaration;
+    missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
+    skillRuntime?: SkillRuntimeBootstrapPayload;
+    localhostGateway?: LocalhostGatewayBootstrapMetadata;
+    taskAssignmentContext?: TaskAssignmentThreadContext;
+    taskWorkspace?: TaskWorkspaceContext;
+}
+export interface PreparedChannelContext {
+    directoryPath: string;
+    payload: ChannelContextPayload;
+    payloadPath?: string;
+    gatewayAuthPath?: string;
+    skillRuntime?: SkillRuntimeBootstrapMetadata;
+    localhostGateway?: LocalhostGatewayBootstrapMetadata;
+    taskWorkspace?: TaskWorkspaceContext;
+}
+export declare class ChannelContextPreparationError extends Error {
+    readonly partialContext: PreparedChannelContext;
+    constructor(message: string, partialContext: PreparedChannelContext, options?: ErrorOptions);
+}
+export interface ChannelContextStore {
+    prepare(input: {
+        channelId: string;
+        collaboration?: ProviderCollaborationContext;
+        collaborationOutcome?: CollaborationOutcomeSnapshot;
+        attentionSnapshot?: AttentionSnapshot;
+        taskThreadCollaborationContract?: TaskThreadCollaborationContract;
+        collaborationCapabilities?: CollaborationCapabilityDeclaration;
+        missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
+        incomingMessageType?: string;
+        incomingContent?: string;
+    }): Promise<PreparedChannelContext>;
+    prepare(channelId: string, options?: {
+        collaboration?: ProviderCollaborationContext;
+        collaborationOutcome?: CollaborationOutcomeSnapshot;
+        attentionSnapshot?: AttentionSnapshot;
+        taskThreadCollaborationContract?: TaskThreadCollaborationContract;
+        collaborationCapabilities?: CollaborationCapabilityDeclaration;
+        missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
+        incomingMessageType?: string;
+        incomingContent?: string;
+    }): Promise<PreparedChannelContext>;
+}
+export interface SkillAssetResolver {
+    resolve(): Promise<SkillRuntimeBootstrapMetadata>;
+}
+export interface LocalhostGatewayContextPublisher {
+    resolveBootstrap(channelId: string, options?: {
+        collaboration?: {
+            enabled: boolean;
+            turnExecutionId: string;
+        };
+    }): LocalhostGatewayBootstrapMetadata & {
+        token: string;
+        turnExecutionId?: string;
+    };
+    publishPayload(channelId: string, payloadPath: string, payload: ChannelContextPayload): void;
+    clearChannel(channelId: string): void;
+}
+interface ContextFileSystem {
+    mkdir(path: string, options?: {
+        mode?: number;
+        recursive?: boolean;
+    }): Promise<void>;
+    readdir(path: string): Promise<string[]>;
+    readFile(path: string, options: {
+        encoding: BufferEncoding;
+    } | BufferEncoding): Promise<string>;
+    writeFile(path: string, data: string, options?: {
+        encoding?: BufferEncoding;
+        mode?: number;
+    }): Promise<void>;
+    unlink(path: string): Promise<void>;
+    access(path: string): Promise<void>;
+}
+interface FileChannelContextStoreOptions {
+    fileSystem?: ContextFileSystem;
+    skillRuntimeEnabled?: boolean;
+    skillAssetResolver?: SkillAssetResolver;
+    localhostGateway?: LocalhostGatewayContextPublisher;
+    taskWorkspaceRootDir?: string;
+}
+export declare function extractTaskIdFromTaskAssignmentContent(incomingContent: string | undefined): string | undefined;
+export declare function encodeChannelPathSegment(channelId: string): string;
+export declare function resolveChannelContextDirectory(stateRootDir: string, channelId: string): string;
+export declare function resolveChannelContextPayloadPath(stateRootDir: string, channelId: string): string;
+export declare function resolveTaskWorkspaceRootDirectory(startupWorkspaceRootDir: string): string;
+export declare function resolveTaskWorkspaceDirectory(startupWorkspaceRootDir: string, channelId: string, taskId: string): string;
+export declare function resolveChannelContextGatewayAuthPath(stateRootDir: string, channelId: string, turnExecutionId?: string): string;
+export declare function resolveGatewayAuthPathFromPayloadPath(payloadPath: string): string;
+export declare function resolveBorgeeAgentSkillRuntimeAssets(moduleUrl: string, fileSystem?: Pick<ContextFileSystem, 'access'>): Promise<SkillRuntimeBootstrapMetadata>;
+export declare class FileChannelContextStore implements ChannelContextStore {
+    private readonly stateRootDir;
+    private readonly fileSystem;
+    private readonly skillRuntimeEnabled;
+    private readonly skillAssetResolver;
+    private readonly localhostGateway?;
+    private readonly startupWorkspaceRootDir;
+    constructor(stateRootDir: string, options?: FileChannelContextStoreOptions);
+    prepare(inputOrChannelId: {
+        channelId: string;
+        collaboration?: ProviderCollaborationContext;
+        collaborationOutcome?: CollaborationOutcomeSnapshot;
+        attentionSnapshot?: AttentionSnapshot;
+        taskThreadCollaborationContract?: TaskThreadCollaborationContract;
+        collaborationCapabilities?: CollaborationCapabilityDeclaration;
+        missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
+        incomingMessageType?: string;
+        incomingContent?: string;
+    } | string, options?: {
+        collaboration?: ProviderCollaborationContext;
+        collaborationOutcome?: CollaborationOutcomeSnapshot;
+        attentionSnapshot?: AttentionSnapshot;
+        taskThreadCollaborationContract?: TaskThreadCollaborationContract;
+        collaborationCapabilities?: CollaborationCapabilityDeclaration;
+        missedCollaborationDiagnostic?: MissedCollaborationDiagnostic;
+        incomingMessageType?: string;
+        incomingContent?: string;
+    }): Promise<PreparedChannelContext>;
+    private resolveSkillRuntimeBestEffort;
+}
+export {};