@borgee/agents-host 0.2.33 → 0.2.44

package/dist/policy/gateway-authorization.d.ts

@@ -8,6 +8,21 @@ export interface GatewayTaskRoute {
     taskId: string;
     resource: 'task' | 'task-history';
 }
+/** One task property, addressed by key. PUT writes it, DELETE removes it. */
+export interface GatewayTaskPropertyRoute {
+    taskId: string;
+    key: string;
+    resource: 'task-property';
+}
+/** The same, on the thread's own task, so an agent need not resolve a task id. */
+export interface GatewayCurrentTaskPropertyRoute {
+    channelId: string;
+    key: string;
+    resource: 'current-task-property';
+}
+export type GatewayRoute = GatewayChannelRoute | GatewayTaskRoute | GatewayTaskPropertyRoute | GatewayCurrentTaskPropertyRoute | {
+    resource: 'health';
+};
 export interface GatewayAuthorizationBinding {
     channelId: string;
     agentId?: string;
@@ -23,9 +38,7 @@ export interface GatewayAuthorizationDecision {
     };
     allowHeader?: string;
     binding?: GatewayAuthorizationBinding;
-    route?: GatewayChannelRoute | GatewayTaskRoute | {
-        resource: 'health';
-    };
+    route?: GatewayRoute;
     path: string;
     token?: string;
 }
@@ -39,4 +52,6 @@ export declare function hasVisibleHeader(value: string | string[] | undefined):
 export declare function parseBearerToken(value: string | string[] | undefined): string | null;
 export declare function matchChannelRoute(pathname: string, allowCollaborationRoutes?: boolean): GatewayChannelRoute | null;
 export declare function matchTaskRoute(pathname: string): GatewayTaskRoute | null;
+export declare function matchTaskPropertyRoute(pathname: string): GatewayTaskPropertyRoute | null;
+export declare function matchCurrentTaskPropertyRoute(pathname: string): GatewayCurrentTaskPropertyRoute | null;
 export declare function evaluateGatewayAuthorization(input: GatewayAuthorizationInput): GatewayAuthorizationDecision;

package/dist/policy/gateway-authorization.js

@@ -61,6 +61,30 @@ export function matchTaskRoute(pathname) {
         resource: match[2] ? 'task-history' : 'task',
     };
 }
+export function matchTaskPropertyRoute(pathname) {
+    const match = /^\/v1\/tasks\/([^/]+)\/properties\/([^/]+)$/.exec(pathname);
+    if (!match) {
+        return null;
+    }
+    const taskId = decodePathSegment(match[1]);
+    const key = decodePathSegment(match[2]);
+    if (taskId == null || key == null) {
+        return null;
+    }
+    return { taskId, key, resource: 'task-property' };
+}
+export function matchCurrentTaskPropertyRoute(pathname) {
+    const match = /^\/v1\/channels\/([^/]+)\/current-task\/properties\/([^/]+)$/.exec(pathname);
+    if (!match) {
+        return null;
+    }
+    const channelId = decodePathSegment(match[1]);
+    const key = decodePathSegment(match[2]);
+    if (channelId == null || key == null) {
+        return null;
+    }
+    return { channelId, key, resource: 'current-task-property' };
+}
 function allowedMethodsForRoute(route, collaborationRoutesEnabled) {
     switch (route.resource) {
         case 'health':
@@ -78,6 +102,11 @@ function allowedMethodsForRoute(route, collaborationRoutesEnabled) {
         case 'current-task':
         case 'task':
             return ['GET', 'PATCH'];
+        // No GET: a property is read back with the task it belongs to, so a
+        // per-key read would be a second way to learn the same thing.
+        case 'current-task-property':
+        case 'task-property':
+            return ['PUT', 'DELETE'];
     }
 }
 export function evaluateGatewayAuthorization(input) {
@@ -96,7 +125,10 @@ export function evaluateGatewayAuthorization(input) {
     const collaborationRoutesEnabled = input.allowCollaborationRoutes ?? false;
     const route = url.pathname === '/health'
         ? { resource: 'health' }
-        : matchChannelRoute(url.pathname, collaborationRoutesEnabled) ?? matchTaskRoute(url.pathname);
+        : matchChannelRoute(url.pathname, collaborationRoutesEnabled)
+            ?? matchCurrentTaskPropertyRoute(url.pathname)
+            ?? matchTaskPropertyRoute(url.pathname)
+            ?? matchTaskRoute(url.pathname);
     if (hiddenCollaborationRoute) {
         return {
             reason: 'not-found',

package/dist/providers/claude/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 { ClaudeCliClient } from './cli-client.js';
+export declare const CLAUDE_HOSTED_PROVIDER_CAPABILITIES: import("../provider-adapter.js").ProviderCapabilities;
 export declare class ClaudeProviderAdapter implements ProviderAdapter {
     private readonly cli;
     private readonly turnPreparer;
+    readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
     constructor(cli: ClaudeCliClient, turnPreparer: ProviderTurnPreparer);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     dispose(): Promise<void>;

package/dist/providers/claude/adapter.js

@@ -1,7 +1,17 @@
+import { createHostedProviderCapabilities } from '../provider-adapter.js';
 import { createAwaitingUserProgressHandler, parseProviderReply } from '../awaiting-user.js';
+export const CLAUDE_HOSTED_PROVIDER_CAPABILITIES = createHostedProviderCapabilities({
+    imageInputTransport: {
+        source: 'transport-derived',
+        support: 'supported',
+        reason: 'real-media-delivered',
+        delivery: ['blob'],
+    },
+});
 export class ClaudeProviderAdapter {
     cli;
     turnPreparer;
+    capabilities = CLAUDE_HOSTED_PROVIDER_CAPABILITIES;
     constructor(cli, turnPreparer) {
         this.cli = cli;
         this.turnPreparer = turnPreparer;
@@ -11,7 +21,9 @@ export class ClaudeProviderAdapter {
         const text = await this.cli.generateReply(preparedTurn, {
             onProgress: createAwaitingUserProgressHandler(options?.onProgress),
         });
-        return parseProviderReply(text);
+        // Read the session AFTER the turn: a first turn on a channel opens the
+        // session as it runs, so before this point there is nothing to report.
+        return { ...parseProviderReply(text), sessionId: this.cli.sessionIdForChannel(input.channelId) };
     }
     async dispose() {
         await this.cli.dispose();

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

@@ -1,7 +1,7 @@
 import spawn from 'cross-spawn';
 import { PROTOCOL_VERSION, client, methods, ndJsonStream } from '@agentclientprotocol/sdk';
 import { type DebugLogger } from '../../debug.js';
-import type { PreparedProviderTurnInput, ProviderGenerateOptions } from '../../types.js';
+import type { PreparedPromptContext, PreparedProviderTurnInput, ProviderGenerateOptions } from '../../types.js';
 import type { ClaudeChannelSessionStore } from './session-store.js';
 interface ClaudeAcpRuntime {
     spawn: typeof spawn;
@@ -9,10 +9,18 @@ interface ClaudeAcpRuntime {
     ndJsonStream: typeof ndJsonStream;
     methods: typeof methods;
     protocolVersion: typeof PROTOCOL_VERSION;
+    fetch: typeof fetch;
     cwd: string;
+    idleBackendShutdownMs: number;
+    idleShutdownGracePeriodMs: number;
     shutdownGracePeriodMs: number;
     shutdownForceKillWaitMs: number;
 }
+interface ClaudeHostedImageInputConfig {
+    borgeeBaseUrl?: string;
+    agentApiKey?: string;
+}
+export declare function buildClaudeSessionSystemPrompt(promptContext?: PreparedPromptContext): string | undefined;
 /**
  * Persistent ACP-backed client for the Claude ACP adapter.
  *
@@ -27,8 +35,15 @@ export declare class ClaudeCliClient {
     private readonly sessionStore?;
     private readonly resolveSessionStoreAgentId;
     private readonly logger;
+    private readonly imageInputConfig;
     private readonly runtime;
     private readonly channels;
+    /**
+     * The provider session currently bound to channelId, or undefined before a
+     * turn has opened one. Surfaced so agents-host can record which session
+     * worked a task without the agent being asked to report its own id.
+     */
+    sessionIdForChannel(channelId: string): string | undefined;
     private readonly persistedSessions;
     private readonly closingSessions;
     private readonly pendingSessionStarts;
@@ -41,7 +56,13 @@ export declare class ClaudeCliClient {
     private startPromise?;
     private shutdownPromise?;
     private childExitPromise?;
-    private resolveChildExit?;
+    /**
+     * Bumped on every spawn so the `exit` / `connection.closed` handlers of a
+     * backend we deliberately recycled stay silent instead of latching a fatal
+     * error onto the client that already owns its successor.
+     */
+    private backendGeneration;
+    private idleShutdownPromise?;
     private fatalError;
     private disposing;
     private backendClosed;
@@ -49,8 +70,9 @@ export declare class ClaudeCliClient {
     private sessionStoreLoadPromise;
     private sessionStoreWriteQueue;
     private sessionCapabilities;
+    private readonly idleBackendShutdown;
     private childStderr;
-    constructor(command: string, args?: string[], runtimeOverrides?: Partial<ClaudeAcpRuntime>, sessionStore?: ClaudeChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger);
+    constructor(command: string, args?: string[], runtimeOverrides?: Partial<ClaudeAcpRuntime>, sessionStore?: ClaudeChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger, imageInputConfig?: ClaudeHostedImageInputConfig);
     generateReply(turn: PreparedProviderTurnInput, options?: ProviderGenerateOptions): Promise<string>;
     generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
     dispose(): Promise<void>;
@@ -83,8 +105,19 @@ export declare class ClaudeCliClient {
     private enqueueSessionStoreWrite;
     private trackSessionStoreOperation;
     private shutdownBackend;
+    /**
+     * Backend teardown without the fatal latch: the client stays usable and
+     * `ensureStarted()` spawns a replacement process on the next turn. Only safe
+     * while `isBackendIdle()` holds, because every channel's live ACP session is
+     * dropped here and no turn is ever replayed onto its successor.
+     */
+    private shutdownIdleBackend;
+    private isBackendIdle;
+    private closeBackendProcess;
     private waitForPendingSessionStarts;
     private waitForPendingSessionCloses;
     private waitForChildExit;
+    private buildPromptInput;
+    private fetchImageBlock;
 }
 export {};