@cuylabs/agent-core 0.4.0 → 0.6.0

package/dist/chunk-P6YF7USR.js

@@ -0,0 +1,182 @@
+// src/tool/replay.ts
+function inferSideEffectLevel(fileOps, requestedLevel) {
+  if (requestedLevel) {
+    return requestedLevel;
+  }
+  switch (fileOps?.operationType) {
+    case "read":
+      return "none";
+    case "write":
+    case "create":
+    case "delete":
+      return "local";
+    default:
+      return "external";
+  }
+}
+function inferReplayMode(sideEffectLevel, requestedMode) {
+  if (requestedMode) {
+    return requestedMode;
+  }
+  return sideEffectLevel === "none" ? "replay" : "manual";
+}
+function normalizeToolReplayPolicy(policy, fileOps) {
+  const sideEffectLevel = inferSideEffectLevel(
+    fileOps,
+    policy?.sideEffectLevel
+  );
+  const mode = inferReplayMode(sideEffectLevel, policy?.mode);
+  return {
+    mode,
+    sideEffectLevel,
+    ...policy?.reason ? { reason: policy.reason } : {}
+  };
+}
+
+// src/tool/truncation.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+var MAX_LINES = 2e3;
+var MAX_BYTES = 1e5;
+var TRUNCATE_DIR = path.join(os.tmpdir(), "cuylabs-agent-outputs");
+var TRUNCATE_GLOB = path.join(TRUNCATE_DIR, "*");
+function truncateOutput(output, options = {}) {
+  const maxLines = options.maxLines ?? MAX_LINES;
+  const maxBytes = options.maxBytes ?? MAX_BYTES;
+  const lines = output.split("\n");
+  const bytes = Buffer.byteLength(output, "utf-8");
+  if (lines.length <= maxLines && bytes <= maxBytes) {
+    return {
+      content: output,
+      truncated: false
+    };
+  }
+  const hash = crypto.createHash("sha256").update(output).digest("hex").slice(0, 16);
+  const outputPath = path.join(TRUNCATE_DIR, `output-${hash}.txt`);
+  fs.mkdir(TRUNCATE_DIR, { recursive: true }).then(() => fs.writeFile(outputPath, output, "utf-8")).catch(() => {
+  });
+  let truncated;
+  if (lines.length > maxLines) {
+    const keepLines = Math.floor(maxLines / 2);
+    const firstPart = lines.slice(0, keepLines);
+    const lastPart = lines.slice(-keepLines);
+    const omitted = lines.length - keepLines * 2;
+    truncated = [
+      ...firstPart,
+      `
+... (${omitted} lines omitted, full output saved to ${outputPath}) ...
+`,
+      ...lastPart
+    ].join("\n");
+  } else {
+    const keepBytes = Math.floor(maxBytes / 2);
+    const start = output.slice(0, keepBytes);
+    const end = output.slice(-keepBytes);
+    const omittedBytes = bytes - keepBytes * 2;
+    truncated = `${start}
+... (${omittedBytes} bytes omitted, full output saved to ${outputPath}) ...
+${end}`;
+  }
+  return {
+    content: truncated,
+    truncated: true,
+    outputPath
+  };
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+// src/tool/tool.ts
+import { z } from "zod";
+var Tool;
+((Tool2) => {
+  function define(id, init, options = {}) {
+    const staticReplayPolicy = typeof init === "function" ? options.replayPolicy ? normalizeToolReplayPolicy(options.replayPolicy) : void 0 : normalizeToolReplayPolicy(
+      options.replayPolicy ?? init.replayPolicy,
+      init.fileOps
+    );
+    return {
+      id,
+      replayPolicy: staticReplayPolicy,
+      init: async (initCtx) => {
+        const toolInfo = typeof init === "function" ? await init(initCtx) : init;
+        const replayPolicy = normalizeToolReplayPolicy(
+          toolInfo.replayPolicy ?? staticReplayPolicy,
+          toolInfo.fileOps
+        );
+        const originalExecute = toolInfo.execute;
+        const execute = async (params, ctx) => {
+          try {
+            toolInfo.parameters.parse(params);
+          } catch (error) {
+            if (error instanceof z.ZodError && toolInfo.formatValidationError) {
+              throw new Error(toolInfo.formatValidationError(error), {
+                cause: error
+              });
+            }
+            throw new Error(
+              `The ${id} tool was called with invalid arguments: ${error}.
+Please rewrite the input so it satisfies the expected schema.`,
+              { cause: error }
+            );
+          }
+          const result = await originalExecute(params, ctx);
+          if (result.metadata.truncated !== void 0) {
+            return result;
+          }
+          const truncated = truncateOutput(result.output);
+          return {
+            ...result,
+            output: truncated.content,
+            metadata: {
+              ...result.metadata,
+              truncated: truncated.truncated,
+              ...truncated.truncated && { outputPath: truncated.outputPath }
+            }
+          };
+        };
+        return {
+          ...toolInfo,
+          replayPolicy,
+          execute
+        };
+      }
+    };
+  }
+  Tool2.define = define;
+  function defineSimple(id, config) {
+    return define(id, config);
+  }
+  Tool2.defineSimple = defineSimple;
+})(Tool || (Tool = {}));
+function defineTool(definition) {
+  return Tool.define(definition.id, {
+    description: definition.description,
+    parameters: definition.parameters,
+    execute: async (params, ctx) => {
+      const result = await definition.execute(params, ctx);
+      return {
+        title: result.title,
+        output: result.output,
+        metadata: result.metadata ?? {}
+      };
+    }
+  });
+}
+
+export {
+  normalizeToolReplayPolicy,
+  MAX_LINES,
+  MAX_BYTES,
+  TRUNCATE_DIR,
+  TRUNCATE_GLOB,
+  truncateOutput,
+  formatSize,
+  Tool,
+  defineTool
+};

package/dist/chunk-QAQADS4X.js

@@ -0,0 +1,258 @@
+// src/context/estimation.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function estimateMessageTokens(message) {
+  if (typeof message.content === "string") {
+    return estimateTokens(message.content);
+  }
+  if (Array.isArray(message.content)) {
+    let total = 0;
+    for (const part of message.content) {
+      if (typeof part === "string") {
+        total += estimateTokens(part);
+      } else if ("text" in part && typeof part.text === "string") {
+        total += estimateTokens(part.text);
+      } else if ("type" in part && part.type === "image") {
+        total += 765;
+      }
+    }
+    return total;
+  }
+  return 0;
+}
+function estimateConversationTokens(messages) {
+  let total = 0;
+  for (const message of messages) {
+    total += estimateMessageTokens(message);
+    total += 4;
+  }
+  return total;
+}
+
+// src/types/agent/compaction.ts
+var PRUNE_PROTECTED_TOOLS = ["skill"];
+
+// src/context/pruning.ts
+var DEFAULT_CONTEXT_LIMITS = {
+  contextWindow: 128e3,
+  reserveTokens: 16e3,
+  // Reserve for output
+  protectedTokens: 4e4,
+  // Keep recent 40 k tokens
+  pruneMinimum: 2e4
+  // Don't prune until 20 k tokens
+};
+function isContextOverflowing(tokens, limits = DEFAULT_CONTEXT_LIMITS) {
+  const threshold = limits.contextWindow - limits.reserveTokens;
+  return tokens > threshold;
+}
+function shouldPruneContext(tokens, limits = DEFAULT_CONTEXT_LIMITS) {
+  if (tokens < limits.pruneMinimum) return false;
+  return isContextOverflowing(tokens, limits);
+}
+function findCutPoint(messages, protectedTokens = DEFAULT_CONTEXT_LIMITS.protectedTokens) {
+  if (messages.length === 0) return 0;
+  let tokensFromEnd = 0;
+  let cutIndex = messages.length;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    tokensFromEnd += estimateMessageTokens(messages[i]);
+    if (tokensFromEnd >= protectedTokens) {
+      cutIndex = i;
+      break;
+    }
+  }
+  if (cutIndex <= 1) return 0;
+  const startIndex = cutIndex >= messages.length ? messages.length - 1 : cutIndex;
+  for (let i = startIndex; i >= 1; i--) {
+    const msg = messages[i];
+    const prevMsg = messages[i - 1];
+    if (!msg || !prevMsg) continue;
+    if (msg.role === "tool") continue;
+    if (prevMsg.role === "assistant" || prevMsg.role === "user") {
+      return i;
+    }
+  }
+  return 0;
+}
+function pruneToolResults(messages, protectedTokens = DEFAULT_CONTEXT_LIMITS.protectedTokens, options) {
+  const protectedToolSet = /* @__PURE__ */ new Set([
+    ...PRUNE_PROTECTED_TOOLS,
+    ...options?.protectedTools ?? []
+  ]);
+  let tokensFromEnd = 0;
+  const tokenPositions = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    tokensFromEnd += estimateMessageTokens(messages[i]);
+    tokenPositions[i] = tokensFromEnd;
+  }
+  return messages.map((msg, i) => {
+    if (tokenPositions[i] < protectedTokens) return msg;
+    if (!("role" in msg) || msg.role !== "tool") return msg;
+    const toolMsg = msg;
+    if ("compactedAt" in toolMsg && toolMsg.compactedAt) return msg;
+    if (toolMsg.toolName && protectedToolSet.has(toolMsg.toolName)) return msg;
+    const currentTokens = estimateTokens(toolMsg.content);
+    if (currentTokens < 500) return msg;
+    return {
+      ...toolMsg,
+      content: `[Output pruned - was ${currentTokens} tokens]`,
+      compactedAt: Date.now()
+    };
+  });
+}
+
+// src/context/summarization.ts
+import { generateText } from "ai";
+var DEFAULT_SUMMARY_PROMPT = `You are summarizing a conversation to continue it with context.
+
+Create a structured summary that captures:
+1. **Goal**: What the user is trying to accomplish
+2. **Progress**: What has been done so far
+3. **Decisions**: Key decisions made during the conversation
+4. **Current State**: Where we left off
+5. **Next Steps**: What should happen next
+
+Be concise but comprehensive. Include specific file paths, function names, and technical details that would be lost otherwise.
+
+Format as a clear summary that could be given to another assistant to continue the work.`;
+async function generateSummary(messages, options) {
+  const conversationText = messages.map((m) => {
+    const role = m.role.toUpperCase();
+    const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+    return `[${role}]: ${content}`;
+  }).join("\n\n");
+  const prompt = options.customPrompt || DEFAULT_SUMMARY_PROMPT;
+  const { text } = await generateText({
+    model: options.model,
+    maxOutputTokens: options.maxTokens ?? 2e3,
+    system: prompt,
+    prompt: `Summarize this conversation:
+
+${conversationText}`
+  });
+  return text;
+}
+async function pruneContext(messages, options = {}) {
+  const limits = options.limits ?? DEFAULT_CONTEXT_LIMITS;
+  let currentMessages = [...messages];
+  let tokensRemoved = 0;
+  let removedCount = 0;
+  let summarized = false;
+  let summary;
+  const initialTokens = estimateConversationTokens(currentMessages);
+  if (!shouldPruneContext(initialTokens, limits)) {
+    return { messages: currentMessages, removedCount: 0, tokensRemoved: 0, summarized: false };
+  }
+  const prunedMessages = pruneToolResults(currentMessages, limits.protectedTokens);
+  const afterPruneTokens = estimateConversationTokens(prunedMessages);
+  tokensRemoved = initialTokens - afterPruneTokens;
+  currentMessages = prunedMessages;
+  if (!isContextOverflowing(afterPruneTokens, limits)) {
+    return { messages: currentMessages, removedCount: 0, tokensRemoved, summarized: false };
+  }
+  const cutIndex = findCutPoint(currentMessages, limits.protectedTokens);
+  if (cutIndex === 0) {
+    return { messages: currentMessages, removedCount: 0, tokensRemoved, summarized: false };
+  }
+  const toSummarize = currentMessages.slice(0, cutIndex);
+  const toKeep = currentMessages.slice(cutIndex);
+  removedCount = toSummarize.length;
+  tokensRemoved += estimateConversationTokens(toSummarize);
+  if (options.model) {
+    summary = await generateSummary(toSummarize, {
+      model: options.model,
+      customPrompt: options.summaryPrompt
+    });
+    summarized = true;
+    const summaryMessage = {
+      id: crypto.randomUUID(),
+      role: "system",
+      content: `## Previous Conversation Summary
+
+${summary}`,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    currentMessages = [summaryMessage, ...toKeep];
+  } else {
+    currentMessages = toKeep;
+  }
+  return { messages: currentMessages, removedCount, tokensRemoved, summarized, summary };
+}
+
+// src/context/manager.ts
+var ContextManager = class {
+  limits;
+  model;
+  summaryPrompt;
+  constructor(options) {
+    this.limits = { ...DEFAULT_CONTEXT_LIMITS, ...options?.limits };
+    this.model = options?.model;
+    this.summaryPrompt = options?.summaryPrompt;
+  }
+  /** Get a copy of the current context limits. */
+  getLimits() {
+    return { ...this.limits };
+  }
+  /** Update context limits (e.g. when switching models). */
+  setLimits(limits) {
+    this.limits = { ...this.limits, ...limits };
+  }
+  /** Set the model used for summarisation. */
+  setModel(model) {
+    this.model = model;
+  }
+  /** Estimate total tokens for a message array. */
+  estimateTokens(messages) {
+    return estimateConversationTokens(messages);
+  }
+  /** Check whether the context is overflowing. */
+  isOverflowing(messages) {
+    const tokens = this.estimateTokens(messages);
+    return isContextOverflowing(tokens, this.limits);
+  }
+  /** Check whether pruning should be triggered. */
+  shouldPrune(messages) {
+    const tokens = this.estimateTokens(messages);
+    return shouldPruneContext(tokens, this.limits);
+  }
+  /** Prune context to fit within limits. */
+  async prune(messages) {
+    return pruneContext(messages, {
+      model: this.model,
+      limits: this.limits,
+      summaryPrompt: this.summaryPrompt
+    });
+  }
+  /**
+   * Get a snapshot of token statistics.
+   *
+   * Useful for dashboards, logging, or deciding whether to prune.
+   */
+  getStats(messages) {
+    const tokens = this.estimateTokens(messages);
+    const limit = this.limits.contextWindow - this.limits.reserveTokens;
+    return {
+      tokens,
+      limit,
+      available: Math.max(0, limit - tokens),
+      utilizationPercent: Math.round(tokens / limit * 100),
+      isOverflowing: isContextOverflowing(tokens, this.limits),
+      shouldPrune: shouldPruneContext(tokens, this.limits)
+    };
+  }
+};
+
+export {
+  estimateTokens,
+  estimateMessageTokens,
+  estimateConversationTokens,
+  DEFAULT_CONTEXT_LIMITS,
+  isContextOverflowing,
+  shouldPruneContext,
+  findCutPoint,
+  pruneToolResults,
+  generateSummary,
+  pruneContext,
+  ContextManager
+};