risicare 0.4.0 → 0.4.2

package/dist/frameworks/langgraph.cjs

@@ -3,9 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -20,34 +17,6 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/globals.ts
-function getTracer() {
-  return G[PREFIX + "tracer"];
-}
-function getContextStorage() {
-  if (!G[PREFIX + "ctx"]) {
-    G[PREFIX + "ctx"] = new import_node_async_hooks.AsyncLocalStorage();
-  }
-  return G[PREFIX + "ctx"];
-}
-var import_node_async_hooks, G, PREFIX;
-var init_globals = __esm({
-  "src/globals.ts"() {
-    "use strict";
-    import_node_async_hooks = require("async_hooks");
-    G = globalThis;
-    PREFIX = "__risicare_";
-  }
-});
-
-// src/utils/log.ts
-var init_log = __esm({
-  "src/utils/log.ts"() {
-    "use strict";
-    init_globals();
-  }
-});
-
 // src/frameworks/langgraph.ts
 var langgraph_exports = {};
 __export(langgraph_exports, {
@@ -128,8 +97,24 @@ var NOOP_SPAN = Object.freeze({
   }
 });
 
+// src/globals.ts
+var import_node_async_hooks = require("async_hooks");
+var G = globalThis;
+var PREFIX = "__risicare_";
+function getTracer() {
+  return G[PREFIX + "tracer"];
+}
+function getContextStorage() {
+  if (!G[PREFIX + "ctx"]) {
+    G[PREFIX + "ctx"] = new import_node_async_hooks.AsyncLocalStorage();
+  }
+  return G[PREFIX + "ctx"];
+}
+function getDebug() {
+  return G[PREFIX + "debug"] ?? false;
+}
+
 // src/context/storage.ts
-init_globals();
 function storage() {
   return getContextStorage();
 }
@@ -142,15 +127,18 @@ function runWithContext(overrides, fn) {
   return storage().run(merged, fn);
 }
 
-// src/exporters/batch.ts
-init_log();
+// src/utils/log.ts
+function debug(msg) {
+  if (getDebug()) {
+    process.stderr.write(`[risicare] ${msg}
+`);
+  }
+}
 
-// src/exporters/http.ts
-init_log();
+// src/runtime/applier.ts
+var import_node_crypto2 = require("crypto");
 
 // src/client.ts
-init_log();
-init_globals();
 function getTracer2() {
   return getTracer();
 }
@@ -162,9 +150,62 @@ function suppressProviderInstrumentation(fn) {
 }
 
 // src/frameworks/langchain.ts
-var RisicareCallbackHandler = class {
+var import_meta = {};
+function resolveBaseCallbackHandler() {
+  try {
+    const { createRequire } = require("module");
+    const req = createRequire(import_meta.url);
+    const mod = req("@langchain/core/callbacks/base");
+    if (mod?.BaseCallbackHandler) {
+      return mod.BaseCallbackHandler;
+    }
+  } catch {
+  }
+  try {
+    const mod = require("@langchain/core/callbacks/base");
+    if (mod?.BaseCallbackHandler) {
+      return mod.BaseCallbackHandler;
+    }
+  } catch {
+    debug("RisicareCallbackHandler: @langchain/core not installed; handler will not satisfy LangChain v0.2+ instanceof check");
+  }
+  return Object;
+}
+var _BaseCallbackHandler = resolveBaseCallbackHandler();
+var RisicareCallbackHandler = class _RisicareCallbackHandler extends _BaseCallbackHandler {
+  // PR-4+5 review B1: duck-type markers that LangChain v0.3's
+  // `isBaseCallbackHandler(x)` checks. This is the ONLY reliable way to be
+  // recognised across the CJS↔ESM identity split — `instanceof` cannot work
+  // when our `createRequire`-loaded BaseCallbackHandler is a different
+  // class object from the customer's ESM-imported BaseCallbackHandler.
+  // Keep these as instance properties (not prototype) so they survive any
+  // Object-fallback path when @langchain/core is absent.
   name = "RisicareCallbackHandler";
+  awaitHandlers = true;
+  ignoreLLM = false;
+  ignoreChain = false;
+  ignoreAgent = false;
+  ignoreRetriever = false;
+  ignoreCustomEvent = false;
+  raiseError = false;
+  lc_serializable = false;
+  lc_kwargs = {};
   _spans = /* @__PURE__ */ new Map();
+  constructor() {
+    super();
+  }
+  /**
+   * Required by LangChain's `isBaseCallbackHandler(x)` duck-type check
+   * (`typeof x.copy === 'function'`). When @langchain/core is installed
+   * BaseCallbackHandler's prototype provides its own `copy()`; this
+   * declaration overrides with a Risicare-aware copy that re-instantiates
+   * — sufficient for the handler-cloning paths LangChain uses internally
+   * (e.g., per-run isolation in concurrent chains). Spans map starts empty
+   * because a fresh handler should not share span state with its parent.
+   */
+  copy() {
+    return new _RisicareCallbackHandler();
+  }
   /**
    * Run a function with provider instrumentation suppressed.
    *
@@ -181,57 +222,75 @@ var RisicareCallbackHandler = class {
   withSuppression(fn) {
     return suppressProviderInstrumentation(fn);
   }
-  // ── Chain lifecycle ────────────────────────────────────────────────────────
-  handleChainStart(chain, _inputs, runId, parentRunId) {
+  // ── Internal helpers ──────────────────────────────────────────────────────
+  _startSpan(runId, parentRunId, name, kind, extraAttrs = {}) {
     const tracer = getTracer2();
     if (!tracer?.enabled) return;
     const parentEntry = parentRunId ? this._spans.get(parentRunId) : void 0;
     const span = tracer.createSpan({
-      name: chain.name || chain._type || "chain",
-      kind: "internal" /* INTERNAL */,
+      name,
+      kind,
       parentSpanId: parentEntry?.span.spanId,
       traceId: parentEntry?.span.traceId,
       attributes: {
-        "framework": "langchain",
+        framework: "langchain",
         "langchain.run_id": runId,
         ...parentRunId ? { "langchain.parent_run_id": parentRunId } : {},
-        ...chain._type ? { "langchain.chain_type": chain._type } : {}
+        ...extraAttrs
       }
     });
     this._spans.set(runId, { span, startTime: Date.now() });
   }
-  handleChainEnd(_outputs, runId) {
+  _endSpan(runId, extraAttrs = {}) {
     const entry = this._spans.get(runId);
     if (!entry) return;
+    for (const [k, v] of Object.entries(extraAttrs)) {
+      entry.span.setAttribute(k, v);
+    }
     entry.span.setAttribute("gen_ai.latency_ms", Date.now() - entry.startTime);
     entry.span.end();
     this._spans.delete(runId);
   }
-  handleChainError(error, runId) {
+  _errorSpan(runId, error) {
     const entry = this._spans.get(runId);
     if (!entry) return;
     entry.span.recordException(error);
     entry.span.end();
     this._spans.delete(runId);
   }
+  // ── Chain lifecycle ────────────────────────────────────────────────────────
+  handleChainStart(chain, _inputs, runId, parentRunId) {
+    this._startSpan(runId, parentRunId, chain.name || chain._type || "chain", "internal" /* INTERNAL */, {
+      ...chain._type ? { "langchain.chain_type": chain._type } : {}
+    });
+  }
+  handleChainEnd(_outputs, runId) {
+    this._endSpan(runId);
+  }
+  handleChainError(error, runId) {
+    this._errorSpan(runId, error);
+  }
   // ── LLM lifecycle ─────────────────────────────────────────────────────────
   handleLLMStart(llm, _prompts, runId, parentRunId) {
-    const tracer = getTracer2();
-    if (!tracer?.enabled) return;
-    const parentEntry = parentRunId ? this._spans.get(parentRunId) : void 0;
-    const span = tracer.createSpan({
-      name: llm.name || llm._type || "llm",
-      kind: "llm_call" /* LLM_CALL */,
-      parentSpanId: parentEntry?.span.spanId,
-      traceId: parentEntry?.span.traceId,
-      attributes: {
-        "framework": "langchain",
-        "langchain.run_id": runId,
-        "gen_ai.system": "langchain",
-        "gen_ai.prompt.count": _prompts.length
-      }
+    this._startSpan(runId, parentRunId, llm.name || llm._type || "llm", "llm_call" /* LLM_CALL */, {
+      "gen_ai.system": "langchain",
+      "gen_ai.prompt.count": _prompts.length
+    });
+  }
+  /**
+   * F-882: chat-model lifecycle — LangChain v0.2+ emits this for any
+   * ChatModel (which is EVERY production LLM today). Without this method,
+   * not a single `langchain` LLM span fires when used via LCEL.
+   *
+   * The messages payload is an array-of-arrays (one inner array per prompt);
+   * we just count rather than materialize content (PII boundary).
+   */
+  handleChatModelStart(llm, messages, runId, parentRunId) {
+    const messageCount = Array.isArray(messages) ? messages.reduce((sum, arr) => sum + (Array.isArray(arr) ? arr.length : 0), 0) : 0;
+    this._startSpan(runId, parentRunId, llm.name || llm._type || "chat_model", "llm_call" /* LLM_CALL */, {
+      "gen_ai.system": "langchain",
+      "gen_ai.message.count": messageCount
     });
-    this._spans.set(runId, { span, startTime: Date.now() });
   }
   handleLLMEnd(output, runId) {
     const entry = this._spans.get(runId);
@@ -253,73 +312,105 @@ var RisicareCallbackHandler = class {
     this._spans.delete(runId);
   }
   handleLLMError(error, runId) {
+    this._errorSpan(runId, error);
+  }
+  /**
+   * F-883: streaming-token event. We do NOT create a new span (the LLM span
+   * already exists from handleLLMStart/handleChatModelStart) — just count tokens
+   * on the existing span. This is a HIGH-FREQUENCY event; do the cheap work only.
+   */
+  handleLLMNewToken(_token, _idx, runId) {
     const entry = this._spans.get(runId);
     if (!entry) return;
-    entry.span.recordException(error);
-    entry.span.end();
-    this._spans.delete(runId);
+    const prior = entry.span.attributes?.["gen_ai.stream.token_count"] ?? 0;
+    entry.span.setAttribute("gen_ai.stream.token_count", prior + 1);
   }
   // ── Tool lifecycle ────────────────────────────────────────────────────────
   handleToolStart(tool, input, runId, parentRunId) {
+    this._startSpan(runId, parentRunId, tool.name || "tool", "tool_call" /* TOOL_CALL */, {
+      "tool.name": tool.name || "unknown",
+      "tool.input_length": input?.length ?? 0
+    });
+  }
+  handleToolEnd(output, runId) {
+    this._endSpan(runId, { "tool.output_length": output?.length ?? 0 });
+  }
+  handleToolError(error, runId) {
+    this._errorSpan(runId, error);
+  }
+  // ── Retriever lifecycle ───────────────────────────────────────────────────
+  handleRetrieverStart(retriever, _query, runId, parentRunId) {
+    this._startSpan(runId, parentRunId, retriever.name || "retriever", "retrieval" /* RETRIEVAL */);
+  }
+  handleRetrieverEnd(documents, runId) {
+    this._endSpan(runId, { "retriever.document_count": documents?.length ?? 0 });
+  }
+  handleRetrieverError(error, runId) {
+    this._errorSpan(runId, error);
+  }
+  // ── Agent lifecycle (F-882) ───────────────────────────────────────────────
+  /**
+   * Agent decided to take an action (call a tool). LangChain v0.2 agents emit
+   * this between LLM calls. Cheap span, no parent change.
+   */
+  handleAgentAction(action, runId, parentRunId) {
     const tracer = getTracer2();
     if (!tracer?.enabled) return;
     const parentEntry = parentRunId ? this._spans.get(parentRunId) : void 0;
     const span = tracer.createSpan({
-      name: tool.name || "tool",
-      kind: "tool_call" /* TOOL_CALL */,
+      name: `agent.action:${action.tool ?? "unknown"}`,
+      kind: "internal" /* INTERNAL */,
       parentSpanId: parentEntry?.span.spanId,
       traceId: parentEntry?.span.traceId,
       attributes: {
-        "framework": "langchain",
+        framework: "langchain",
         "langchain.run_id": runId,
-        "tool.name": tool.name || "unknown",
-        "tool.input_length": input?.length ?? 0
+        "agent.action.tool": action.tool ?? ""
       }
     });
-    this._spans.set(runId, { span, startTime: Date.now() });
+    span.end();
   }
-  handleToolEnd(output, runId) {
-    const entry = this._spans.get(runId);
-    if (!entry) return;
-    entry.span.setAttribute("tool.output_length", output?.length ?? 0);
-    entry.span.setAttribute("gen_ai.latency_ms", Date.now() - entry.startTime);
-    entry.span.end();
-    this._spans.delete(runId);
-  }
-  handleToolError(error, runId) {
-    const entry = this._spans.get(runId);
-    if (!entry) return;
-    entry.span.recordException(error);
-    entry.span.end();
-    this._spans.delete(runId);
-  }
-  // ── Retriever lifecycle ───────────────────────────────────────────────────
-  handleRetrieverStart(retriever, _query, runId, parentRunId) {
+  /**
+   * Agent finished (final answer produced). Mirror of handleAgentAction.
+   */
+  handleAgentEnd(action, runId, parentRunId) {
     const tracer = getTracer2();
     if (!tracer?.enabled) return;
     const parentEntry = parentRunId ? this._spans.get(parentRunId) : void 0;
     const span = tracer.createSpan({
-      name: retriever.name || "retriever",
-      kind: "retrieval" /* RETRIEVAL */,
+      name: "agent.end",
+      kind: "internal" /* INTERNAL */,
       parentSpanId: parentEntry?.span.spanId,
       traceId: parentEntry?.span.traceId,
       attributes: {
-        "framework": "langchain",
-        "langchain.run_id": runId
+        framework: "langchain",
+        "langchain.run_id": runId,
+        "agent.return_keys": action.returnValues ? Object.keys(action.returnValues).length : 0
       }
     });
-    this._spans.set(runId, { span, startTime: Date.now() });
+    span.end();
   }
-  handleRetrieverEnd(documents, runId) {
+  // ── Misc (F-882) ──────────────────────────────────────────────────────────
+  /**
+   * Free-text emission (logging-style). Used by ConversationalRetrievalChain
+   * and verbose prints. Adds an event to the current chain span if one exists.
+   */
+  handleText(text, runId, _parentRunId) {
     const entry = this._spans.get(runId);
     if (!entry) return;
-    entry.span.setAttribute(
-      "retriever.document_count",
-      documents?.length ?? 0
-    );
-    entry.span.setAttribute("gen_ai.latency_ms", Date.now() - entry.startTime);
-    entry.span.end();
-    this._spans.delete(runId);
+    entry.span.addEvent("langchain.text", {
+      "text.length": text?.length ?? 0
+    });
+  }
+  /**
+   * Custom event hook (introduced in @langchain/core 0.2.14). Customer code can
+   * `dispatchCustomEvent(name, payload)` from inside a runnable. We surface as
+   * a span event on the closest enclosing run so it shows up in the trace.
+   */
+  handleCustomEvent(eventName, _payload, runId, _tags, _metadata) {
+    const entry = this._spans.get(runId);
+    if (!entry) return;
+    entry.span.addEvent("langchain.custom_event", { name: eventName });
   }
 };