@borgee/agents-host 0.2.35 → 0.2.44

package/dist/providers/codex/project-doc.js

@@ -1,36 +1,27 @@
-import { basename } from 'node:path';
 import { buildAttentionSummaryLines } from '../../context/attention.js';
 import { buildCollaborationCapabilityDeclarationSummaryLines, buildMissedCollaborationDiagnosticSummaryLines, } from '../../context/collaboration-capabilities-diagnostics.js';
 import { buildCollaborationOutcomeSummaryLines } from '../../context/collaboration-outcome.js';
 import { MAIN_SESSION_DELEGATION_LINES } from '../../context/main-session-delegation.js';
+import { buildSkillManualLines } from '../../context/skill-manual.js';
 import { buildTaskThreadCollaborationSummaryLines } from '../../context/task-thread-collaboration.js';
 const PROJECT_DOC_MAX_BYTES = 32 * 1024;
+// Every command the CLI carries needs the gateway credential file, so the capability is only
+// worth naming in a workspace that also names one; otherwise the model is handed an invocation
+// template it cannot fill.
 function buildSkillRuntimeLines(context) {
-    if (!context?.skillRuntime || !context.channelContextPayloadPath) {
+    if (!context?.skillRuntime || !context.gatewayCredentialPath) {
         return [];
     }
-    return [
-        'Read-only local skill runtime bootstrap is available in this workspace.',
-        `Context payload: ${context.channelContextPayloadPath}`,
-        `Skill guide: ${context.skillRuntime.skillMarkdownPath}`,
-        `Node CLI: node ${context.skillRuntime.nodeCliPath} --context ${context.channelContextPayloadPath} --print-bootstrap`,
-        `Python CLI: python3 ${context.skillRuntime.pythonCliPath} --context ${context.channelContextPayloadPath} --print-bootstrap`,
-        'These CLIs are local-only, may only access the loopback gateway surfaced by the host, and must not mutate files or the local environment.',
-    ];
+    return buildSkillManualLines(context.skillRuntime);
 }
-function buildGatewayLines(context) {
-    if (!context?.localhostGateway || !context.channelContextPayloadPath) {
+// The credential file is the whole handoff: it carries the gateway's base URL along with the
+// channel id and the token, and the CLI reads all three out of it. Naming the base URL separately
+// would only invite a hand-rolled request that carries the token off the CLI's one path.
+function buildGatewayCredentialLines(context) {
+    if (!context?.localhostGateway || !context.gatewayCredentialPath) {
         return [];
     }
-    const lines = [
-        'A loopback-only localhost gateway may be available for this channel.',
-        `Gateway base URL: ${context.localhostGateway.baseUrl}`,
-        'Use the packaged local CLI with the context payload above for gateway access.',
-    ];
-    if (context.gatewayAuthPath) {
-        lines.push(`Per-turn gateway auth sidecar: ${context.gatewayAuthPath}`, 'If a later turn prompt advertises a different auth sidecar path, prefer the prompt-visible path for that turn.');
-    }
-    return lines;
+    return [`Gateway credential file: ${context.gatewayCredentialPath}`];
 }
 export function buildCodexProjectDocument(context) {
     const lines = [
@@ -40,13 +31,6 @@ export function buildCodexProjectDocument(context) {
         'Keep visible replies concise, do not claim actions you did not perform, and prefer the per-turn prompt when it provides newer turn-local details.',
         '',
         ...MAIN_SESSION_DELEGATION_LINES,
-        ...(context?.channelContextPayloadPath
-            ? [
-                '',
-                `Context payload file: ${context.channelContextPayloadPath}`,
-                `Workspace anchor: ${basename(context.channelContextPayloadPath)}`,
-            ]
-            : []),
         ...(context?.taskWorkspace
             ? [
                 '',
@@ -79,7 +63,7 @@ export function buildCodexProjectDocument(context) {
             return skillRuntimeLines.length > 0 ? ['', ...skillRuntimeLines] : [];
         })(),
         ...(() => {
-            const gatewayLines = buildGatewayLines(context);
+            const gatewayLines = buildGatewayCredentialLines(context);
             return gatewayLines.length > 0 ? ['', ...gatewayLines] : [];
         })(),
     ];

package/dist/providers/copilot/adapter.d.ts

@@ -1,10 +1,12 @@
-import type { ProviderAdapter } from '../provider-adapter.js';
+import { type ProviderAdapter } from '../provider-adapter.js';
 import type { ProviderGenerateOptions, ProviderInput, ProviderReply } from '../../types.js';
 import { ProviderTurnPreparer } from '../../context/turn-preparation.js';
 import { CopilotCliClient } from './cli-client.js';
+export declare const COPILOT_HOSTED_PROVIDER_CAPABILITIES: import("../provider-adapter.js").ProviderCapabilities;
 export declare class CopilotProviderAdapter implements ProviderAdapter {
     private readonly cli;
     private readonly turnPreparer;
+    readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
     constructor(cli: CopilotCliClient, turnPreparer: ProviderTurnPreparer);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     dispose(): Promise<void>;

package/dist/providers/copilot/adapter.js

@@ -1,7 +1,17 @@
+import { createHostedProviderCapabilities } from '../provider-adapter.js';
 import { createAwaitingUserProgressHandler, parseProviderReply } from '../awaiting-user.js';
+export const COPILOT_HOSTED_PROVIDER_CAPABILITIES = createHostedProviderCapabilities({
+    imageInputTransport: {
+        source: 'transport-derived',
+        support: 'supported',
+        reason: 'real-media-delivered',
+        delivery: ['blob'],
+    },
+});
 export class CopilotProviderAdapter {
     cli;
     turnPreparer;
+    capabilities = COPILOT_HOSTED_PROVIDER_CAPABILITIES;
     constructor(cli, turnPreparer) {
         this.cli = cli;
         this.turnPreparer = turnPreparer;

package/dist/providers/copilot/cli-client.d.ts

@@ -17,12 +17,17 @@ interface CopilotAcpRuntime {
     idleShutdownGracePeriodMs: number;
     shutdownGracePeriodMs: number;
     shutdownForceKillWaitMs: number;
+    fetch(input: string | URL, init?: RequestInit): Promise<Response>;
 }
 interface CopilotPermissionPolicyOptions {
     gateEnabled?: boolean;
     policyMode?: InternalPolicyMode;
     auditSink?: AuthorizationAuditSinkLike;
 }
+interface CopilotHostedImageInputConfig {
+    borgeeBaseUrl?: string;
+    agentApiKey?: string;
+}
 /**
  * Persistent ACP-backed client for the GitHub Copilot CLI (`copilot --acp`).
  *
@@ -37,6 +42,7 @@ export declare class CopilotCliClient {
     private readonly resolveSessionStoreAgentId;
     private readonly logger;
     private readonly permissionPolicy;
+    private readonly imageInputConfig;
     private readonly runtime;
     private readonly channels;
     /**
@@ -72,7 +78,7 @@ export declare class CopilotCliClient {
     private sessionStoreWriteQueue;
     private sessionCapabilities;
     private readonly idleBackendShutdown;
-    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>, sessionStore?: CopilotChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger, permissionPolicy?: CopilotPermissionPolicyOptions);
+    constructor(command: string, _ignoredArgs?: string[], runtimeOverrides?: Partial<CopilotAcpRuntime>, sessionStore?: CopilotChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger, permissionPolicy?: CopilotPermissionPolicyOptions, imageInputConfig?: CopilotHostedImageInputConfig);
     generateReply(turn: PreparedProviderTurnInput, options?: ProviderGenerateOptions): Promise<string>;
     generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
     dispose(): Promise<void>;
@@ -86,6 +92,8 @@ export declare class CopilotCliClient {
     private restoreSession;
     private clearBufferedSessionReplay;
     private resolveSessionCwd;
+    private buildPromptInput;
+    private fetchImageBlock;
     private recycleSessionIfCwdChanged;
     private runTurn;
     private raceWithFatal;

package/dist/providers/copilot/cli-client.js

@@ -30,6 +30,7 @@ const DEFAULT_RUNTIME = {
     idleShutdownGracePeriodMs: DEFAULT_IDLE_SHUTDOWN_GRACE_PERIOD_MS,
     shutdownGracePeriodMs: DEFAULT_SHUTDOWN_GRACE_PERIOD_MS,
     shutdownForceKillWaitMs: DEFAULT_SHUTDOWN_FORCE_KILL_WAIT_MS,
+    fetch: async (input, init) => fetch(input, init),
 };
 const DEFAULT_SESSION_CAPABILITIES = {
     loadSession: false,
@@ -38,6 +39,28 @@ const DEFAULT_SESSION_CAPABILITIES = {
 function hasVisibleText(value) {
     return typeof value === 'string' && value.trim().length > 0;
 }
+function isAbsoluteHttpUrl(value) {
+    return value.startsWith('http://') || value.startsWith('https://');
+}
+function resolveHostedAttachmentUrl(rawUrl, borgeeBaseUrl) {
+    if (isAbsoluteHttpUrl(rawUrl)) {
+        return rawUrl;
+    }
+    const base = borgeeBaseUrl.replace(/\/$/, '');
+    const path = rawUrl.startsWith('/') ? rawUrl : `/${rawUrl}`;
+    return `${base}${path}`;
+}
+function isSameOrigin(left, right) {
+    try {
+        return new URL(left).origin === new URL(right).origin;
+    }
+    catch {
+        return false;
+    }
+}
+function asImagePart(part) {
+    return part.type === 'image' ? part : null;
+}
 function formatToolProgress(title, status) {
     const normalizedTitle = hasVisibleText(title) ? title.trim() : null;
     switch (status) {
@@ -116,7 +139,7 @@ class CopilotProgressCollector {
         this.onProgress({ text });
     }
 }
-function createDeferredTurn(channelId, prompt, sessionPersistence, promptContext, options) {
+function createDeferredTurn(channelId, preparedTurn, sessionPersistence, options) {
     let settled = false;
     let resolvePromise;
     let rejectPromise;
@@ -126,9 +149,8 @@ function createDeferredTurn(channelId, prompt, sessionPersistence, promptContext
     });
     return {
         channelId,
-        prompt,
+        preparedTurn,
         sessionPersistence,
-        promptContext,
         options,
         promise,
         resolve(value) {
@@ -216,6 +238,7 @@ export class CopilotCliClient {
     resolveSessionStoreAgentId;
     logger;
     permissionPolicy;
+    imageInputConfig;
     runtime;
     channels = new Map();
     /**
@@ -253,12 +276,13 @@ export class CopilotCliClient {
     sessionStoreWriteQueue = Promise.resolve();
     sessionCapabilities = DEFAULT_SESSION_CAPABILITIES;
     idleBackendShutdown;
-    constructor(command, _ignoredArgs = [], runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined, logger = new HostLogger(), permissionPolicy = {}) {
+    constructor(command, _ignoredArgs = [], runtimeOverrides = {}, sessionStore, resolveSessionStoreAgentId = () => undefined, logger = new HostLogger(), permissionPolicy = {}, imageInputConfig = {}) {
         this.command = command;
         this.sessionStore = sessionStore;
         this.resolveSessionStoreAgentId = resolveSessionStoreAgentId;
         this.logger = logger;
         this.permissionPolicy = permissionPolicy;
+        this.imageInputConfig = imageInputConfig;
         this.runtime = { ...DEFAULT_RUNTIME, ...runtimeOverrides };
         this.idleBackendShutdown = new IdleBackendShutdownScheduler({
             idleShutdownMs: this.runtime.idleBackendShutdownMs,
@@ -279,12 +303,19 @@ export class CopilotCliClient {
         if (this.fatalError) {
             throw this.fatalError;
         }
-        const preparedTurn = typeof channelIdOrTurn === 'string'
+        const preparedTurnBase = typeof channelIdOrTurn === 'string'
             ? {
                 channelId: channelIdOrTurn,
+                incomingContent: '',
+                incomingParts: [],
                 prompt: typeof promptOrOptions === 'string' ? promptOrOptions : '',
             }
             : channelIdOrTurn;
+        const preparedTurn = {
+            ...preparedTurnBase,
+            incomingContent: preparedTurnBase.incomingContent ?? '',
+            incomingParts: preparedTurnBase.incomingParts ?? [],
+        };
         const options = typeof channelIdOrTurn === 'string'
             ? maybeOptions
             : promptOrOptions;
@@ -292,7 +323,7 @@ export class CopilotCliClient {
         const state = this.getOrCreateChannelState(sessionRouting.key, preparedTurn.channelId, sessionRouting.persistence);
         this.clearIdleTimer(state);
         this.idleBackendShutdown.cancel();
-        const turn = createDeferredTurn(preparedTurn.channelId, preparedTurn.prompt, sessionRouting.persistence, preparedTurn.promptContext, options);
+        const turn = createDeferredTurn(preparedTurn.channelId, preparedTurn, sessionRouting.persistence, options);
         state.queue.push(turn);
         this.processChannelQueue(sessionRouting.key, state);
         return turn.promise;
@@ -455,13 +486,14 @@ export class CopilotCliClient {
                     }
                     state.activeTurn = turn;
                     try {
-                        state.cwd = await this.resolveSessionCwd(turn.promptContext);
+                        state.cwd = await this.resolveSessionCwd(turn.preparedTurn.promptContext);
                         await this.ensureStarted();
                         await this.recycleSessionIfCwdChanged(channelId, state);
                         const session = await this.getOrCreateSession(channelId, state);
                         let reply;
                         try {
-                            reply = await this.runTurn(session, turn.prompt, turn.options);
+                            const promptInput = await this.buildPromptInput(turn.preparedTurn);
+                            reply = await this.runTurn(session, promptInput, turn.options);
                         }
                         catch (error) {
                             if (isSessionTainted(error)) {
@@ -617,6 +649,37 @@ export class CopilotCliClient {
     async resolveSessionCwd(promptContext) {
         return promptContext?.taskWorkspace?.rootPath ?? this.runtime.cwd;
     }
+    async buildPromptInput(turn) {
+        const imageParts = turn.incomingParts.map(asImagePart).filter((part) => part !== null);
+        if (imageParts.length === 0) {
+            return turn.prompt;
+        }
+        const imageBlocks = await Promise.all(imageParts.map(async (part) => this.fetchImageBlock(part.attachment.url, part.attachment.contentType)));
+        return [{ type: 'text', text: turn.prompt }, ...imageBlocks];
+    }
+    async fetchImageBlock(rawUrl, contentType) {
+        const baseUrl = this.imageInputConfig.borgeeBaseUrl?.trim();
+        const agentApiKey = this.imageInputConfig.agentApiKey?.trim();
+        if (!baseUrl || !agentApiKey) {
+            throw new Error('Copilot image input requires Borgee base URL and agent API key');
+        }
+        const resolvedUrl = resolveHostedAttachmentUrl(rawUrl, baseUrl);
+        if (!isSameOrigin(resolvedUrl, baseUrl)) {
+            throw new Error(`Copilot image input only supports Borgee-origin attachments: ${resolvedUrl}`);
+        }
+        const response = await this.runtime.fetch(resolvedUrl, {
+            headers: { Authorization: `Bearer ${agentApiKey}` },
+        });
+        if (!response.ok) {
+            throw new Error(`Copilot image fetch failed with ${response.status} ${response.statusText}`.trim());
+        }
+        return {
+            type: 'image',
+            mimeType: contentType,
+            data: Buffer.from(await response.arrayBuffer()).toString('base64'),
+            uri: response.url || resolvedUrl,
+        };
+    }
     async recycleSessionIfCwdChanged(channelId, state) {
         const session = state.session;
         if (!session) {

package/dist/providers/create-provider.d.ts

@@ -1,6 +1,6 @@
 import type { DebugLogger } from '../debug.js';
 import type { ProviderRuntimeConfig } from '../types.js';
-import type { ProviderAdapter } from './provider-adapter.js';
+import { type ProviderAdapter } from './provider-adapter.js';
 import type { LocalhostGatewayContextPublisher } from '../context/injection.js';
 import type { AuthorizationAuditSinkLike } from '../policy/authorization-audit.js';
 interface CreateProviderOptions {

package/dist/providers/create-provider.js

@@ -10,16 +10,18 @@ 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 { COPILOT_HOSTED_PROVIDER_CAPABILITIES, CopilotProviderAdapter } from './copilot/adapter.js';
 import { FileCopilotChannelSessionStore } from './copilot/session-store.js';
 import { resolveClaudeSessionMapPath, resolveCodexSessionMapPath, resolveCopilotSessionMapPath, } from '../state-paths.js';
 import { createAwaitingUserProgressHandler, parseProviderReply } from './awaiting-user.js';
 class ProviderV2CompatibilityAdapter {
     provider;
     turnPreparer;
-    constructor(provider, turnPreparer) {
+    capabilities;
+    constructor(provider, turnPreparer, capabilities) {
         this.provider = provider;
         this.turnPreparer = turnPreparer;
+        this.capabilities = capabilities;
     }
     async generateReply(input, options) {
         const preparedTurn = await this.turnPreparer.prepare(input);
@@ -69,7 +71,10 @@ function createClaudeProvider(config, debugLogger, connectionsStateGateEnabled,
         stateRootDir: config.stateRootDir,
         gateEnabled: connectionsStateGateEnabled,
         logger: debugLogger,
-    }), config.resolveStableAgentId, debugLogger);
+    }), config.resolveStableAgentId, debugLogger, {
+        borgeeBaseUrl: config.borgeeBaseUrl,
+        agentApiKey: config.agentApiKey,
+    });
     return new ClaudeProviderAdapter(cli, turnPreparer);
 }
 function createCopilotProvider(config, debugLogger, connectionsStateGateEnabled, implementation, turnPreparer, policyAuditGateEnabled, authorizationAuditSink, idleBackendShutdownMs) {
@@ -89,9 +94,12 @@ function createCopilotProvider(config, debugLogger, connectionsStateGateEnabled,
         gateEnabled: policyAuditGateEnabled,
         policyMode,
         auditSink: authorizationAuditSink,
+    }, {
+        borgeeBaseUrl: config.borgeeBaseUrl,
+        agentApiKey: config.agentApiKey,
     });
     return implementation === 'v2'
-        ? new ProviderV2CompatibilityAdapter(new CopilotProviderV2(cli), turnPreparer)
+        ? new ProviderV2CompatibilityAdapter(new CopilotProviderV2(cli), turnPreparer, COPILOT_HOSTED_PROVIDER_CAPABILITIES)
         : new CopilotProviderAdapter(cli, turnPreparer);
 }
 function createCodexProvider(config, debugLogger, connectionsStateGateEnabled, turnPreparer, idleBackendShutdownMs) {
@@ -103,7 +111,10 @@ function createCodexProvider(config, debugLogger, connectionsStateGateEnabled, t
         stateRootDir: config.stateRootDir,
         gateEnabled: connectionsStateGateEnabled,
         logger: debugLogger,
-    }), config.resolveStableAgentId, debugLogger);
+    }), config.resolveStableAgentId, debugLogger, {
+        borgeeBaseUrl: config.borgeeBaseUrl,
+        agentApiKey: config.agentApiKey,
+    });
     return new CodexProviderAdapter(cli, turnPreparer);
 }
 export function createProvider(config, debugLogger, options = {}) {

package/dist/providers/provider-adapter.d.ts

@@ -1,5 +1,40 @@
 import type { ProviderGenerateOptions, ProviderInput, ProviderReply } from '../types.js';
+export type ProviderImageInputSupport = 'supported' | 'metadata-only' | 'not-supported';
+export type ProviderImageTransportSupport = 'supported' | 'not-supported';
+export type ProviderImageTransportSource = 'transport-derived' | 'runtime-derived';
+export type ProviderImageTransportDelivery = 'host-materialized-local-path' | 'blob';
+export type ProviderImageInputReason = 'real-media-delivered' | 'shared-host-attachment-metadata-fallback' | 'host-policy-blocked';
+export type ProviderImageTransportReason = 'real-media-delivered' | 'transport-does-not-deliver-real-media' | 'runtime-capability-not-yet-resolved' | 'host-policy-blocked';
+export interface SharedHostAttachmentMetadataFallbackCapability {
+    support: 'metadata-only';
+    delivery: 'prompt-text-attachment-metadata';
+}
+export interface ProviderImageTransportCapability {
+    source: ProviderImageTransportSource;
+    support: ProviderImageTransportSupport;
+    reason: ProviderImageTransportReason;
+    delivery: readonly ProviderImageTransportDelivery[];
+    maxImageCount?: number;
+    maxBytesPerImage?: number;
+    maxTotalBytes?: number;
+}
+export interface ProviderImageCapability {
+    support: ProviderImageInputSupport;
+    reason: ProviderImageInputReason;
+    sharedHostFallback: SharedHostAttachmentMetadataFallbackCapability;
+    transport: ProviderImageTransportCapability;
+}
+export interface ProviderCapabilities {
+    imageInput: ProviderImageCapability;
+}
+export declare const SHARED_HOST_ATTACHMENT_METADATA_FALLBACK: SharedHostAttachmentMetadataFallbackCapability;
+export declare function createHostedProviderCapabilities(params: {
+    imageInputTransport: ProviderImageTransportCapability;
+    sharedHostFallback?: SharedHostAttachmentMetadataFallbackCapability;
+}): ProviderCapabilities;
+export declare const TEXT_ONLY_HOSTED_PROVIDER_CAPABILITIES: ProviderCapabilities;
 export interface ProviderAdapter {
+    readonly capabilities: ProviderCapabilities;
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     dispose?(): Promise<void>;
 }

package/dist/providers/provider-adapter.js

@@ -1 +1,44 @@
-export {};
+export const SHARED_HOST_ATTACHMENT_METADATA_FALLBACK = Object.freeze({
+    support: 'metadata-only',
+    delivery: 'prompt-text-attachment-metadata',
+});
+function resolveImageInputSupport(transport, sharedHostFallback) {
+    if (transport.support === 'supported') {
+        return {
+            support: 'supported',
+            reason: 'real-media-delivered',
+        };
+    }
+    if (transport.reason === 'host-policy-blocked') {
+        return {
+            support: 'not-supported',
+            reason: 'host-policy-blocked',
+        };
+    }
+    return {
+        support: sharedHostFallback.support,
+        reason: 'shared-host-attachment-metadata-fallback',
+    };
+}
+export function createHostedProviderCapabilities(params) {
+    const sharedHostFallback = params.sharedHostFallback ?? SHARED_HOST_ATTACHMENT_METADATA_FALLBACK;
+    const transport = Object.freeze({
+        ...params.imageInputTransport,
+        delivery: Object.freeze([...params.imageInputTransport.delivery]),
+    });
+    return Object.freeze({
+        imageInput: Object.freeze({
+            ...resolveImageInputSupport(transport, sharedHostFallback),
+            sharedHostFallback,
+            transport,
+        }),
+    });
+}
+export const TEXT_ONLY_HOSTED_PROVIDER_CAPABILITIES = createHostedProviderCapabilities({
+    imageInputTransport: {
+        source: 'transport-derived',
+        support: 'not-supported',
+        reason: 'transport-does-not-deliver-real-media',
+        delivery: [],
+    },
+});

package/dist/state-paths.d.ts

@@ -1,4 +1,11 @@
 export declare function normalizeManagedRuntimeKey(serverUrl: string): string;
+export type ManagedDaemonEndpoint = {
+    kind: 'named-pipe';
+    address: string;
+} | {
+    kind: 'unix-socket';
+    address: 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;
 /**
@@ -7,7 +14,8 @@ export declare function resolveManagedRuntimeRoot(serverUrl: string, env?: NodeJ
  */
 export declare function resolveUpdateCheckCachePath(env?: NodeJS.ProcessEnv, resolvedHomeDir?: string): string;
 export declare function resolveManagedStateRoot(rootPath: string): string;
-export declare function resolveManagedDaemonSocketPath(rootPath: string): string;
+export declare function resolveManagedDaemonEndpoint(rootPath: string, platform?: NodeJS.Platform): ManagedDaemonEndpoint;
+export declare function resolveManagedDaemonSocketPath(rootPath: string, platform?: NodeJS.Platform): string;
 export declare function resolveManagedDaemonLogPath(rootPath: string): string;
 export declare function resolveManagedRuntimeSettingsPath(rootPath: string): string;
 export declare function resolveManagedBootstrapLockPath(rootPath: string): string;

package/dist/state-paths.js

@@ -1,12 +1,13 @@
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join, posix, resolve, win32 } 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_PIPE_PREFIX = '\\\\.\\pipe\\borgee-agents-host-managed-';
 const MANAGED_DAEMON_LOG_FILENAME = 'daemon.log';
 const MANAGED_RUNTIME_SETTINGS_FILENAME = 'managed-runtime-settings.json';
 const MANAGED_BOOTSTRAP_LOCK_DIRNAME = '.bootstrap.lock';
@@ -95,8 +96,26 @@ export function resolveUpdateCheckCachePath(env = process.env, resolvedHomeDir =
 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 resolveManagedDaemonEndpoint(rootPath, platform = process.platform) {
+    const pathApi = platform === 'win32' ? win32 : posix;
+    const resolvedRoot = pathApi.resolve(rootPath);
+    if (platform === 'win32') {
+        const rootHash = createHash('sha256')
+            .update(resolvedRoot.toLowerCase())
+            .digest('hex')
+            .slice(0, 24);
+        return {
+            kind: 'named-pipe',
+            address: `${MANAGED_DAEMON_PIPE_PREFIX}${rootHash}`,
+        };
+    }
+    return {
+        kind: 'unix-socket',
+        address: posix.join(resolvedRoot, MANAGED_DAEMON_SOCKET_FILENAME),
+    };
+}
+export function resolveManagedDaemonSocketPath(rootPath, platform = process.platform) {
+    return resolveManagedDaemonEndpoint(rootPath, platform).address;
 }
 export function resolveManagedDaemonLogPath(rootPath) {
     return join(resolve(rootPath), MANAGED_DAEMON_LOG_FILENAME);

package/dist/types.d.ts

@@ -12,7 +12,9 @@ export interface ProviderCommandConfig {
 }
 export interface ProviderRuntimeConfig extends ProviderCommandConfig {
     provider: ProviderKind;
+    borgeeBaseUrl: string;
     stateRootDir: string;
+    agentApiKey: string;
     resolveStableAgentId?: () => string | undefined;
 }
 export interface HostedAgentConfig {
@@ -96,6 +98,7 @@ export interface ChannelMessageEvent {
     content?: string;
     body?: string;
     content_type?: string;
+    attachments?: HostedMessageAttachment[];
     created_at?: number;
     [key: string]: unknown;
 }
@@ -115,11 +118,32 @@ export interface ChannelHistoryEntry {
     authorId: string;
     body: string;
     contentType?: string;
+    attachments?: HostedMessageAttachment[];
     type?: string;
     replyToId?: string;
     createdAt: number;
     editedAt?: number;
 }
+export interface HostedMessageAttachment {
+    url: string;
+    filename?: string;
+    contentType: string;
+    kind?: 'image' | 'file';
+    sizeBytes?: number;
+}
+export interface HostedTextContentPart {
+    type: 'text';
+    text: string;
+}
+export interface HostedImageContentPart {
+    type: 'image';
+    attachment: HostedMessageAttachment;
+}
+export interface HostedFileContentPart {
+    type: 'file';
+    attachment: HostedMessageAttachment;
+}
+export type HostedTurnContentPart = HostedTextContentPart | HostedImageContentPart | HostedFileContentPart;
 export interface ReadChannelHistoryInput {
     channelId: string;
     before?: number;
@@ -234,6 +258,7 @@ export interface ProviderInput {
     channelId: string;
     incomingAuthorId: string;
     incomingContent: string;
+    incomingParts?: HostedTurnContentPart[];
     incomingEventKind?: string;
     incomingMessageType?: string;
     collaboration?: ProviderCollaborationContext;
@@ -291,7 +316,7 @@ export interface TaskWorkspaceContext {
 }
 export interface PreparedPromptContext {
     channelContextPayloadPath?: string;
-    gatewayAuthPath?: string;
+    gatewayCredentialPath?: string;
     collaborationTurnExecutionId?: string;
     collaborationTurnMode?: ProviderCollaborationTurnMode;
     collaborationOutcome?: CollaborationOutcomeSnapshot;
@@ -313,6 +338,8 @@ export interface PreparedProviderSessionRouting {
 }
 export interface PreparedProviderTurnInput {
     channelId: string;
+    incomingContent: string;
+    incomingParts: HostedTurnContentPart[];
     incomingEventKind?: string;
     incomingMessageType?: string;
     prompt: string;
@@ -362,7 +389,7 @@ export interface Task {
     id: string;
     channelId: string;
     guildId: string;
-    seq?: number;
+    seq: number;
     title: string;
     description: string;
     status: string;
@@ -372,6 +399,10 @@ export interface Task {
     threadId: string | null;
     createdAt: number;
     updatedAt: number;
+    heartbeatIntervalMs: number;
+    heartbeatPrompt: string;
+    participants: string[];
+    properties: Record<string, string>;
 }
 export interface CreateTaskInput {
     channelId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@borgee/agents-host",
-  "version": "0.2.35",
+  "version": "0.2.44",
   "private": false,
   "publishConfig": {
     "access": "public"