@borgee/agents-host 0.2.35 → 0.2.56

package/dist/context/projection-strategy.js

@@ -0,0 +1,90 @@
+import { DEFAULT_PROJECTION_STRATEGY, normalizeProjectionStrategy, } from '../projection-strategy-values.js';
+import { findTaskForThread } from '../task-thread-resolution.js';
+export class ServerProjectionStrategyResolver {
+    options;
+    strategyCache = new Map();
+    channelAliases = new Map();
+    fetchImpl;
+    fallback;
+    constructor(options) {
+        this.options = options;
+        this.fetchImpl = options.fetch ?? fetch;
+        this.fallback = options.fallback ?? (() => DEFAULT_PROJECTION_STRATEGY);
+    }
+    async resolve(channelId) {
+        const baseUrl = this.options.baseUrl?.trim();
+        const agentApiKey = this.options.agentApiKey?.trim();
+        const agentId = this.options.resolveStableAgentId?.()?.trim();
+        if (!baseUrl || !agentApiKey || !agentId) {
+            return this.fallback();
+        }
+        const cacheKey = `${agentId}::${channelId}`;
+        const url = new URL(`/api/v1/agents/${encodeURIComponent(agentId)}/channels/${encodeURIComponent(channelId)}/projection-strategy`, baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`);
+        try {
+            const response = await this.fetchImpl(url.toString(), {
+                headers: {
+                    Authorization: `Bearer ${agentApiKey}`,
+                },
+            });
+            if (response.status === 404) {
+                const effectiveCacheKey = await this.resolveEffectiveCacheKey(agentId, channelId, cacheKey);
+                this.channelAliases.set(cacheKey, effectiveCacheKey);
+                this.strategyCache.set(effectiveCacheKey, DEFAULT_PROJECTION_STRATEGY);
+                return DEFAULT_PROJECTION_STRATEGY;
+            }
+            if (!response.ok) {
+                throw new Error(`server returned ${response.status} ${response.statusText}`.trim());
+            }
+            const body = await response.json();
+            const strategy = normalizeProjectionStrategy(typeof body.projection_strategy === 'string' ? body.projection_strategy : undefined);
+            if (!strategy) {
+                throw new Error('server returned an invalid projection strategy');
+            }
+            const effectiveChannelId = typeof body.channel_id === 'string' && body.channel_id.length > 0
+                ? body.channel_id
+                : channelId;
+            const effectiveCacheKey = `${agentId}::${effectiveChannelId}`;
+            this.channelAliases.set(cacheKey, effectiveCacheKey);
+            this.strategyCache.set(effectiveCacheKey, strategy);
+            return strategy;
+        }
+        catch (error) {
+            const cached = await this.resolveCachedStrategy(agentId, channelId, cacheKey);
+            if (cached) {
+                return cached;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            this.options.logger?.error('failed to resolve server-backed projection strategy; using fallback', {
+                agentId,
+                channelId,
+                error: message,
+            });
+            return DEFAULT_PROJECTION_STRATEGY;
+        }
+    }
+    async resolveCachedStrategy(agentId, channelId, cacheKey) {
+        const direct = this.strategyCache.get(this.channelAliases.get(cacheKey) ?? cacheKey);
+        if (direct) {
+            return direct;
+        }
+        if (!this.options.taskReader) {
+            return undefined;
+        }
+        const effectiveCacheKey = await this.resolveEffectiveCacheKey(agentId, channelId, cacheKey);
+        if (effectiveCacheKey === cacheKey) {
+            return undefined;
+        }
+        this.channelAliases.set(cacheKey, effectiveCacheKey);
+        return this.strategyCache.get(effectiveCacheKey);
+    }
+    async resolveEffectiveCacheKey(agentId, channelId, cacheKey) {
+        if (!this.options.taskReader) {
+            return cacheKey;
+        }
+        const task = await findTaskForThread(this.options.taskReader, channelId);
+        if (!task?.channelId) {
+            return cacheKey;
+        }
+        return `${agentId}::${task.channelId}`;
+    }
+}

package/dist/context/prompt.d.ts

@@ -1,4 +1,4 @@
-import type { PreparedPromptContext, ProviderKind } from '../types.js';
+import type { ProjectionStrategy, PreparedPromptContext, ProviderKind } from '../types.js';
 /**
  * Builds the per-turn prompt. Conversation memory is intentionally NOT
  * assembled here: each provider's CLI client resumes a native per-channel
@@ -16,3 +16,18 @@ export declare function buildPrompt(params: {
     incomingMessageType?: string;
     promptContext?: PreparedPromptContext;
 }): string;
+export declare function buildClaudeSessionPromptAppend(params: {
+    agentName: string;
+    promptContext?: PreparedPromptContext;
+    promptStrategy?: ProjectionStrategy;
+}): string | undefined;
+export declare function buildClaudeTurnPrompt(params: {
+    agentName?: string;
+    channelId: string;
+    incomingAuthorId: string;
+    incomingContent: string;
+    incomingEventKind?: string;
+    incomingMessageType?: string;
+    promptContext?: PreparedPromptContext;
+    promptStrategy?: ProjectionStrategy;
+}): string;