@hybridaione/hybridclaw 0.1.21 → 0.1.24

package/src/chunk.ts

@@ -0,0 +1,153 @@
+export interface ChunkMessageOptions {
+  maxChars?: number;
+  maxLines?: number;
+}
+
+const DEFAULT_MAX_CHARS = 1_900;
+const DEFAULT_MAX_LINES = 20;
+
+function isFenceLine(line: string): boolean {
+  return line.trim().startsWith('```');
+}
+
+function parseFenceLanguage(line: string): string {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith('```')) return '';
+  return trimmed.slice(3).trim();
+}
+
+function findSentenceBoundary(input: string): number {
+  let best = -1;
+  const re = /[.!?]\s+/g;
+  for (let match = re.exec(input); match; match = re.exec(input)) {
+    best = match.index + match[0].length;
+  }
+  return best;
+}
+
+function findPreferredSplit(input: string, hardLimit: number): number {
+  const limit = Math.max(1, Math.min(hardLimit, input.length));
+  const window = input.slice(0, limit);
+
+  const paragraph = window.lastIndexOf('\n\n');
+  if (paragraph >= Math.floor(limit * 0.45)) {
+    return paragraph + 2;
+  }
+
+  const line = window.lastIndexOf('\n');
+  if (line >= Math.floor(limit * 0.45)) {
+    return line + 1;
+  }
+
+  const sentence = findSentenceBoundary(window);
+  if (sentence >= Math.floor(limit * 0.45)) {
+    return sentence;
+  }
+
+  const word = window.lastIndexOf(' ');
+  if (word >= Math.floor(limit * 0.35)) {
+    return word + 1;
+  }
+
+  return limit;
+}
+
+function splitLongLine(line: string, maxChars: number): string[] {
+  if (line.length <= maxChars) return [line];
+
+  const pieces: string[] = [];
+  let remaining = line;
+  while (remaining.length > maxChars) {
+    let splitAt = findPreferredSplit(remaining, maxChars);
+    if (splitAt <= 0 || splitAt > remaining.length) {
+      splitAt = Math.min(maxChars, remaining.length);
+    }
+
+    const head = remaining.slice(0, splitAt).trimEnd();
+    if (!head) {
+      const fallback = remaining.slice(0, maxChars);
+      pieces.push(fallback);
+      remaining = remaining.slice(maxChars);
+      continue;
+    }
+
+    pieces.push(head);
+    remaining = remaining.slice(splitAt).trimStart();
+  }
+
+  if (remaining.length > 0) {
+    pieces.push(remaining);
+  }
+
+  return pieces;
+}
+
+export function chunkMessage(text: string, opts?: ChunkMessageOptions): string[] {
+  const maxChars = Math.max(200, opts?.maxChars ?? DEFAULT_MAX_CHARS);
+  const maxLines = Math.max(4, opts?.maxLines ?? DEFAULT_MAX_LINES);
+  const normalized = (text || '').replace(/\r\n?/g, '\n');
+  if (!normalized.trim()) return [];
+
+  const inputLines = normalized.split('\n');
+  const chunks: string[] = [];
+
+  let currentLines: string[] = [];
+  let currentChars = 0;
+  let openFence = false;
+  let fenceLanguage = '';
+
+  const flush = (isFinal: boolean): void => {
+    if (currentLines.length === 0) return;
+
+    let chunk = currentLines.join('\n');
+    if (openFence) {
+      chunk += '\n```';
+    }
+    chunks.push(chunk);
+
+    if (!isFinal && openFence) {
+      const reopenedFence = fenceLanguage ? `\`\`\`${fenceLanguage}` : '```';
+      currentLines = [reopenedFence];
+      currentChars = reopenedFence.length;
+    } else {
+      currentLines = [];
+      currentChars = 0;
+      if (isFinal && openFence) {
+        openFence = false;
+        fenceLanguage = '';
+      }
+    }
+  };
+
+  const appendLine = (line: string): void => {
+    const addedChars = currentLines.length === 0 ? line.length : line.length + 1;
+    const nextChars = currentChars + addedChars;
+    const nextLines = currentLines.length + 1;
+    if (currentLines.length > 0 && (nextChars > maxChars || nextLines > maxLines)) {
+      flush(false);
+    }
+
+    currentLines.push(line);
+    currentChars = currentLines.length === 1 ? line.length : currentChars + line.length + 1;
+
+    if (isFenceLine(line)) {
+      if (!openFence) {
+        openFence = true;
+        fenceLanguage = parseFenceLanguage(line);
+      } else {
+        openFence = false;
+        fenceLanguage = '';
+      }
+    }
+  };
+
+  for (const rawLine of inputLines) {
+    const splitLines = splitLongLine(rawLine, maxChars);
+    for (const part of splitLines) {
+      appendLine(part);
+    }
+  }
+
+  flush(true);
+  return chunks;
+}

package/src/container-runner.ts

@@ -33,14 +33,31 @@ interface PoolEntry {
   sessionId: string;
   startedAt: number;
   stderrBuffer: string;
+  onTextDelta?: (delta: string) => void;
   onToolProgress?: (event: ToolProgressEvent) => void;
 }
 
 const pool = new Map<string, PoolEntry>();
 const TOOL_RESULT_RE = /^\[tool\]\s+([a-zA-Z0-9_.-]+)\s+result\s+\((\d+)ms\):\s*(.*)$/;
 const TOOL_START_RE = /^\[tool\]\s+([a-zA-Z0-9_.-]+):\s*(.*)$/;
+const STREAM_DELTA_RE = /^\[stream\]\s+([A-Za-z0-9+/=]+)$/;
 const CONTAINER_WORKSPACE_ROOT = '/workspace';
 
+function emitTextDelta(entry: PoolEntry, line: string): void {
+  const callback = entry.onTextDelta;
+  if (!callback) return;
+  const match = line.match(STREAM_DELTA_RE);
+  if (!match) return;
+
+  try {
+    const delta = Buffer.from(match[1], 'base64').toString('utf-8');
+    if (!delta) return;
+    callback(delta);
+  } catch (err) {
+    logger.debug({ sessionId: entry.sessionId, err }, 'Text delta callback failed');
+  }
+}
+
 function emitToolProgress(entry: PoolEntry, line: string): void {
   const callback = entry.onToolProgress;
   if (!callback) return;
@@ -218,6 +235,7 @@ function getOrSpawnContainer(sessionId: string, agentId: string): PoolEntry {
     for (const rawLine of lines) {
       const line = rawLine.trim();
       if (!line) continue;
+      emitTextDelta(entry, line);
       logger.debug({ container: containerName }, line);
       emitToolProgress(entry, line);
     }
@@ -226,6 +244,7 @@ function getOrSpawnContainer(sessionId: string, agentId: string): PoolEntry {
   proc.on('close', (code) => {
     const tail = entry.stderrBuffer.trim();
     if (tail) {
+      emitTextDelta(entry, tail);
       logger.debug({ container: containerName }, tail);
       emitToolProgress(entry, tail);
       entry.stderrBuffer = '';
@@ -256,6 +275,7 @@ export async function runContainer(
   channelId: string = '',
   scheduledTasks?: ScheduledTask[],
   allowedTools?: string[],
+  onTextDelta?: (delta: string) => void,
   onToolProgress?: (event: ToolProgressEvent) => void,
   abortSignal?: AbortSignal,
 ): Promise<ContainerOutput> {
@@ -312,6 +332,7 @@ export async function runContainer(
     allowedTools,
   };
 
+  entry.onTextDelta = onTextDelta;
   entry.onToolProgress = onToolProgress;
   const onAbort = () => {
     logger.info({ sessionId, containerName: entry.containerName }, 'Interrupt requested, stopping container');
@@ -346,6 +367,9 @@ export async function runContainer(
     return output;
   } finally {
     abortSignal?.removeEventListener('abort', onAbort);
+    if (entry.onTextDelta === onTextDelta) {
+      entry.onTextDelta = undefined;
+    }
     if (entry.onToolProgress === onToolProgress) {
       entry.onToolProgress = undefined;
     }

package/src/conversation.ts

@@ -1,6 +1,10 @@
 import { expandSkillInvocation, loadSkills, type Skill } from './skills.js';
 import type { ChatMessage } from './types.js';
-import { buildSystemPromptFromHooks } from './prompt-hooks.js';
+import { buildSystemPromptFromHooks, type PromptMode } from './prompt-hooks.js';
+import {
+  optimizeHistoryMessagesForPrompt,
+  type HistoryOptimizationStats,
+} from './token-efficiency.js';
 
 interface HistoryMessage {
   role: string;
@@ -10,6 +14,7 @@ interface HistoryMessage {
 export interface ConversationContext {
   messages: ChatMessage[];
   skills: Skill[];
+  historyStats: HistoryOptimizationStats;
 }
 
 export function buildConversationContext(params: {
@@ -17,14 +22,22 @@ export function buildConversationContext(params: {
   sessionSummary?: string | null;
   history: HistoryMessage[];
   expandLatestHistoryUser?: boolean;
+  promptMode?: PromptMode;
 }): ConversationContext {
-  const { agentId, sessionSummary, history, expandLatestHistoryUser = false } = params;
+  const {
+    agentId,
+    sessionSummary,
+    history,
+    expandLatestHistoryUser = false,
+    promptMode = 'full',
+  } = params;
   const skills = loadSkills(agentId);
   const systemPrompt = buildSystemPromptFromHooks({
     agentId,
     sessionSummary,
     skills,
     purpose: 'conversation',
+    promptMode,
   });
 
   const messages: ChatMessage[] = [];
@@ -44,6 +57,17 @@ export function buildConversationContext(params: {
     }
   }
 
-  messages.push(...historyMessages);
-  return { messages, skills };
+  const optimizedHistory = optimizeHistoryMessagesForPrompt(
+    historyMessages.map((message) => ({
+      role: message.role,
+      content: typeof message.content === 'string' ? message.content : '',
+    })),
+  );
+
+  messages.push(...optimizedHistory.messages);
+  return {
+    messages,
+    skills,
+    historyStats: optimizedHistory.stats,
+  };
 }

package/src/discord-stream.ts

@@ -0,0 +1,240 @@
+import {
+  AttachmentBuilder,
+  type Message as DiscordMessage,
+} from 'discord.js';
+
+import { chunkMessage } from './chunk.js';
+import { logger } from './logger.js';
+
+interface DiscordSendChannel {
+  send: (payload: { content: string; files?: AttachmentBuilder[] }) => Promise<DiscordMessage>;
+}
+
+interface DiscordEditMessage {
+  edit: (payload: { content: string; files?: AttachmentBuilder[] }) => Promise<DiscordMessage>;
+  delete: () => Promise<unknown>;
+}
+
+interface DiscordErrorLike {
+  status?: number;
+  httpStatus?: number;
+  retryAfter?: number;
+  data?: {
+    retry_after?: number;
+  };
+}
+
+export interface DiscordStreamOptions {
+  maxChars?: number;
+  maxLines?: number;
+  editIntervalMs?: number;
+  onFirstMessage?: () => void;
+}
+
+const DEFAULT_MAX_CHARS = 1_800;
+const DEFAULT_MAX_LINES = 20;
+const DEFAULT_EDIT_INTERVAL_MS = 1_200;
+const RETRY_MAX_ATTEMPTS = 3;
+const RETRY_BASE_DELAY_MS = 500;
+
+function isRetryableDiscordError(error: unknown): boolean {
+  const maybe = error as DiscordErrorLike;
+  const status = maybe.status ?? maybe.httpStatus;
+  return status === 429 || (typeof status === 'number' && status >= 500 && status <= 599);
+}
+
+function extractRetryDelayMs(error: unknown, fallbackMs: number): number {
+  const maybe = error as DiscordErrorLike;
+  const retryAfterSeconds = maybe.retryAfter ?? maybe.data?.retry_after;
+  if (typeof retryAfterSeconds === 'number' && Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0) {
+    return Math.max(50, Math.ceil(retryAfterSeconds * 1_000));
+  }
+  const jitter = Math.floor(Math.random() * 250);
+  return fallbackMs + jitter;
+}
+
+async function withDiscordRetry<T>(label: string, run: () => Promise<T>): Promise<T> {
+  let attempt = 0;
+  let delayMs = RETRY_BASE_DELAY_MS;
+  while (true) {
+    attempt += 1;
+    try {
+      return await run();
+    } catch (error) {
+      if (attempt >= RETRY_MAX_ATTEMPTS || !isRetryableDiscordError(error)) {
+        throw error;
+      }
+      const waitMs = extractRetryDelayMs(error, delayMs);
+      logger.warn({ label, attempt, waitMs, error }, 'Discord request failed; retrying');
+      await new Promise((resolve) => setTimeout(resolve, waitMs));
+      delayMs = Math.min(delayMs * 2, 4_000);
+    }
+  }
+}
+
+export class DiscordStreamManager {
+  private readonly sourceMessage: DiscordMessage;
+  private readonly channel: DiscordSendChannel;
+  private readonly maxChars: number;
+  private readonly maxLines: number;
+  private readonly editIntervalMs: number;
+  private readonly onFirstMessage?: () => void;
+
+  private readonly messages: DiscordEditMessage[] = [];
+  private sentChunks: string[] = [];
+  private content = '';
+  private lastEditAt = 0;
+  private flushTimer: ReturnType<typeof setTimeout> | null = null;
+  private opQueue = Promise.resolve();
+  private closed = false;
+
+  constructor(sourceMessage: DiscordMessage, options?: DiscordStreamOptions) {
+    this.sourceMessage = sourceMessage;
+    this.channel = sourceMessage.channel as unknown as DiscordSendChannel;
+    this.maxChars = Math.max(200, options?.maxChars ?? DEFAULT_MAX_CHARS);
+    this.maxLines = Math.max(4, options?.maxLines ?? DEFAULT_MAX_LINES);
+    this.editIntervalMs = Math.max(250, options?.editIntervalMs ?? DEFAULT_EDIT_INTERVAL_MS);
+    this.onFirstMessage = options?.onFirstMessage;
+  }
+
+  hasSentMessages(): boolean {
+    return this.messages.length > 0;
+  }
+
+  append(delta: string): Promise<void> {
+    if (this.closed) return Promise.resolve();
+    if (!delta) return Promise.resolve();
+    this.content += delta;
+    return this.enqueue(async () => {
+      await this.sync(false);
+    });
+  }
+
+  finalize(finalText: string, files?: AttachmentBuilder[]): Promise<void> {
+    if (this.closed) return Promise.resolve();
+    this.content = finalText;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    return this.enqueue(async () => {
+      await this.sync(true, files);
+      this.closed = true;
+    });
+  }
+
+  fail(errorText: string): Promise<void> {
+    if (this.closed) return Promise.resolve();
+    this.content = this.content
+      ? `${this.content}\n\n${errorText}`
+      : errorText;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    return this.enqueue(async () => {
+      await this.sync(true);
+      this.closed = true;
+    });
+  }
+
+  discard(): Promise<void> {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.closed = true;
+    return this.enqueue(async () => {
+      for (const message of this.messages) {
+        try {
+          await withDiscordRetry('delete', () => message.delete());
+        } catch (error) {
+          logger.debug({ error }, 'Failed to delete partial streamed message');
+        }
+      }
+      this.messages.length = 0;
+      this.sentChunks = [];
+      this.content = '';
+    });
+  }
+
+  private enqueue(task: () => Promise<void>): Promise<void> {
+    this.opQueue = this.opQueue
+      .then(task)
+      .catch((error) => {
+        logger.warn({ error }, 'Discord stream operation failed');
+      });
+    return this.opQueue;
+  }
+
+  private scheduleFlush(): void {
+    if (this.flushTimer || this.closed) return;
+    const waitMs = Math.max(0, this.editIntervalMs - (Date.now() - this.lastEditAt));
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      void this.enqueue(async () => {
+        await this.sync(false);
+      });
+    }, waitMs);
+  }
+
+  private async sync(forceLastEdit: boolean, files?: AttachmentBuilder[]): Promise<void> {
+    const chunks = chunkMessage(this.content, {
+      maxChars: this.maxChars,
+      maxLines: this.maxLines,
+    });
+
+    if (chunks.length === 0) {
+      if (files && files.length > 0) {
+        const fallback = 'Attached files:';
+        const sent = await withDiscordRetry('reply', () => this.sourceMessage.reply({ content: fallback, files }));
+        this.messages.push(sent as unknown as DiscordEditMessage);
+        this.sentChunks.push(fallback);
+        this.onFirstMessage?.();
+      }
+      return;
+    }
+
+    for (let i = 0; i < chunks.length; i += 1) {
+      const chunk = chunks[i];
+      const isLast = i === chunks.length - 1;
+
+      if (i >= this.messages.length) {
+        const sent = i === 0
+          ? await withDiscordRetry('reply', () => this.sourceMessage.reply({ content: chunk }))
+          : await withDiscordRetry('send', () => this.channel.send({ content: chunk }));
+        this.messages.push(sent as unknown as DiscordEditMessage);
+        this.sentChunks.push(chunk);
+        this.onFirstMessage?.();
+        continue;
+      }
+
+      if (this.sentChunks[i] === chunk) continue;
+
+      const elapsed = Date.now() - this.lastEditAt;
+      if (isLast && !forceLastEdit && elapsed < this.editIntervalMs) {
+        this.scheduleFlush();
+        continue;
+      }
+
+      await withDiscordRetry('edit', () => this.messages[i].edit({ content: chunk }));
+      this.sentChunks[i] = chunk;
+      this.lastEditAt = Date.now();
+    }
+
+    if (this.messages.length > chunks.length) {
+      for (let i = this.messages.length - 1; i >= chunks.length; i -= 1) {
+        await withDiscordRetry('delete', () => this.messages[i].delete());
+      }
+      this.messages.splice(chunks.length);
+      this.sentChunks = this.sentChunks.slice(0, chunks.length);
+    }
+
+    if (files && files.length > 0) {
+      const lastIndex = chunks.length - 1;
+      await withDiscordRetry('edit', () => this.messages[lastIndex].edit({ content: chunks[lastIndex], files }));
+      this.sentChunks[lastIndex] = chunks[lastIndex];
+      this.lastEditAt = Date.now();
+    }
+  }
+}