agentid-sdk 0.1.17 → 0.1.19

package/README.md

@@ -1,65 +1,197 @@
-# 🛡️ AgentID: Enterprise AI Governance & PII Shield
+# agentid-sdk (Node.js / TypeScript)
 
-AgentID je inteligentní brána (gateway) pro vaše LLM aplikace. Monitoruje náklady, filtruje PII (osobní údaje) v reálném čase a zajišťuje soulad s GDPR.
+[![npm version](https://img.shields.io/npm/v/agentid-sdk.svg)](https://www.npmjs.com/package/agentid-sdk)
+[![Node](https://img.shields.io/node/v/agentid-sdk.svg)](https://www.npmjs.com/package/agentid-sdk)
+[![Node >=18](https://img.shields.io/badge/node-%3E%3D18-339933.svg)](https://nodejs.org/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
-## 🚀 Rychlý start (60 sekund)
+## 1. Introduction
 
-### 1. Instalace
+`agentid-sdk` is the official Node.js/TypeScript SDK for AgentID, an AI security and compliance System of Record. It allows you to gate LLM traffic through guard checks, enforce policy before execution, and capture durable telemetry for audit and governance workflows.
 
-```bash
-# Pro Python projekty
-pip install agentid-sdk
+## 2. Installation
 
-# Pro JavaScript/TypeScript projekty
+```bash
 npm install agentid-sdk
 ```
 
-### 2. Integrace (Python)
+## 3. Prerequisites
+
+1. Create an account at `https://app.getagentid.com`.
+2. Create an AI system and copy:
+   - `AGENTID_API_KEY` (for example `sk_live_...`)
+   - `AGENTID_SYSTEM_ID` (UUID)
+3. If using OpenAI/LangChain, set:
+   - `OPENAI_API_KEY`
+
+```bash
+export AGENTID_API_KEY="sk_live_..."
+export AGENTID_SYSTEM_ID="00000000-0000-0000-0000-000000000000"
+export OPENAI_API_KEY="sk-proj-..."
+```
 
-Stačí zabalit vašeho stávajícího OpenAI klienta.
+## 4. Quickstart
 
-```python
-from openai import OpenAI
-from agentid import AgentID
+```ts
+import { AgentID } from "agentid-sdk";
 
-client = OpenAI(api_key="your_openai_key")
-agent = AgentID(api_key="ag_prod_...")
+const agent = new AgentID(); // auto-loads AGENTID_API_KEY
+const systemId = process.env.AGENTID_SYSTEM_ID!;
 
-# Automaticky filtruje PII a loguje metriky
-response = agent.wrap_openai(client, system_id="sys_...").chat.completions.create(
-    model="gpt-4",
-    messages=[{"role": "user", "content": "Můj email je jan.novak@firma.cz"}]
-)
+const verdict = await agent.guard({
+  system_id: systemId,
+  input: "Summarize this ticket in one sentence.",
+  model: "gpt-4o-mini",
+  user_id: "quickstart-user",
+});
+if (!verdict.allowed) throw new Error(`Blocked: ${verdict.reason}`);
+
+await agent.log({
+  system_id: systemId,
+  event_id: verdict.client_event_id,
+  model: "gpt-4o-mini",
+  input: "Summarize this ticket in one sentence.",
+  output: "Summary generated.",
+  metadata: { agent_role: "support-assistant" },
+});
 ```
 
-### 3. Integrace (Node.js)
+## 5. Core Integrations
+
+### OpenAI Wrapper
+
+```bash
+npm install agentid-sdk openai
+```
 
 ```ts
-import { AgentID } from "agentid-sdk";
 import OpenAI from "openai";
+import { AgentID } from "agentid-sdk";
 
-const openai = new OpenAI();
 const agent = new AgentID({
-  apiKey: "ag_prod_...",
-  strictMode: false, // default (fail-open on timeout/unreachable AgentID API)
-  guardTimeoutMs: 6000, // optional: timeout for AgentID /guard call in ms
-  // strictMode: true, // fail-closed for high-risk workloads
+  piiMasking: true,
+});
+
+const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY! });
+const secured = agent.wrapOpenAI(openai, {
+  system_id: process.env.AGENTID_SYSTEM_ID!,
+  user_id: "customer-123",
+});
+
+const response = await secured.chat.completions.create({
+  model: "gpt-4o-mini",
+  messages: [{ role: "user", content: "What is the capital of the Czech Republic?" }],
+});
+
+console.log(response.choices[0]?.message?.content ?? "");
+```
+
+### LangChain Integration
+
+```bash
+npm install agentid-sdk openai @langchain/core @langchain/openai
+```
+
+```ts
+import { AgentID } from "agentid-sdk";
+import { AgentIDCallbackHandler } from "agentid-sdk/langchain";
+import { ChatOpenAI } from "@langchain/openai";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { StringOutputParser } from "@langchain/core/output_parsers";
+
+const agent = new AgentID();
+const handler = new AgentIDCallbackHandler(agent, {
+  system_id: process.env.AGENTID_SYSTEM_ID!,
 });
 
-const proxiedOpenAI = agent.wrapOpenAI(openai, {
-  system_id: "sys_...",
-  user_id: "system-auto-summary", // optional service/user identity
+const prompt = ChatPromptTemplate.fromTemplate("Answer in one sentence: {question}");
+const model = new ChatOpenAI({
+  apiKey: process.env.OPENAI_API_KEY!,
+  model: "gpt-4o-mini",
 });
+const chain = prompt.pipe(model).pipe(new StringOutputParser());
+
+const result = await chain.invoke(
+  { question: "What is the capital of the Czech Republic?" },
+  { callbacks: [handler] }
+);
+console.log(result);
 ```
 
-## 🔒 Klíčové vlastnosti
+### Raw Ingest API (Telemetry Only)
+
+```ts
+import { AgentID } from "agentid-sdk";
+
+const agent = new AgentID();
+
+await agent.log({
+  system_id: process.env.AGENTID_SYSTEM_ID!,
+  event_type: "complete",
+  severity: "info",
+  model: "gpt-4o-mini",
+  input: "Raw telemetry prompt",
+  output: '{"ok": true}',
+  metadata: { agent_role: "batch-worker", channel: "manual_ingest" },
+});
+```
+
+## 6. Advanced Configuration
+
+### Custom identity / role metadata
+
+```ts
+await agent.guard({
+  system_id: process.env.AGENTID_SYSTEM_ID!,
+  input: "Process user request",
+  user_id: "service:billing-agent",
+  model: "gpt-4o-mini",
+});
+
+await agent.log({
+  system_id: process.env.AGENTID_SYSTEM_ID!,
+  model: "gpt-4o-mini",
+  input: "Process user request",
+  output: "Done",
+  metadata: { agent_role: "billing-agent", environment: "prod" },
+});
+```
+
+### Strict mode and timeout tuning
+
+```ts
+const agent = new AgentID({
+  strictMode: true,      // fail-closed on guard connectivity/timeouts
+  guardTimeoutMs: 10000, // default guard timeout is 10000ms
+});
+```
+
+### Error handling behavior
+
+- `guard()` returns a verdict (`allowed`, `reason`); handle deny paths explicitly.
+- `wrapOpenAI()` throws `Error("AgentID: Security Blocked (...)")` when blocked.
+- Default mode is fail-open for connectivity/timeouts (`timeout_fallback`, `guard_unreachable`, `system_failure_fail_open`).
+- If `strictMode` is not explicitly set in SDK code, runtime behavior follows the system configuration from AgentID (`strict_security_mode` / `failure_mode`).
+- Set `strictMode: true` to fail-closed (`network_error_strict_mode` / `server_error`) in high-sensitivity environments.
+- Ingest retries transient failures (5xx/429) and logs warnings if persistence fails.
+
+## 7. Security & Compliance
+
+- Optional local PII masking and local policy enforcement before model dispatch.
+- Prompt-injection scanning in the SDK request path.
+- Guard checks run pre-execution; ingest telemetry captures prompt/output lifecycle.
+- Safe for server and serverless runtimes (including async completion flows).
+- Supports compliance and forensics workflows with durable event records.
+
+## 8. Support
+
+- Dashboard: `https://app.getagentid.com`
+- Repository: `https://github.com/ondrejsukac-rgb/agentid/tree/main/js-sdk`
+- Issues: `https://github.com/ondrejsukac-rgb/agentid/issues`
 
-- PII Scrubbing: Automatická redakce e-mailů, rodných čísel a hesel před odesláním do cloudu.
-- Crypto-Shredding: Možnost nenávratně smazat citlivá data z logů na žádost uživatele (GDPR).
-- Fail-Safe architektura: Inteligentní přepínání mezi bezpečností a dostupností (Fail-Open/Closed).
-- Strict mode: při timeoutu Guard API můžeš vynutit fail-closed (`strictMode: true`).
+## 9. Publishing Notes (NPM)
 
-## Guard transformed input
+NPM automatically renders `README.md` from the package root during `npm publish`.
 
-If `/guard` returns `transformed_input`, the OpenAI and LangChain wrappers automatically
-forward that transformed value to the downstream LLM call.
+- File location: next to `package.json` in `js-sdk/`.
+- No additional NPM config is required for README rendering.

package/dist/chunk-6YR4ECGB.mjs

@@ -0,0 +1,424 @@
+// src/langchain.ts
+import { BaseCallbackHandler } from "@langchain/core/callbacks/base";
+function safeString(val) {
+  return typeof val === "string" ? val : "";
+}
+function callbackDebugEnabled() {
+  try {
+    return typeof process !== "undefined" && process?.env?.AGENTID_DEBUG_CALLBACK === "1";
+  } catch {
+    return false;
+  }
+}
+function logCallbackDebug(message, details) {
+  if (!callbackDebugEnabled()) return;
+  if (details) {
+    console.log(`[AgentID][LC] ${message}`, details);
+    return;
+  }
+  console.log(`[AgentID][LC] ${message}`);
+}
+function extractTextFromContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    const parts = content.map((item) => {
+      if (typeof item === "string") return item;
+      if (!item || typeof item !== "object") return "";
+      const record = item;
+      if (typeof record.text === "string") return record.text;
+      if (typeof record.content === "string") return record.content;
+      return "";
+    }).filter((part) => part.length > 0);
+    return parts.join("\n");
+  }
+  if (content && typeof content === "object") {
+    const record = content;
+    if (typeof record.text === "string") return record.text;
+    if (typeof record.content === "string") return record.content;
+  }
+  return "";
+}
+function getMessageRole(msg) {
+  if (!msg || typeof msg !== "object") return null;
+  const typed = msg;
+  if (typeof typed.role === "string") return typed.role;
+  if (typeof typed.type === "string") return typed.type;
+  if (typeof typed._getType === "function") {
+    try {
+      const role = typed._getType();
+      if (typeof role === "string") return role;
+    } catch {
+    }
+  }
+  if (typeof typed.getType === "function") {
+    try {
+      const role = typed.getType();
+      if (typeof role === "string") return role;
+    } catch {
+    }
+  }
+  return null;
+}
+function extractPromptFromPrompts(prompts) {
+  if (Array.isArray(prompts) && prompts.length > 0) {
+    return safeString(prompts[prompts.length - 1]);
+  }
+  return "";
+}
+function extractPromptFromMessages(messages) {
+  const flat = [];
+  if (Array.isArray(messages)) {
+    for (const item of messages) {
+      if (Array.isArray(item)) {
+        flat.push(...item);
+      } else {
+        flat.push(item);
+      }
+    }
+  }
+  let last = null;
+  for (const msg of flat) {
+    const typed = msg;
+    const role = getMessageRole(msg);
+    if (role === "user" || role === "human") {
+      last = typed;
+    }
+  }
+  if (!last || typeof last !== "object") {
+    return "";
+  }
+  const typedLast = last;
+  return extractTextFromContent(typedLast.content ?? typedLast.text);
+}
+function setPromptInPrompts(prompts, sanitizedInput) {
+  if (!Array.isArray(prompts) || prompts.length === 0) {
+    return false;
+  }
+  prompts[prompts.length - 1] = sanitizedInput;
+  return true;
+}
+function setPromptInMessages(messages, sanitizedInput) {
+  if (!Array.isArray(messages)) {
+    return false;
+  }
+  const flat = [];
+  for (const item of messages) {
+    if (Array.isArray(item)) {
+      flat.push(...item);
+    } else {
+      flat.push(item);
+    }
+  }
+  for (let i = flat.length - 1; i >= 0; i -= 1) {
+    const candidate = flat[i];
+    if (!candidate || typeof candidate !== "object") {
+      continue;
+    }
+    const typed = candidate;
+    const role = typed.role ?? typed.type;
+    if (role !== "user" && role !== "human") {
+      continue;
+    }
+    if ("content" in typed) {
+      typed.content = sanitizedInput;
+      return true;
+    }
+    if ("text" in typed) {
+      typed.text = sanitizedInput;
+      return true;
+    }
+    typed.content = sanitizedInput;
+    return true;
+  }
+  return false;
+}
+function extractModel(serialized, kwargs) {
+  const kw = (kwargs && typeof kwargs === "object" ? kwargs : null) ?? null;
+  const directModel = kw?.model ?? kw?.model_name ?? kw?.modelName;
+  if (typeof directModel === "string" && directModel) return directModel;
+  const invocationModel = kw?.invocation_params?.model ?? kw?.invocation_params?.model_name ?? kw?.invocation_params?.modelName;
+  if (typeof invocationModel === "string" && invocationModel) return invocationModel;
+  const nestedModel = kw?.options?.model ?? kw?.options?.model_name ?? kw?.options?.modelName ?? kw?.kwargs?.model ?? kw?.kwargs?.model_name ?? kw?.kwargs?.modelName;
+  if (typeof nestedModel === "string" && nestedModel) return nestedModel;
+  const ser = (serialized && typeof serialized === "object" ? serialized : null) ?? null;
+  const serKw = (ser?.kwargs && typeof ser.kwargs === "object" ? ser.kwargs : null) ?? null;
+  const serModel = serKw?.model ?? serKw?.model_name ?? serKw?.modelName;
+  if (typeof serModel === "string" && serModel) return serModel;
+  const name = ser?.name ?? ser?.id;
+  if (typeof name === "string" && name) return name;
+  return void 0;
+}
+function extractModelFromOutput(output) {
+  const llmOutput = output?.llmOutput ?? output?.llm_output;
+  const llmModel = llmOutput?.model ?? llmOutput?.model_name ?? llmOutput?.modelName;
+  if (typeof llmModel === "string" && llmModel) return llmModel;
+  const first = output?.generations?.[0]?.[0];
+  const responseMeta = first?.message?.response_metadata ?? first?.message?.responseMetadata;
+  const responseModel = responseMeta?.model_name ?? responseMeta?.model ?? responseMeta?.modelName;
+  if (typeof responseModel === "string" && responseModel) return responseModel;
+  const generationInfo = first?.generation_info ?? first?.generationInfo;
+  const genModel = generationInfo?.model_name ?? generationInfo?.model ?? generationInfo?.modelName;
+  if (typeof genModel === "string" && genModel) return genModel;
+  return void 0;
+}
+function extractOutputText(output) {
+  const gens = output?.generations;
+  const first = gens?.[0]?.[0];
+  const text = first?.text ?? first?.message?.content;
+  return typeof text === "string" ? text : "";
+}
+function extractTokenUsage(output) {
+  const llmOutput = output?.llmOutput ?? output?.llm_output;
+  const usage = llmOutput?.tokenUsage ?? llmOutput?.token_usage ?? llmOutput?.usage ?? void 0;
+  if (usage && typeof usage === "object") {
+    return usage;
+  }
+  const first = output?.generations?.[0]?.[0];
+  const usageMetadata = first?.message?.usage_metadata;
+  if (usageMetadata && typeof usageMetadata === "object") {
+    return usageMetadata;
+  }
+  const responseTokenUsage = first?.message?.response_metadata?.token_usage ?? first?.message?.response_metadata?.tokenUsage ?? void 0;
+  if (responseTokenUsage && typeof responseTokenUsage === "object") {
+    return responseTokenUsage;
+  }
+  const generationTokenUsage = first?.generation_info?.token_usage ?? first?.generation_info?.tokenUsage ?? void 0;
+  if (generationTokenUsage && typeof generationTokenUsage === "object") {
+    return generationTokenUsage;
+  }
+  return void 0;
+}
+function isUuidLike(value) {
+  return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value.trim());
+}
+function createClientEventId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const segment = () => Math.floor((1 + Math.random()) * 65536).toString(16).slice(1);
+  return `${segment()}${segment()}-${segment()}-4${segment().slice(1)}-a${segment().slice(1)}-${segment()}${segment()}${segment()}`;
+}
+function readBooleanField(value) {
+  return typeof value === "boolean" ? value : null;
+}
+function extractStreamFlag(serialized, extraParams) {
+  const extras = extraParams && typeof extraParams === "object" ? extraParams : null;
+  const direct = readBooleanField(extras?.stream) ?? readBooleanField(extras?.streaming);
+  if (direct !== null) {
+    return direct;
+  }
+  const invocation = extras?.invocation_params && typeof extras.invocation_params === "object" ? extras.invocation_params : null;
+  const invocationStream = readBooleanField(invocation?.stream) ?? readBooleanField(invocation?.streaming);
+  if (invocationStream !== null) {
+    return invocationStream;
+  }
+  const serializedRecord = serialized && typeof serialized === "object" ? serialized : null;
+  const kwargs = serializedRecord?.kwargs && typeof serializedRecord.kwargs === "object" ? serializedRecord.kwargs : null;
+  return readBooleanField(kwargs?.stream) ?? readBooleanField(kwargs?.streaming) ?? false;
+}
+var AgentIDCallbackHandler = class extends BaseCallbackHandler {
+  constructor(agent, options) {
+    super();
+    this.name = "agentid_callback_handler";
+    this.runs = /* @__PURE__ */ new Map();
+    this.agent = agent;
+    this.systemId = options.system_id;
+    this.apiKeyOverride = options.apiKey?.trim() || options.api_key?.trim() || void 0;
+  }
+  get requestOptions() {
+    return this.apiKeyOverride ? { apiKey: this.apiKeyOverride } : void 0;
+  }
+  getLangchainCapabilities() {
+    const piiMaskingEnabled = Boolean(
+      this.agent.piiMasking
+    );
+    return {
+      capabilities: {
+        has_feedback_handler: true,
+        pii_masking_enabled: piiMaskingEnabled,
+        framework: "langchain"
+      }
+    };
+  }
+  async preflight(input, stream) {
+    await this.agent.scanPromptInjection(input, this.requestOptions);
+    const prepared = await this.agent.prepareInputForDispatch({
+      input,
+      systemId: this.systemId,
+      stream,
+      skipInjectionScan: true
+    }, this.requestOptions);
+    return prepared.sanitizedInput;
+  }
+  async handleLLMStart(serialized, prompts, runId, _parentRunId, extraParams) {
+    const input = extractPromptFromPrompts(prompts);
+    const id = String(runId ?? "");
+    logCallbackDebug("handleLLMStart", { runId: id, hasInput: input.length > 0 });
+    if (!input) {
+      return;
+    }
+    const stream = extractStreamFlag(serialized, extraParams);
+    const sanitizedInput = await this.preflight(input, stream);
+    if (sanitizedInput !== input) {
+      const mutated = setPromptInPrompts(prompts, sanitizedInput);
+      if (!mutated) {
+        throw new Error(
+          "AgentID: Strict PII mode requires mutable LangChain prompt payload."
+        );
+      }
+    }
+    const requestedClientEventId = isUuidLike(id) ? id.trim() : createClientEventId();
+    const modelName = extractModel(serialized, extraParams);
+    const verdict = await this.agent.guard({
+      input: sanitizedInput,
+      system_id: this.systemId,
+      model: modelName,
+      client_event_id: requestedClientEventId,
+      client_capabilities: this.getLangchainCapabilities()
+    }, this.requestOptions);
+    if (!verdict.allowed) {
+      throw new Error(`AgentID: Security Blocked (${verdict.reason ?? "guard_denied"})`);
+    }
+    const canonicalClientEventId = isUuidLike(verdict.client_event_id) ? verdict.client_event_id.trim() : requestedClientEventId;
+    const guardEventId = typeof verdict.guard_event_id === "string" && verdict.guard_event_id.length > 0 ? verdict.guard_event_id : void 0;
+    let transformedInput = typeof verdict.transformed_input === "string" && verdict.transformed_input.length > 0 ? verdict.transformed_input : sanitizedInput;
+    if (transformedInput !== sanitizedInput) {
+      const mutated = setPromptInPrompts(prompts, transformedInput);
+      if (!mutated) {
+        transformedInput = sanitizedInput;
+      }
+    }
+    this.runs.set(id, {
+      input: transformedInput,
+      startedAtMs: Date.now(),
+      model: modelName,
+      clientEventId: canonicalClientEventId,
+      guardEventId
+    });
+    logCallbackDebug("handleLLMStart state_set", {
+      runId: id,
+      clientEventId: canonicalClientEventId,
+      guardEventId: guardEventId ?? null
+    });
+  }
+  async handleChatModelStart(serialized, messages, runId, _parentRunId, extraParams) {
+    const input = extractPromptFromMessages(messages);
+    const id = String(runId ?? "");
+    logCallbackDebug("handleChatModelStart", { runId: id, hasInput: input.length > 0 });
+    if (!input) {
+      return;
+    }
+    const stream = extractStreamFlag(serialized, extraParams);
+    const sanitizedInput = await this.preflight(input, stream);
+    if (sanitizedInput !== input) {
+      const mutated = setPromptInMessages(messages, sanitizedInput);
+      if (!mutated) {
+        throw new Error(
+          "AgentID: Strict PII mode requires mutable LangChain message payload."
+        );
+      }
+    }
+    const requestedClientEventId = isUuidLike(id) ? id.trim() : createClientEventId();
+    const modelName = extractModel(serialized, extraParams);
+    const verdict = await this.agent.guard({
+      input: sanitizedInput,
+      system_id: this.systemId,
+      model: modelName,
+      client_event_id: requestedClientEventId,
+      client_capabilities: this.getLangchainCapabilities()
+    }, this.requestOptions);
+    if (!verdict.allowed) {
+      throw new Error(`AgentID: Security Blocked (${verdict.reason ?? "guard_denied"})`);
+    }
+    const canonicalClientEventId = isUuidLike(verdict.client_event_id) ? verdict.client_event_id.trim() : requestedClientEventId;
+    const guardEventId = typeof verdict.guard_event_id === "string" && verdict.guard_event_id.length > 0 ? verdict.guard_event_id : void 0;
+    let transformedInput = typeof verdict.transformed_input === "string" && verdict.transformed_input.length > 0 ? verdict.transformed_input : sanitizedInput;
+    if (transformedInput !== sanitizedInput) {
+      const mutated = setPromptInMessages(messages, transformedInput);
+      if (!mutated) {
+        transformedInput = sanitizedInput;
+      }
+    }
+    this.runs.set(id, {
+      input: transformedInput,
+      startedAtMs: Date.now(),
+      model: modelName,
+      clientEventId: canonicalClientEventId,
+      guardEventId
+    });
+    logCallbackDebug("handleChatModelStart state_set", {
+      runId: id,
+      clientEventId: canonicalClientEventId,
+      guardEventId: guardEventId ?? null
+    });
+  }
+  async handleLLMEnd(output, runId) {
+    const id = String(runId ?? "");
+    logCallbackDebug("handleLLMEnd", { runId: id });
+    const state = this.runs.get(id);
+    if (!state) {
+      logCallbackDebug("handleLLMEnd missing_state", { runId: id });
+      return;
+    }
+    this.runs.delete(id);
+    const latency = Date.now() - state.startedAtMs;
+    const outText = extractOutputText(output);
+    const usage = extractTokenUsage(output);
+    const metadata = {};
+    if (state.clientEventId) {
+      metadata.client_event_id = state.clientEventId;
+    }
+    if (state.guardEventId) {
+      metadata.guard_event_id = state.guardEventId;
+    }
+    const resolvedModel = state.model ?? extractModelFromOutput(output) ?? "unknown";
+    await this.agent.log({
+      system_id: this.systemId,
+      input: state.input,
+      output: outText,
+      event_id: state.clientEventId,
+      model: resolvedModel,
+      usage,
+      latency,
+      metadata: Object.keys(metadata).length > 0 ? metadata : void 0,
+      client_capabilities: this.getLangchainCapabilities()
+    }, this.requestOptions);
+    logCallbackDebug("handleLLMEnd logged", {
+      runId: id,
+      clientEventId: state.clientEventId ?? null
+    });
+  }
+  async handleLLMError(err, runId) {
+    const id = String(runId ?? "");
+    logCallbackDebug("handleLLMError", { runId: id });
+    const state = this.runs.get(id);
+    if (state) this.runs.delete(id);
+    const message = err && typeof err === "object" && "message" in err ? String(err.message) : String(err ?? "");
+    const metadata = {
+      error_message: message
+    };
+    if (state?.clientEventId) {
+      metadata.client_event_id = state.clientEventId;
+    }
+    if (state?.guardEventId) {
+      metadata.guard_event_id = state.guardEventId;
+    }
+    await this.agent.log({
+      system_id: this.systemId,
+      input: state?.input ?? "",
+      output: "",
+      event_id: state?.clientEventId,
+      model: state?.model ?? "unknown",
+      event_type: "error",
+      severity: "error",
+      metadata,
+      client_capabilities: this.getLangchainCapabilities()
+    }, this.requestOptions);
+  }
+};
+
+export {
+  AgentIDCallbackHandler
+};

package/dist/index.d.mts

@@ -1,4 +1,5 @@
-export { A as AgentID, a as AgentIDCallbackHandler, G as GuardParams, b as GuardResponse, L as LogParams, P as PreparedInput, R as RequestOptions } from './langchain-CWHTxef0.mjs';
+export { A as AgentID, a as AgentIDCallbackHandler, G as GuardParams, b as GuardResponse, L as LogParams, P as PreparedInput, R as RequestOptions } from './langchain-DJDqqpbT.mjs';
+import '@langchain/core/callbacks/base';
 
 type PIIMapping = Record<string, string>;
 declare class PIIManager {

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export { A as AgentID, a as AgentIDCallbackHandler, G as GuardParams, b as GuardResponse, L as LogParams, P as PreparedInput, R as RequestOptions } from './langchain-CWHTxef0.js';
+export { A as AgentID, a as AgentIDCallbackHandler, G as GuardParams, b as GuardResponse, L as LogParams, P as PreparedInput, R as RequestOptions } from './langchain-DJDqqpbT.js';
+import '@langchain/core/callbacks/base';
 
 type PIIMapping = Record<string, string>;
 declare class PIIManager {