@borgee/agents-host 0.2.2 → 0.2.28

package/dist/providers/awaiting-user.js

@@ -0,0 +1,192 @@
+export const HOST_CONTROL_PREFIX = '[[BORGEE_CONTROL]] ';
+export const AWAITING_USER_CONTROL_PREFIX = HOST_CONTROL_PREFIX;
+const VALID_ATTENTION_UPDATES = new Set([
+    'follow-channel',
+    'unfollow-channel',
+    'mute-channel',
+    'claim-channel',
+    'claim-task-thread',
+    'unclaim-channel',
+    'unclaim-task-thread',
+]);
+function isProviderAttentionUpdate(value) {
+    return typeof value === 'string' && VALID_ATTENTION_UPDATES.has(value);
+}
+function hasVisibleText(value) {
+    return value.trim().length > 0;
+}
+function stripTrailingCarriageReturn(value) {
+    return value.endsWith('\r') ? value.slice(0, -1) : value;
+}
+function matchControlLine(sourceText, trimTrailingWhitespace) {
+    const analyzedText = trimTrailingWhitespace
+        ? sourceText.replace(/[ \t\r\n]+$/u, '')
+        : sourceText;
+    const lastNewline = analyzedText.lastIndexOf('\n');
+    const lineStart = lastNewline === -1 ? 0 : lastNewline + 1;
+    const line = stripTrailingCarriageReturn(analyzedText.slice(lineStart));
+    const removalStart = lastNewline === -1 ? 0 : lastNewline;
+    if (line.startsWith(HOST_CONTROL_PREFIX)) {
+        return {
+            kind: 'footer',
+            analyzedText,
+            removalStart,
+            payload: line.slice(HOST_CONTROL_PREFIX.length),
+        };
+    }
+    if (line.length > 0 && HOST_CONTROL_PREFIX.startsWith(line)) {
+        return {
+            kind: 'plausible-prefix',
+            analyzedText,
+            removalStart,
+        };
+    }
+    return {
+        kind: 'none',
+        analyzedText,
+        removalStart,
+    };
+}
+function parseControlPayload(payload) {
+    let parsed;
+    try {
+        parsed = JSON.parse(payload);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return null;
+    }
+    const record = parsed;
+    if (typeof record.kind !== 'string') {
+        return null;
+    }
+    const attentionUpdate = (() => {
+        if (record.attentionUpdate === undefined) {
+            return undefined;
+        }
+        return isProviderAttentionUpdate(record.attentionUpdate) ? record.attentionUpdate : null;
+    })();
+    if (attentionUpdate === null) {
+        return null;
+    }
+    if (record.kind === 'continue-to-peer' || record.kind === 'conclude-locally') {
+        return Object.keys(record).every((key) => key === 'kind' || key === 'attentionUpdate')
+            ? {
+                kind: record.kind,
+                ...(attentionUpdate ? { attentionUpdate } : {}),
+            }
+            : null;
+    }
+    if (record.kind === 'start-protocol') {
+        return attentionUpdate === undefined
+            && Object.keys(record).length === 2
+            && typeof record.rounds === 'number'
+            && Number.isInteger(record.rounds)
+            && record.rounds > 0
+            ? {
+                kind: 'start-protocol',
+                rounds: record.rounds,
+            }
+            : null;
+    }
+    if (record.kind === 'awaiting-user') {
+        const keys = Object.keys(record);
+        if (keys.some((key) => key !== 'kind' && key !== 'question' && key !== 'reason' && key !== 'attentionUpdate')) {
+            return null;
+        }
+        if (typeof record.question !== 'string' || record.question.trim().length === 0) {
+            return null;
+        }
+        if (record.reason !== undefined
+            && (typeof record.reason !== 'string' || record.reason.trim().length === 0)) {
+            return null;
+        }
+        return {
+            kind: 'awaiting-user',
+            question: record.question.trim(),
+            ...(typeof record.reason === 'string' ? { reason: record.reason.trim() } : {}),
+            ...(attentionUpdate ? { attentionUpdate } : {}),
+        };
+    }
+    if (record.kind === 'attention-only') {
+        return Object.keys(record).length === 2 && attentionUpdate
+            ? {
+                kind: 'attention-only',
+                attentionUpdate,
+            }
+            : null;
+    }
+    return null;
+}
+export function parseProviderReply(text) {
+    const match = matchControlLine(text, true);
+    if (match.kind !== 'footer' || match.payload === undefined) {
+        return { text };
+    }
+    const control = parseControlPayload(match.payload);
+    if (!control) {
+        return {
+            text: stripTrailingCarriageReturn(match.analyzedText.slice(0, match.removalStart)),
+            controlMalformed: true,
+        };
+    }
+    const textWithoutFooter = stripTrailingCarriageReturn(match.analyzedText.slice(0, match.removalStart));
+    if (control.kind === 'attention-only' && !hasVisibleText(textWithoutFooter)) {
+        return {
+            text: textWithoutFooter,
+            controlMalformed: true,
+        };
+    }
+    return {
+        text: textWithoutFooter,
+        control,
+        ...(control.kind === 'awaiting-user'
+            ? {
+                awaitingUser: {
+                    question: control.question,
+                    ...(control.reason ? { reason: control.reason } : {}),
+                },
+            }
+            : {}),
+    };
+}
+export function sanitizeAwaitingUserProgressText(text) {
+    const match = matchControlLine(text, true);
+    if (match.kind !== 'none') {
+        return stripTrailingCarriageReturn(match.analyzedText.slice(0, match.removalStart));
+    }
+    const rawMatch = matchControlLine(text, false);
+    if (rawMatch.kind === 'none') {
+        return text;
+    }
+    return stripTrailingCarriageReturn(rawMatch.analyzedText.slice(0, rawMatch.removalStart));
+}
+export class AwaitingUserProgressSanitizer {
+    onProgress;
+    lastPublished = null;
+    constructor(onProgress) {
+        this.onProgress = onProgress;
+    }
+    publish(text) {
+        if (!this.onProgress) {
+            return;
+        }
+        const sanitizedText = sanitizeAwaitingUserProgressText(text);
+        if (!hasVisibleText(sanitizedText) || sanitizedText === this.lastPublished) {
+            return;
+        }
+        this.lastPublished = sanitizedText;
+        this.onProgress({ text: sanitizedText });
+    }
+}
+export function createAwaitingUserProgressHandler(onProgress) {
+    if (!onProgress) {
+        return undefined;
+    }
+    const sanitizer = new AwaitingUserProgressSanitizer(onProgress);
+    return (update) => {
+        sanitizer.publish(update.text);
+    };
+}

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

@@ -1,9 +1,11 @@
 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 class ClaudeProviderAdapter implements ProviderAdapter {
     private readonly cli;
-    constructor(cli: ClaudeCliClient);
+    private readonly turnPreparer;
+    constructor(cli: ClaudeCliClient, turnPreparer: ProviderTurnPreparer);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     dispose(): Promise<void>;
 }

package/dist/providers/claude/adapter.js

@@ -1,21 +1,17 @@
-import { buildPrompt } from '../../context/prompt.js';
+import { createAwaitingUserProgressHandler, parseProviderReply } from '../awaiting-user.js';
 export class ClaudeProviderAdapter {
     cli;
-    constructor(cli) {
+    turnPreparer;
+    constructor(cli, turnPreparer) {
         this.cli = cli;
+        this.turnPreparer = turnPreparer;
     }
     async generateReply(input, options) {
-        const prompt = buildPrompt({
-            agentName: input.agentName,
-            provider: input.provider,
-            channelId: input.channelId,
-            incomingAuthorId: input.incomingAuthorId,
-            incomingContent: input.incomingContent,
+        const preparedTurn = await this.turnPreparer.prepare(input);
+        const text = await this.cli.generateReply(preparedTurn, {
+            onProgress: createAwaitingUserProgressHandler(options?.onProgress),
         });
-        const text = await this.cli.generateReply(input.channelId, prompt, {
-            onProgress: options?.onProgress,
-        });
-        return { text };
+        return parseProviderReply(text);
     }
     async dispose() {
         await this.cli.dispose();

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

@@ -1,22 +1,26 @@
 import spawn from 'cross-spawn';
-import type { ProviderGenerateOptions } from '../../types.js';
+import { type DebugLogger } from '../../debug.js';
+import type { PreparedProviderTurnInput, ProviderGenerateOptions } from '../../types.js';
 import type { ClaudeChannelSessionStore } from './session-store.js';
 interface ClaudeCliRuntime {
     spawn: typeof spawn;
+    cwd: string;
 }
 /**
  * CLI client for the Claude Code CLI (`claude`) non-interactive mode, with
- * native per-channel session continuity.
+ * native provider-session continuity.
  *
  * Claude session memory remains entirely inside the Claude CLI. This client
- * only pins one native session id per Borgee channel and serializes turns per
- * channel so `--resume` is never called concurrently for the same session.
+ * only pins one native session id per routed provider session and serializes
+ * turns per route so `--resume` is never called concurrently for the same
+ * native session.
  */
 export declare class ClaudeCliClient {
     private readonly command;
     private readonly args;
     private readonly sessionStore?;
     private readonly resolveSessionStoreAgentId;
+    private readonly logger;
     private readonly runtime;
     private readonly channels;
     private readonly persistedSessions;
@@ -24,7 +28,8 @@ export declare class ClaudeCliClient {
     private stopped;
     private sessionStoreLoadPromise;
     private sessionStoreWriteQueue;
-    constructor(command: string, args: string[], runtimeOverrides?: Partial<ClaudeCliRuntime>, sessionStore?: ClaudeChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined);
+    constructor(command: string, args: string[], runtimeOverrides?: Partial<ClaudeCliRuntime>, sessionStore?: ClaudeChannelSessionStore | undefined, resolveSessionStoreAgentId?: () => string | undefined, logger?: DebugLogger);
+    generateReply(turn: PreparedProviderTurnInput, options?: ProviderGenerateOptions): Promise<string>;
     generateReply(channelId: string, prompt: string, options?: ProviderGenerateOptions): Promise<string>;
     dispose(): Promise<void>;
     private getOrCreateChannelState;
@@ -37,6 +42,8 @@ export declare class ClaudeCliClient {
     private persistSession;
     private persistSessionBestEffort;
     private resetPersistedSession;
+    private resolveTurnCwd;
+    private resetSessionIfCwdChanged;
     private resetPersistedSessionBestEffort;
     private enqueueSessionStoreWrite;
     private run;