@raindrop-ai/deep-agents 0.1.2 → 0.1.4

package/dist/index.js

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  PROMPT_TOOLS_ATTRIBUTE: () => PROMPT_TOOLS_ATTRIBUTE,
   RaindropDeepAgentsHandler: () => RaindropDeepAgentsHandler,
   createRaindropDeepAgents: () => createRaindropDeepAgents
 });
@@ -90,7 +91,7 @@ function evalScopeAttributes() {
   return { [EVAL_CORRELATION_ID_ATTRIBUTE]: scope.correlationId };
 }
 
-// ../core/dist/chunk-WJOR6M7H.js
+// ../core/dist/chunk-I6TVJQEC.js
 var STATE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.replayTraceRoutingState");
 function state() {
   const holder = globalThis;
@@ -2077,6 +2078,158 @@ var TraceShipper = class {
     }
   }
 };
+var PROMPT_TOOLS_ATTRIBUTE = "ai.prompt.tools";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var JSON_SCHEMA_KEYS = [
+  "type",
+  "properties",
+  "$schema",
+  "$ref",
+  "anyOf",
+  "oneOf",
+  "allOf",
+  "enum",
+  "const",
+  "items",
+  "additionalProperties",
+  "required"
+];
+function isJsonSchema(value) {
+  if (!isRecord(value)) return false;
+  if (typeof value["~standard"] === "object") return false;
+  if (isRecord(value._def) || isRecord(value._zod)) return false;
+  if (Object.keys(value).length === 0) return true;
+  return JSON_SCHEMA_KEYS.some((key) => key in value);
+}
+function toJsonSchema(value, options) {
+  if (value === void 0 || value === null) return void 0;
+  if (isJsonSchema(value)) return value;
+  if (isRecord(value) && isJsonSchema(value.jsonSchema)) return value.jsonSchema;
+  if (isRecord(value) && isJsonSchema(value.json)) return value.json;
+  if (options == null ? void 0 : options.schema) {
+    try {
+      return options.schema(value);
+    } catch (e) {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function pickString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function functionTool(name, description, schema, options) {
+  const tool = { type: "function", name };
+  const desc = pickString(description);
+  if (desc !== void 0) tool.description = desc;
+  const inputSchema = toJsonSchema(schema, options);
+  if (inputSchema !== void 0) tool.inputSchema = inputSchema;
+  return tool;
+}
+function normalizeToolDeclaration(tool, options, fallbackName) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  if (!isRecord(tool)) return void 0;
+  if (tool.type === "provider-defined" || tool.type === "provider") {
+    const name2 = (_b = (_a = pickString(tool.name)) != null ? _a : pickString(tool.id)) != null ? _b : fallbackName;
+    if (name2 === void 0) return void 0;
+    const declaration = { type: "provider-defined", name: name2 };
+    const id = pickString(tool.id);
+    if (id !== void 0) declaration.id = id;
+    if (isRecord(tool.args)) declaration.args = tool.args;
+    return declaration;
+  }
+  if (isRecord(tool.toolSpec)) {
+    const spec = tool.toolSpec;
+    const name2 = (_c = pickString(spec.name)) != null ? _c : fallbackName;
+    if (name2 === void 0) return void 0;
+    return functionTool(name2, spec.description, spec.inputSchema, options);
+  }
+  if (isRecord(tool.function)) {
+    const fn = tool.function;
+    const name2 = (_d = pickString(fn.name)) != null ? _d : fallbackName;
+    if (name2 === void 0) return void 0;
+    return functionTool(name2, fn.description, (_e = fn.parameters) != null ? _e : fn.input_schema, options);
+  }
+  const name = (_g = (_f = pickString(tool.name)) != null ? _f : pickString(tool.id)) != null ? _g : fallbackName;
+  if (name === void 0) return void 0;
+  const type = pickString(tool.type);
+  if (type !== void 0 && type !== "function" && type !== "dynamic" && type !== "custom") {
+    if (!("input_schema" in tool) && !("inputSchema" in tool) && !("parameters" in tool)) {
+      return { type: "provider-defined", id: type, name };
+    }
+  }
+  return functionTool(
+    name,
+    tool.description,
+    (_j = (_i = (_h = tool.inputSchema) != null ? _h : tool.input_schema) != null ? _i : tool.parameters) != null ? _j : tool.schema,
+    options
+  );
+}
+var NOT_A_GEMINI_GROUP_KEYS = ["name", "id", "type", "function", "toolSpec", "cachePoint"];
+function isGeminiToolGroup(tool) {
+  if (Array.isArray(tool.functionDeclarations)) return true;
+  const keys = Object.keys(tool);
+  if (keys.length === 0 || NOT_A_GEMINI_GROUP_KEYS.some((key) => key in tool)) return false;
+  return keys.every((key) => isRecord(tool[key]));
+}
+function expandGeminiTool(tool, options) {
+  const declarations = [];
+  for (const [key, value] of Object.entries(tool)) {
+    if (key === "functionDeclarations" && Array.isArray(value)) {
+      for (const declaration of value) {
+        const normalized = normalizeToolDeclaration(declaration, options);
+        if (normalized) declarations.push(normalized);
+      }
+    } else if (isRecord(value)) {
+      declarations.push({ type: "provider-defined", id: key, name: key, args: value });
+    }
+  }
+  return declarations;
+}
+function normalizeToolDeclarations(tools, options) {
+  if (tools === void 0 || tools === null) return void 0;
+  if (Array.isArray(tools)) {
+    return tools.flatMap((tool) => {
+      if (isRecord(tool) && isGeminiToolGroup(tool)) {
+        return expandGeminiTool(tool, options);
+      }
+      const declaration = normalizeToolDeclaration(tool, options);
+      return declaration ? [declaration] : [];
+    });
+  }
+  if (!isRecord(tools)) return void 0;
+  return Object.entries(tools).flatMap(([key, tool]) => {
+    const declaration = normalizeToolDeclaration(tool, options, key);
+    return declaration ? [declaration] : [];
+  });
+}
+function resolvePromptTools(args) {
+  var _a;
+  if (args.override !== void 0) {
+    return (_a = normalizeToolDeclarations(args.override, args.options)) != null ? _a : [];
+  }
+  return normalizeToolDeclarations(args.inferred, args.options);
+}
+function promptToolsAttribute(tools) {
+  const values = promptToolsAttributeValue(tools);
+  if (values === void 0) return void 0;
+  return {
+    key: PROMPT_TOOLS_ATTRIBUTE,
+    value: { arrayValue: { values: values.map((stringValue) => ({ stringValue })) } }
+  };
+}
+function promptToolsAttributeValue(tools) {
+  if (tools === void 0) return void 0;
+  return tools.map((tool) => {
+    try {
+      return JSON.stringify(tool);
+    } catch (e) {
+      return JSON.stringify({ type: tool.type, name: tool.name });
+    }
+  });
+}
 
 // ../core/dist/index.node.js
 var import_async_hooks = require("async_hooks");
@@ -2252,7 +2405,470 @@ function installTracingSuppressionHook() {
 }
 installTracingSuppressionHook();
 
+// src/conversation.ts
+var import_messages = require("@langchain/core/messages");
+
+// src/truncation.ts
+var TRUNCATION_MARKER2 = "...[truncated by raindrop]";
+var DEFAULT_MAX_TEXT_FIELD_CHARS2 = 1e6;
+var MAX_DEPTH = 12;
+var configuredMaxTextFieldChars;
+function setMaxTextFieldChars(limit) {
+  if (limit === void 0) return;
+  if (typeof limit === "number" && Number.isFinite(limit) && limit > 0) {
+    configuredMaxTextFieldChars = Math.floor(limit);
+  } else {
+    console.warn(`[raindrop-ai] maxTextFieldChars=${String(limit)} ignored; must be > 0`);
+  }
+}
+function otelEnvLimit() {
+  if (typeof process === "undefined") return void 0;
+  const raw = process.env?.OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT;
+  if (!raw) return void 0;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function eventMaxTextFieldChars() {
+  return configuredMaxTextFieldChars ?? DEFAULT_MAX_TEXT_FIELD_CHARS2;
+}
+function spanAttributeLimit(limit) {
+  const env = otelEnvLimit();
+  return env !== void 0 && env < limit ? env : limit;
+}
+function effectiveMaxTextFieldChars() {
+  return spanAttributeLimit(eventMaxTextFieldChars());
+}
+function truncateToLimit2(text, limit) {
+  if (limit > TRUNCATION_MARKER2.length) {
+    return text.slice(0, limit - TRUNCATION_MARKER2.length) + TRUNCATION_MARKER2;
+  }
+  return text.slice(0, limit);
+}
+function capText2(value, limit) {
+  if (typeof value !== "string") return value;
+  const max = limit ?? effectiveMaxTextFieldChars();
+  if (value.length <= max) return value;
+  return truncateToLimit2(value, max);
+}
+function boundedClone2(value, budget, depth) {
+  if (budget.remaining <= 0) return TRUNCATION_MARKER2;
+  if (typeof value === "string") {
+    if (value.length > budget.remaining) {
+      const taken = value.slice(0, Math.max(0, budget.remaining)) + TRUNCATION_MARKER2;
+      budget.remaining = 0;
+      return taken;
+    }
+    budget.remaining -= Math.max(value.length, 1);
+    return value;
+  }
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    budget.remaining -= 8;
+    return value;
+  }
+  if (typeof value === "bigint") return boundedClone2(value.toString(), budget, depth);
+  if (typeof value !== "object") {
+    budget.remaining -= 1;
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    const maxBytes = Math.max(0, Math.ceil(budget.remaining * 3 / 4));
+    if (value.byteLength > maxBytes) {
+      const taken = base64Encode(value.subarray(0, maxBytes)) + TRUNCATION_MARKER2;
+      budget.remaining = 0;
+      return taken;
+    }
+    const encoded = base64Encode(value);
+    budget.remaining -= Math.max(encoded.length, 1);
+    return encoded;
+  }
+  if (depth >= MAX_DEPTH) {
+    budget.remaining -= 16;
+    const name = value.constructor?.name ?? "object";
+    return `<max depth: ${name}>`;
+  }
+  const toJSON = value.toJSON;
+  if (typeof toJSON === "function") {
+    budget.remaining -= 2;
+    return boundedClone2(toJSON.call(value), budget, depth + 1);
+  }
+  if (Array.isArray(value)) {
+    budget.remaining -= 2;
+    const out2 = [];
+    for (const item of value) {
+      if (budget.remaining <= 0) {
+        out2.push(TRUNCATION_MARKER2);
+        break;
+      }
+      out2.push(boundedClone2(item, budget, depth + 1));
+    }
+    return out2;
+  }
+  budget.remaining -= 2;
+  const out = {};
+  for (const key in value) {
+    if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+    if (budget.remaining <= 0) {
+      out["..."] = TRUNCATION_MARKER2;
+      break;
+    }
+    let cappedKey = key;
+    if (key.length > budget.remaining) {
+      cappedKey = key.slice(0, Math.max(0, budget.remaining)) + TRUNCATION_MARKER2;
+      budget.remaining = 0;
+      out[cappedKey] = TRUNCATION_MARKER2;
+      break;
+    }
+    budget.remaining -= Math.max(key.length, 1);
+    out[cappedKey] = boundedClone2(value[key], budget, depth + 1);
+  }
+  return out;
+}
+function boundedStringify(value, limit) {
+  const max = limit ?? effectiveMaxTextFieldChars();
+  try {
+    if (typeof value === "string") {
+      const text2 = JSON.stringify(capText2(value, max));
+      return text2.length <= max ? text2 : truncateToLimit2(text2, max);
+    }
+    const pruned = boundedClone2(value, { remaining: max + TRUNCATION_MARKER2.length + 256 }, 0);
+    const text = JSON.stringify(pruned);
+    if (text === void 0) return void 0;
+    return text.length <= max ? text : truncateToLimit2(text, max);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/conversation.ts
+var CAPTURE_TRUNCATED_ROLE = "raindrop";
+var MESSAGE_OVERHEAD = 32;
+var PART_OVERHEAD = 24;
+var MAX_DEPTH2 = 12;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(record, key) {
+  const value = record[key];
+  return typeof value === "string" ? value : void 0;
+}
+function takeText(text, budget) {
+  if (text.length > budget.remaining) {
+    const kept = text.slice(0, Math.max(0, budget.remaining)) + TRUNCATION_MARKER2;
+    budget.remaining = 0;
+    budget.truncated = true;
+    return kept;
+  }
+  budget.remaining -= Math.max(text.length, 1);
+  return text;
+}
+function reserve(text, budget) {
+  if (text !== void 0) budget.remaining -= Math.max(text.length, 1);
+  return text;
+}
+function takeValue(value, budget, depth) {
+  if (typeof value === "string") return takeText(value, budget);
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    budget.remaining -= 8;
+    return value;
+  }
+  if (typeof value !== "object") {
+    budget.remaining -= 1;
+    return value;
+  }
+  if (depth >= MAX_DEPTH2) {
+    budget.remaining -= TRUNCATION_MARKER2.length;
+    budget.truncated = true;
+    return TRUNCATION_MARKER2;
+  }
+  if ("toJSON" in value && typeof value.toJSON === "function") {
+    return takeValue(value.toJSON(), budget, depth + 1);
+  }
+  if (Array.isArray(value)) {
+    budget.remaining -= 2;
+    const out2 = [];
+    for (const item of value) {
+      if (budget.remaining <= 0) {
+        budget.truncated = true;
+        out2.push(TRUNCATION_MARKER2);
+        break;
+      }
+      out2.push(takeValue(item, budget, depth + 1));
+    }
+    return out2;
+  }
+  budget.remaining -= 2;
+  const out = {};
+  if (!isRecord2(value)) return out;
+  for (const key in value) {
+    if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+    if (budget.remaining <= 0) {
+      budget.truncated = true;
+      out["..."] = TRUNCATION_MARKER2;
+      break;
+    }
+    budget.remaining -= Math.max(key.length, 1);
+    out[key] = takeValue(value[key], budget, depth + 1);
+  }
+  return out;
+}
+function messageType(message) {
+  return typeof message._getType === "function" ? message._getType() : void 0;
+}
+function textPart(text, budget) {
+  return { type: "text", text: takeText(text, budget) };
+}
+function joinedText(content, budget) {
+  const texts = [];
+  for (const block of content) {
+    if (budget.remaining <= 0) {
+      budget.truncated = true;
+      texts.push(TRUNCATION_MARKER2);
+      break;
+    }
+    budget.remaining -= 1;
+    if (!isRecord2(block)) continue;
+    const text = stringField(block, "text");
+    if (text !== void 0) texts.push(takeText(text, budget));
+  }
+  return texts.join("\n");
+}
+function contentPart(block, budget) {
+  budget.remaining -= PART_OVERHEAD;
+  if (!isRecord2(block)) return takeValue(block, budget, 0);
+  const type = stringField(block, "type");
+  const text = stringField(block, "text");
+  if (type === "text" && text !== void 0) return textPart(text, budget);
+  if (type === "image_url") {
+    const imageUrl = block["image_url"];
+    const url = typeof imageUrl === "string" ? imageUrl : isRecord2(imageUrl) ? stringField(imageUrl, "url") : void 0;
+    if (url !== void 0) return { type: "image", image: takeText(url, budget) };
+  }
+  if (type === "thinking") {
+    const thinking = stringField(block, "thinking");
+    if (thinking !== void 0) return { type: "reasoning", text: takeText(thinking, budget) };
+  }
+  if (type === "image" || type === "file" || type === "audio") {
+    const mediaType = stringField(block, "mime_type");
+    const sourceType = stringField(block, "source_type");
+    const source = block["source"];
+    if (sourceType === "text" && text !== void 0) return textPart(text, budget);
+    const data = sourceType === "url" ? stringField(block, "url") : sourceType === "base64" ? stringField(block, "data") : isRecord2(source) ? stringField(source, "url") ?? stringField(source, "data") : void 0;
+    const sourceMediaType = mediaType ?? (isRecord2(source) ? stringField(source, "media_type") : void 0);
+    if (data !== void 0) {
+      const filename = stringField(block, "filename");
+      return type === "image" ? { type: "image", image: takeText(data, budget), mediaType: reserve(sourceMediaType, budget) } : {
+        type: "file",
+        data: takeText(data, budget),
+        mediaType: reserve(sourceMediaType, budget),
+        filename: reserve(filename, budget)
+      };
+    }
+  }
+  return takeValue(block, budget, 0);
+}
+function contentParts(content, budget, skipToolUseIds) {
+  const parts = [];
+  for (const block of content) {
+    if (budget.remaining <= 0) {
+      budget.truncated = true;
+      parts.push({ type: "text", text: TRUNCATION_MARKER2 });
+      break;
+    }
+    if (isRecord2(block) && (block["type"] === "tool_use" || block["type"] === "tool_call")) {
+      const id = stringField(block, "id");
+      if (id !== void 0 && skipToolUseIds.has(id)) continue;
+    }
+    parts.push(contentPart(block, budget));
+  }
+  return parts;
+}
+function assistantMessage(message, budget, toolNames) {
+  const toolCalls = (0, import_messages.isAIMessage)(message) ? message.tool_calls ?? [] : [];
+  if (toolCalls.length === 0 && typeof message.content === "string") {
+    return { role: "assistant", content: takeText(message.content, budget) };
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const callParts = [];
+  for (const call of toolCalls) {
+    if (budget.remaining <= 0) {
+      budget.truncated = true;
+      callParts.push({ type: "text", text: TRUNCATION_MARKER2 });
+      break;
+    }
+    budget.remaining -= PART_OVERHEAD;
+    if (call.id !== void 0) {
+      ids.add(call.id);
+      toolNames.set(call.id, call.name);
+    }
+    callParts.push({
+      type: "tool-call",
+      toolCallId: reserve(call.id, budget),
+      toolName: reserve(call.name, budget),
+      input: takeValue(call.args, budget, 0)
+    });
+  }
+  const content = typeof message.content === "string" ? message.content.length > 0 ? [textPart(message.content, budget)] : [] : contentParts(message.content, budget, ids);
+  content.push(...callParts);
+  return { role: "assistant", content };
+}
+function toolResultOutput(message, budget) {
+  const failed = (0, import_messages.isToolMessage)(message) && message.status === "error";
+  if (typeof message.content === "string") {
+    return { type: failed ? "error-text" : "text", value: takeText(message.content, budget) };
+  }
+  return { type: "content", value: contentParts(message.content, budget, /* @__PURE__ */ new Set()) };
+}
+function toolMessage(message, budget, toolNames) {
+  const toolCallId = (0, import_messages.isToolMessage)(message) ? message.tool_call_id : void 0;
+  const toolName = message.name ?? (toolCallId !== void 0 ? toolNames.get(toolCallId) : void 0);
+  budget.remaining -= PART_OVERHEAD;
+  return {
+    role: "tool",
+    content: [{
+      type: "tool-result",
+      toolCallId: reserve(toolCallId, budget),
+      toolName: reserve(toolName, budget),
+      output: toolResultOutput(message, budget)
+    }]
+  };
+}
+function modelMessage(message, budget, toolNames) {
+  budget.remaining -= MESSAGE_OVERHEAD;
+  switch (messageType(message)) {
+    case "system":
+      return {
+        role: "system",
+        content: typeof message.content === "string" ? takeText(message.content, budget) : joinedText(message.content, budget)
+      };
+    case "ai":
+      return assistantMessage(message, budget, toolNames);
+    case "tool":
+    case "function":
+      return toolMessage(message, budget, toolNames);
+    case "generic": {
+      const role = (0, import_messages.isChatMessage)(message) ? message.role : void 0;
+      if (role === "assistant" || role === "system") {
+        return {
+          role,
+          content: typeof message.content === "string" ? takeText(message.content, budget) : joinedText(message.content, budget)
+        };
+      }
+      return userMessage(message, budget);
+    }
+    default:
+      return userMessage(message, budget);
+  }
+}
+function userMessage(message, budget) {
+  return {
+    role: "user",
+    content: typeof message.content === "string" ? takeText(message.content, budget) : contentParts(message.content, budget, /* @__PURE__ */ new Set())
+  };
+}
+function truncationRecord(omittedMessages) {
+  return { role: CAPTURE_TRUNCATED_ROLE, truncated: true, marker: TRUNCATION_MARKER2, omittedMessages };
+}
+function encodeWithinLimit(items, limit, overflow, convert) {
+  let textBudget = limit;
+  for (let attempt = 0; attempt < 8 && textBudget >= 64; attempt++) {
+    const budget = { remaining: textBudget, truncated: false };
+    const out = [];
+    let omitted = 0;
+    for (let i = 0; i < items.length; i++) {
+      if (overflow === "omit" && budget.remaining <= 0) {
+        omitted = items.length - i;
+        break;
+      }
+      out.push(convert(items[i], budget));
+    }
+    const truncated = budget.truncated || omitted > 0;
+    if (truncated && overflow === "omit") out.push(truncationRecord(omitted));
+    const json2 = JSON.stringify(out);
+    if (json2.length <= limit) return { json: json2, truncated };
+    const excess = json2.length - limit + 128;
+    textBudget = Math.max(textBudget - excess, Math.floor(textBudget / 2));
+  }
+  if (overflow === "keep") return void 0;
+  const json = JSON.stringify([truncationRecord(items.length)]);
+  return json.length <= limit ? { json, truncated: true } : void 0;
+}
+function captureConversation(messages, limit) {
+  if (messages.length === 0) return void 0;
+  try {
+    const toolNames = /* @__PURE__ */ new Map();
+    return encodeWithinLimit(
+      messages,
+      limit,
+      "omit",
+      (message, budget) => modelMessage(message, budget, toolNames)
+    );
+  } catch {
+    return void 0;
+  }
+}
+function capturePrompt(prompt, limit) {
+  try {
+    return encodeWithinLimit([prompt], limit, "omit", (text, budget) => {
+      budget.remaining -= MESSAGE_OVERHEAD;
+      return { role: "user", content: takeText(text, budget) };
+    });
+  } catch {
+    return void 0;
+  }
+}
+function captureToolCalls(message, limit) {
+  if (!isRecord2(message) || !Array.isArray(message["tool_calls"])) return void 0;
+  const calls = [];
+  let structural = 0;
+  for (const call of message["tool_calls"]) {
+    structural += PART_OVERHEAD;
+    if (isRecord2(call)) {
+      structural += (stringField(call, "id")?.length ?? 0) + (stringField(call, "name")?.length ?? 0);
+      calls.push(call);
+    }
+    if (structural > limit) return void 0;
+  }
+  if (calls.length === 0) return void 0;
+  try {
+    return encodeWithinLimit(calls, limit, "keep", (call, budget) => {
+      budget.remaining -= PART_OVERHEAD;
+      return {
+        toolCallId: reserve(stringField(call, "id"), budget),
+        toolName: reserve(stringField(call, "name"), budget),
+        input: takeValue(call["args"], budget, 0)
+      };
+    });
+  } catch {
+    return void 0;
+  }
+}
+function parseToolCallInput(input) {
+  try {
+    const parsed = JSON.parse(input);
+    if (isRecord2(parsed) && parsed["type"] === "tool_call" && "args" in parsed) {
+      return { id: stringField(parsed, "id"), args: JSON.stringify(parsed["args"]) };
+    }
+  } catch {
+  }
+  return { args: input };
+}
+function unwrapToolOutput(output) {
+  if ((0, import_messages.isBaseMessage)(output)) {
+    return {
+      content: output.content,
+      toolCallId: (0, import_messages.isToolMessage)(output) ? output.tool_call_id : void 0
+    };
+  }
+  return { content: output };
+}
+
 // src/callback-handler.ts
+function inferInvocationTools(extraParams) {
+  const params = extraParams?.invocation_params;
+  if (typeof params !== "object" || params === null) return void 0;
+  const record = { ...params };
+  return record.tools ?? record.functions;
+}
 function resolveEventId(source) {
   if (typeof source !== "function") return randomUUID();
   try {
@@ -2269,32 +2885,38 @@ function isInternalName(name) {
   if (name.startsWith("__") && name.endsWith("__")) return true;
   return false;
 }
-var CHAIN_TEXT_MAX_LEN = 8192;
-function extractTextFromContent(content) {
+function extractTextFromContent(content, limit) {
   if (content == null) return void 0;
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
     const parts = [];
+    let length = 0;
     for (const part of content) {
+      if (length > limit) break;
+      length += 1;
+      let text;
       if (typeof part === "string") {
-        parts.push(part);
+        text = part;
       } else if (part && typeof part === "object") {
         const p = part;
         if (typeof p.text === "string") {
-          parts.push(p.text);
+          text = p.text;
         } else if (p.type === "text" && typeof p.content === "string") {
-          parts.push(p.content);
+          text = p.content;
         }
       }
+      if (text === void 0) continue;
+      parts.push(text.length > limit ? text.slice(0, limit + 1) : text);
+      length += Math.max(text.length, 1);
     }
     if (parts.length > 0) return parts.join("\n");
-    return safeStringify(content, CHAIN_TEXT_MAX_LEN);
+    return boundedStringify(content, limit);
   }
   if (typeof content === "object") {
     const c = content;
     if (typeof c.text === "string") return c.text;
     if (typeof c.content === "string") return c.content;
-    return safeStringify(content, CHAIN_TEXT_MAX_LEN);
+    return boundedStringify(content, limit);
   }
   return String(content);
 }
@@ -2313,6 +2935,17 @@ var RaindropDeepAgentsHandler = class extends import_base.BaseCallbackHandler {
     this.eventName = opts.eventName;
     this.eventIdSource = opts.eventId;
     this.traceChains = opts.traceChains ?? true;
+    this.configuredSpanMaxChars = opts.maxTextFieldChars ?? eventMaxTextFieldChars();
+    this.eventMaxChars = opts.eventMaxTextFieldChars ?? eventMaxTextFieldChars();
+    this.promptTools = opts.tools;
+  }
+  promptToolsAttribute(extraParams) {
+    return promptToolsAttribute(
+      resolvePromptTools({ override: this.promptTools, inferred: inferInvocationTools(extraParams) })
+    );
+  }
+  get spanMaxChars() {
+    return spanAttributeLimit(this.configuredSpanMaxChars);
   }
   getEventId(runId, parentRunId) {
     const rootId = parentRunId ? this.rootRunIds.get(parentRunId) ?? parentRunId : runId;
@@ -2373,18 +3006,27 @@ var RaindropDeepAgentsHandler = class extends import_base.BaseCallbackHandler {
   // ---------------------------------------------------------------------------
   // LLM events
   // ---------------------------------------------------------------------------
-  async handleLLMStart(llm, prompts, runId, parentRunId, _extraParams, tags, metadata, runName) {
+  async handleLLMStart(llm, prompts, runId, parentRunId, extraParams, tags, metadata, runName) {
     try {
       if (this.spans.has(runId)) return;
       const eventId = this.getEventId(runId, parentRunId);
       const modelId = getName(llm, runName);
+      const prompt = prompts[0] ?? "";
       const span = this.traceShipper.startSpan({
         name: "llm",
         parent: this.getParent(parentRunId),
         eventId,
+        // `ai.generateText` classifies the span as an LLM generation at ingest
+        // (a bare `llm`/`chat` operationId maps to INTERNAL and is skipped by
+        // the rich-interaction extractor). `ai.prompt.messages` carries the
+        // per-step trajectory so replay can see the history each step ran on.
+        // A batch is a list of independent prompts; the span describes the
+        // first one, whose response `handleLLMEnd` reports (`generations[0][0]`).
         attributes: [
           attrString("ai.model.provider", modelId),
-          attrString("ai.operationId", "llm")
+          attrString("ai.operationId", "ai.generateText"),
+          ...promptAttributes(capturePrompt(prompt, this.spanMaxChars)),
+          this.promptToolsAttribute(extraParams)
         ]
       });
       this.spans.set(runId, span);
@@ -2392,36 +3034,44 @@ var RaindropDeepAgentsHandler = class extends import_base.BaseCallbackHandler {
         userId: this.userId,
         convoId: this.convoId,
         eventName: this.eventName,
-        input: truncate(prompts.join("\n"), CHAIN_TEXT_MAX_LEN),
+        input: capText2(prompt, this.eventMaxChars),
         properties: buildProperties(tags, metadata),
         isPending: true
       });
     } catch {
     }
   }
-  async handleChatModelStart(llm, messages, runId, parentRunId, _extraParams, tags, metadata, runName) {
+  async handleChatModelStart(llm, messages, runId, parentRunId, extraParams, tags, metadata, runName) {
     try {
       if (this.spans.has(runId)) return;
       const eventId = this.getEventId(runId, parentRunId);
       const modelId = getName(llm, runName);
+      const conversation = messages[0] ?? [];
       const span = this.traceShipper.startSpan({
         name: "llm",
         parent: this.getParent(parentRunId),
         eventId,
+        // See handleLLMStart: the full history (historical tool calls and
+        // their results included) goes on the span; the event `input` below
+        // stays the latest human message. LangChain batches are a list of
+        // independent conversations; the span describes the first one, the
+        // same member `handleLLMEnd` reports the response of
+        // (`generations[0][0]`), so history and response stay paired.
         attributes: [
           attrString("ai.model.provider", modelId),
-          attrString("ai.operationId", "chat")
+          attrString("ai.operationId", "ai.generateText"),
+          ...promptAttributes(captureConversation(conversation, this.spanMaxChars)),
+          this.promptToolsAttribute(extraParams)
         ]
       });
       this.spans.set(runId, span);
-      const allMessages = messages.flat();
-      const userMessages = allMessages.filter((m) => {
+      const userMessages = conversation.filter((m) => {
         const role = m._getType?.() ?? "unknown";
         return role === "human";
       });
-      const lastMsg = userMessages.length > 0 ? userMessages[userMessages.length - 1] : allMessages[allMessages.length - 1];
-      const extracted = lastMsg ? extractTextFromContent(lastMsg.content) : void 0;
-      const inputText = extracted !== void 0 ? truncate(extracted, CHAIN_TEXT_MAX_LEN) : void 0;
+      const lastMsg = userMessages.length > 0 ? userMessages[userMessages.length - 1] : conversation[conversation.length - 1];
+      const extracted = lastMsg ? extractTextFromContent(lastMsg.content, this.eventMaxChars) : void 0;
+      const inputText = capText2(extracted, this.eventMaxChars);
       await this.eventShipper.patch(eventId, {
         userId: this.userId,
         convoId: this.convoId,
@@ -2444,7 +3094,7 @@ var RaindropDeepAgentsHandler = class extends import_base.BaseCallbackHandler {
         await this.finalizeEventIfRoot(runId);
         return;
       }
-      const meta = extractLLMMetadata(output);
+      const meta = extractLLMMetadata(output, this.spanMaxChars);
       const {
         model,
         promptTokens,
@@ -2452,11 +3102,17 @@ var RaindropDeepAgentsHandler = class extends import_base.BaseCallbackHandler {
         cachedTokens,
         reasoningTokens,
         finishReason,
-        outputText
+        outputText,
+        toolCalls
       } = meta;
       this.traceShipper.endSpan(span, {
         attributes: [
           attrString("ai.response.model", model),
+          attrString("ai.response.text", capText2(outputText, this.spanMaxChars)),
+          // Tool calls requested by this step, with the ids the matching
+          // `ai.toolCall` spans and the next step's history carry.
+          attrString("ai.response.toolCalls", toolCalls?.json),
+          attrString("ai.response.toolCalls.truncated", toolCalls?.truncated ? "true" : void 0),
           attrInt("ai.usage.prompt_tokens", promptTokens),
           attrInt("ai.usage.completion_tokens", completionTokens),
           attrInt("ai.usage.cached_tokens", cachedTokens),
@@ -2468,9 +3124,8 @@ var RaindropDeepAgentsHandler = class extends import_base.BaseCallbackHandler {
       if (cachedTokens != null) properties["ai.usage.cached_tokens"] = cachedTokens;
       if (reasoningTokens != null) properties["ai.usage.thoughts_tokens"] = reasoningTokens;
       if (finishReason != null) properties["ai.finish_reason"] = finishReason;
-      const cappedOutput = outputText !== void 0 ? truncate(outputText, CHAIN_TEXT_MAX_LEN) : void 0;
       await this.finalizeEventIfRoot(runId, {
-        output: cappedOutput,
+        output: capText2(outputText, this.eventMaxChars),
         model,
         usage: { promptTokens, completionTokens },
         properties: Object.keys(properties).length > 0 ? properties : void 0
@@ -2566,14 +3221,16 @@ var RaindropDeepAgentsHandler = class extends import_base.BaseCallbackHandler {
     try {
       const eventId = this.getEventId(runId, parentRunId);
       const toolName = getName(tool, runName);
+      const toolCall = parseToolCallInput(input);
       const span = this.traceShipper.startSpan({
         name: "tool",
         parent: this.getParent(parentRunId),
         eventId,
         operationId: "ai.toolCall",
         attributes: [
+          attrString("ai.toolCall.id", toolCall.id),
           attrString("ai.toolCall.name", toolName),
-          attrString("tool.input", truncate(input, 4096))
+          attrString("ai.toolCall.args", capText2(toolCall.args, this.spanMaxChars))
         ]
       });
       this.spans.set(runId, span);
@@ -2588,9 +3245,14 @@ var RaindropDeepAgentsHandler = class extends import_base.BaseCallbackHandler {
     try {
       const span = this.spans.get(runId);
       if (span) {
-        const outputStr = typeof output === "string" ? output : safeStringify(output, 4096);
+        const { content, toolCallId } = unwrapToolOutput(output);
+        const result = typeof content === "string" ? capText2(content, this.spanMaxChars) : boundedStringify(content, this.spanMaxChars);
+        const hasId = span.attributes.some((attr) => attr?.key === "ai.toolCall.id");
         this.traceShipper.endSpan(span, {
-          attributes: [attrString("tool.output", truncate(outputStr, 4096))]
+          attributes: [
+            attrString("ai.toolCall.id", hasId ? void 0 : toolCallId),
+            attrString("ai.toolCall.result", result)
+          ]
         });
       }
       await this.finalizeEventIfRoot(runId);
@@ -2626,10 +3288,10 @@ var RaindropDeepAgentsHandler = class extends import_base.BaseCallbackHandler {
         operationId: "ai.toolCall",
         attributes: [
           attrString("ai.toolCall.name", action.tool),
-          attrString("agent.tool_input", truncate(
-            typeof action.toolInput === "string" ? action.toolInput : safeStringify(action.toolInput, 4096),
-            4096
-          ))
+          attrString(
+            "agent.tool_input",
+            typeof action.toolInput === "string" ? capText2(action.toolInput, this.spanMaxChars) : boundedStringify(action.toolInput, this.spanMaxChars)
+          )
         ]
       });
       this.spans.set(`${runId}:agent_action`, span);
@@ -2662,75 +3324,13 @@ function buildProperties(tags, metadata) {
   if (metadata) Object.assign(props, metadata);
   return props;
 }
-var TRUNCATION_MARKER2 = "...[truncated by raindrop]";
-var MAX_TEXT_FIELD_CHARS = 1e6;
-var MAX_BOUNDED_DEPTH = 12;
-function boundedClone2(value, budget, depth) {
-  if (budget.remaining <= 0) return TRUNCATION_MARKER2;
-  if (typeof value === "string") {
-    if (value.length > budget.remaining) {
-      const taken = value.slice(0, Math.max(0, budget.remaining)) + TRUNCATION_MARKER2;
-      budget.remaining = 0;
-      return taken;
-    }
-    budget.remaining -= Math.max(value.length, 1);
-    return value;
-  }
-  if (value === null || typeof value === "number" || typeof value === "boolean") {
-    budget.remaining -= 8;
-    return value;
-  }
-  if (typeof value !== "object") {
-    budget.remaining -= 8;
-    return value;
-  }
-  if (depth >= MAX_BOUNDED_DEPTH) {
-    budget.remaining -= 16;
-    return `<max depth: ${TRUNCATION_MARKER2}>`;
-  }
-  const withToJson = value;
-  if (typeof withToJson.toJSON === "function") {
-    try {
-      return boundedClone2(withToJson.toJSON(), budget, depth + 1);
-    } catch {
-    }
-  }
-  if (Array.isArray(value)) {
-    const out2 = [];
-    for (const item of value) {
-      if (budget.remaining <= 0) {
-        out2.push(TRUNCATION_MARKER2);
-        break;
-      }
-      out2.push(boundedClone2(item, budget, depth + 1));
-    }
-    return out2;
-  }
-  const out = {};
-  for (const key of Object.keys(value)) {
-    if (budget.remaining <= 0) {
-      out["..."] = TRUNCATION_MARKER2;
-      break;
-    }
-    budget.remaining -= Math.max(key.length, 1);
-    out[key] = boundedClone2(value[key], budget, depth + 1);
-  }
-  return out;
-}
-function safeStringify(value, limit = MAX_TEXT_FIELD_CHARS) {
-  try {
-    const pruned = boundedClone2(value, { remaining: limit + TRUNCATION_MARKER2.length + 256 }, 0);
-    return JSON.stringify(pruned) ?? "";
-  } catch {
-    const fallback = String(value);
-    return fallback.length > limit ? fallback.slice(0, limit) : fallback;
-  }
-}
-function truncate(str, maxLen) {
-  if (str.length <= maxLen) return str;
-  return str.slice(0, maxLen - 3) + "...";
+function promptAttributes(capture) {
+  return [
+    attrString("ai.prompt.messages", capture?.json),
+    attrString("ai.prompt.messages.truncated", capture?.truncated ? "true" : void 0)
+  ];
 }
-function extractLLMMetadata(output) {
+function extractLLMMetadata(output, limit) {
   const gen = output.generations?.[0]?.[0];
   const message = gen?.message;
   const responseMeta = message?.response_metadata;
@@ -2756,7 +3356,7 @@ function extractLLMMetadata(output) {
     outputDetails?.reasoning ?? usage?.reasoning_tokens ?? usage?.thoughts_tokens
   );
   const finishReason = generationInfo?.finish_reason ?? responseMeta?.finish_reason ?? responseMeta?.stop_reason;
-  const outputText = gen?.text ?? (typeof message?.content === "string" ? message.content : void 0) ?? (message?.content ? extractTextFromContent(message.content) : void 0);
+  const outputText = gen?.text ?? (typeof message?.content === "string" ? message.content : void 0) ?? (message?.content ? extractTextFromContent(message.content, limit) : void 0);
   return {
     model,
     promptTokens,
@@ -2764,7 +3364,8 @@ function extractLLMMetadata(output) {
     cachedTokens,
     reasoningTokens,
     finishReason,
-    outputText
+    outputText,
+    toolCalls: captureToolCalls(message, limit)
   };
 }
 function asNumber(val) {
@@ -2776,7 +3377,7 @@ function asNumber(val) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/deep-agents",
-  version: "0.1.2",
+  version: "0.1.4",
   description: "Raindrop integration for LangChain Deep Agents",
   main: "dist/index.js",
   module: "dist/index.mjs",
@@ -2849,6 +3450,8 @@ var libraryVersion = package_default.version;
 function createRaindropDeepAgents(opts) {
   const writeKey = opts.writeKey;
   const enabled = !!writeKey;
+  setMaxTextFieldChars(opts.maxTextFieldChars);
+  const maxChars = eventMaxTextFieldChars();
   if (!writeKey) {
     console.warn(
       "[raindrop-ai/deep-agents] writeKey not provided; telemetry shipping is disabled"
@@ -2864,7 +3467,8 @@ function createRaindropDeepAgents(opts) {
     sdkName: "deep-agents",
     libraryName,
     libraryVersion,
-    appGitContext
+    appGitContext,
+    maxTextFieldChars: maxChars
   });
   const traceShipper = new TraceShipper2({
     writeKey,
@@ -2875,7 +3479,8 @@ function createRaindropDeepAgents(opts) {
     sdkName: "deep-agents",
     serviceName: "raindrop.deep-agents",
     serviceVersion: libraryVersion,
-    appGitContext
+    appGitContext,
+    maxTextFieldChars: maxChars
   });
   const handler = new RaindropDeepAgentsHandler({
     eventShipper,
@@ -2884,7 +3489,10 @@ function createRaindropDeepAgents(opts) {
     convoId: opts.convoId,
     eventName: opts.eventName,
     eventId: opts.eventId,
-    traceChains: opts.traceChains
+    traceChains: opts.traceChains,
+    maxTextFieldChars: maxChars,
+    eventMaxTextFieldChars: maxChars,
+    tools: opts.tools
   });
   return {
     handler,
@@ -2932,6 +3540,7 @@ function createRaindropDeepAgents(opts) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  PROMPT_TOOLS_ATTRIBUTE,
   RaindropDeepAgentsHandler,
   createRaindropDeepAgents
 });