raindrop-ai 0.9.0 → 0.9.1

package/dist/tracing/index.js

@@ -101,7 +101,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;
@@ -1215,6 +1215,178 @@ var DEFAULT_REDACT_ATTRIBUTE_KEYS = [
   "ai.response.providerMetadata"
 ];
 var REDACT_JSON_ATTRIBUTE_KEYS = new Set(DEFAULT_REDACT_ATTRIBUTE_KEYS);
+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 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 });
+    }
+  });
+}
+function promptToolsFromTraceloopAttributes(attributes) {
+  var _a;
+  const byIndex = /* @__PURE__ */ new Map();
+  const prefix = "llm.request.functions.";
+  for (const [key, value] of Object.entries(attributes)) {
+    if (!key.startsWith(prefix)) continue;
+    const rest = key.slice(prefix.length);
+    const dot = rest.indexOf(".");
+    if (dot <= 0) continue;
+    const index = Number(rest.slice(0, dot));
+    if (!Number.isInteger(index) || index < 0) continue;
+    const field = rest.slice(dot + 1);
+    const entry = (_a = byIndex.get(index)) != null ? _a : {};
+    if (field === "name" && typeof value === "string") entry.name = value;
+    else if (field === "description" && typeof value === "string") entry.description = value;
+    else if (field === "parameters") entry.parameters = value;
+    byIndex.set(index, entry);
+  }
+  if (byIndex.size === 0) return void 0;
+  const tools = [];
+  for (const index of [...byIndex.keys()].sort((a, b) => a - b)) {
+    const entry = byIndex.get(index);
+    if (!(entry == null ? void 0 : entry.name)) continue;
+    let parameters = entry.parameters;
+    if (typeof parameters === "string") {
+      try {
+        parameters = JSON.parse(parameters);
+      } catch (e) {
+        parameters = void 0;
+      }
+    }
+    tools.push(functionTool(entry.name, entry.description, parameters, void 0));
+  }
+  return tools;
+}
 
 // ../core/dist/index.node.js
 var import_async_hooks = require("async_hooks");
@@ -1422,7 +1594,7 @@ function base64ToHex2(base64) {
 // package.json
 var package_default = {
   name: "raindrop-ai",
-  version: "0.9.0",
+  version: "0.9.1",
   main: "dist/index.js",
   module: "dist/index.mjs",
   types: "dist/index.d.ts",
@@ -2472,6 +2644,34 @@ function enrichStart(span) {
     }
   }
 }
+var PROMPT_TOOLS_OVERRIDE_MARKER = "raindrop.prompt_tools.override";
+var MODEL_SPAN_ATTRIBUTES = ["llm.request.type", "gen_ai.request.model", "ai.model.id"];
+function isModelSpan(attributes) {
+  return MODEL_SPAN_ATTRIBUTES.some((key) => attributes[key] !== void 0);
+}
+function applyPromptTools(span) {
+  var _a;
+  const attributes = span.attributes;
+  const marker = attributes[PROMPT_TOOLS_OVERRIDE_MARKER];
+  if (marker !== void 0) {
+    delete attributes[PROMPT_TOOLS_OVERRIDE_MARKER];
+    if (!isModelSpan(attributes) || !shouldSendTraceContent()) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(String(marker));
+    } catch (e) {
+      return;
+    }
+    const tools = (_a = normalizeToolDeclarations(parsed)) != null ? _a : [];
+    attributes[PROMPT_TOOLS_ATTRIBUTE] = promptToolsAttributeValue(tools);
+    return;
+  }
+  if (attributes[PROMPT_TOOLS_ATTRIBUTE] !== void 0) return;
+  if (!shouldSendTraceContent()) return;
+  const inferred = promptToolsFromTraceloopAttributes(attributes);
+  if (inferred === void 0) return;
+  attributes[PROMPT_TOOLS_ATTRIBUTE] = promptToolsAttributeValue(inferred);
+}
 function createSpanProcessor(options) {
   var _a, _b;
   const baseUrl = options.baseUrl || process.env.TRACELOOP_BASE_URL || "https://api.traceloop.com";
@@ -2497,6 +2697,7 @@ function createSpanProcessor(options) {
       if (allowed !== ALL_INSTRUMENTATION_LIBRARIES && ![...INSTRUMENTATION_LIBRARIES, ...allowed != null ? allowed : []].includes((_a2 = scopeName(span)) != null ? _a2 : "")) {
         return;
       }
+      applyPromptTools(span);
       outgoing = transformAiSdkSpan(span);
       if (outgoing !== span) copyReplayTraceDestination(span, outgoing);
     } catch (e) {
@@ -3612,6 +3813,22 @@ var LiveInteraction = class {
     if (this.toolEventsFrame) return;
     this.toolEventsFrame = bindSpanAttributes(attributes, this);
   }
+  /**
+   * Carry a `begin({ tools })` override to every span started inside this
+   * interaction. Frames stamp strings, so the normalized catalog rides as one
+   * JSON marker attribute; the span processor turns it into `ai.prompt.tools`
+   * on model spans (and drops it from every other span) when the span ends.
+   * Same lifetime as the tool-events frame: removed by `finish()`.
+   */
+  bindPromptToolsOverride(tools) {
+    var _a;
+    if (tools === void 0 || this.promptToolsFrame) return;
+    const declarations = (_a = normalizeToolDeclarations(tools)) != null ? _a : [];
+    this.promptToolsFrame = bindSpanAttributes(
+      { [PROMPT_TOOLS_OVERRIDE_MARKER]: JSON.stringify(declarations) },
+      this
+    );
+  }
   subagent(options) {
     return recordSubagentDispatch(this, options);
   }
@@ -3739,6 +3956,8 @@ var LiveInteraction = class {
     this.boundContext = void 0;
     unbindSpanAttributes(this.toolEventsFrame);
     this.toolEventsFrame = void 0;
+    unbindSpanAttributes(this.promptToolsFrame);
+    this.promptToolsFrame = void 0;
     if (!this.traceId) {
       this.resolveLiveTraceId();
     }
@@ -4764,8 +4983,9 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
     } catch (e) {
     }
   }) : void 0;
-  const beginInteraction = (traceContext) => {
+  const beginInteraction = (params) => {
     var _a2;
+    const { tools, ...traceContext } = params;
     if (!traceContext.eventId) {
       traceContext.eventId = crypto.randomUUID();
     }
@@ -4779,6 +4999,7 @@ var tracing = (analytics, apiUrl, writeKey, options, isDebug = false) => {
     );
     const bound = bindRoutingContext({ projectId, authHint, appGit: analytics.getAppGitSnapshot(traceContext.properties, traceContext.eventId) }, interaction);
     interaction.setBoundContext(bound);
+    interaction.bindPromptToolsOverride(tools);
     try {
       analytics._trackAiPartial({
         ...traceContext,

package/dist/tracing/index.mjs

@@ -1,6 +1,6 @@
 import {
   tracing
-} from "../chunk-RIL2CV7Q.mjs";
+} from "../chunk-WLBBPTI6.mjs";
 import "../chunk-UJCSKKID.mjs";
 
 // src/tracing/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "raindrop-ai",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -48,7 +48,7 @@
     "typescript": "^5.3.3",
     "vite": "^7.3.2",
     "vitest": "^4.0.10",
-    "@raindrop-ai/core": "0.3.0",
+    "@raindrop-ai/core": "0.3.1",
     "@raindrop-ai/redact-pii": "0.1.2",
     "@raindrop-ai/schemas": "0.1.0"
   },