agentid-sdk 0.1.0

package/dist/langchain-BdIOZZVq.d.mts

@@ -0,0 +1,128 @@
+type CapabilityConfig = {
+    block_pii_leakage: boolean;
+    block_db_access: boolean;
+    block_code_execution: boolean;
+    block_toxicity: boolean;
+};
+
+interface GuardParams {
+    input: string;
+    system_id: string;
+    user_id?: string;
+}
+interface GuardResponse {
+    allowed: boolean;
+    reason?: string;
+    detected_pii?: boolean;
+}
+interface RequestOptions {
+    apiKey?: string;
+}
+interface LogParams {
+    event_id?: string;
+    system_id?: string;
+    input: string;
+    output: string;
+    model: string;
+    usage?: Record<string, number>;
+    tokens?: Record<string, number>;
+    latency?: number;
+    user_id?: string;
+    metadata?: Record<string, unknown>;
+    event_type?: "start" | "complete" | "error" | "human_override" | "security_alert" | "security_block" | "security_policy_violation";
+    severity?: "info" | "warning" | "error" | "high";
+    timestamp?: string;
+}
+type AgentIDConfig = {
+    apiKey: string;
+    baseUrl?: string;
+    piiMasking?: boolean;
+    checkInjection?: boolean;
+    aiScanEnabled?: boolean;
+    storePii?: boolean;
+};
+
+type PreparedInput = {
+    sanitizedInput: string;
+    capabilityConfig: CapabilityConfig;
+};
+declare class AgentID {
+    private baseUrl;
+    private apiKey;
+    private piiMasking;
+    private checkInjection;
+    private aiScanEnabled;
+    private storePii;
+    private pii;
+    private localEnforcer;
+    private injectionScanner;
+    constructor(config: AgentIDConfig);
+    private resolveApiKey;
+    getCapabilityConfig(force?: boolean, options?: RequestOptions): Promise<CapabilityConfig>;
+    private getCachedCapabilityConfig;
+    prepareInputForDispatch(params: {
+        input: string;
+        systemId: string;
+        stream: boolean;
+        skipInjectionScan?: boolean;
+    }, options?: RequestOptions): Promise<PreparedInput>;
+    scanPromptInjection(input: string, options?: RequestOptions): Promise<void>;
+    private withMaskedOpenAIRequest;
+    private logSecurityPolicyViolation;
+    /**
+     * GUARD: Checks limits, PII, and security before execution.
+     * FAIL-CLOSED: Returns allowed=false if the API fails.
+     */
+    guard(params: GuardParams, options?: RequestOptions): Promise<GuardResponse>;
+    /**
+     * LOG: Sends telemetry after execution.
+     * Non-blocking / Fire-and-forget.
+     */
+    log(params: LogParams, options?: RequestOptions): void;
+    /**
+     * Analytics alias for telemetry logging.
+     */
+    analytics(params: LogParams, options?: RequestOptions): void;
+    /**
+     * Trace alias for telemetry logging.
+     */
+    trace(params: LogParams, options?: RequestOptions): void;
+    /**
+     * Wrap an OpenAI client once; AgentID will automatically:
+     * - run guard() before chat.completions.create
+     * - measure latency
+     * - fire-and-forget ingest logging
+     */
+    wrapOpenAI<T>(openai: T, options: {
+        system_id: string;
+        apiKey?: string;
+        api_key?: string;
+        resolveApiKey?: (request: Record<string, unknown>) => string | undefined;
+    }): T;
+}
+
+/**
+ * LangChainJS callback handler (dependency-free shape).
+ *
+ * Usage (LangChain):
+ * callbacks: [new AgentIDCallbackHandler(agent, { system_id: "..." })]
+ */
+declare class AgentIDCallbackHandler {
+    private agent;
+    private systemId;
+    private apiKeyOverride?;
+    private runs;
+    constructor(agent: AgentID, options: {
+        system_id: string;
+        apiKey?: string;
+        api_key?: string;
+    });
+    private get requestOptions();
+    private preflight;
+    handleLLMStart(serialized: unknown, prompts: unknown, runId?: string, _parentRunId?: string, extraParams?: unknown): Promise<void>;
+    handleChatModelStart(serialized: unknown, messages: unknown, runId?: string, _parentRunId?: string, extraParams?: unknown): Promise<void>;
+    handleLLMEnd(output: unknown, runId?: string): Promise<void>;
+    handleLLMError(err: unknown, runId?: string): Promise<void>;
+}
+
+export { AgentID as A, type GuardParams as G, type LogParams as L, type PreparedInput as P, type RequestOptions as R, AgentIDCallbackHandler as a, type GuardResponse as b };

package/dist/langchain-BdIOZZVq.d.ts

@@ -0,0 +1,128 @@
+type CapabilityConfig = {
+    block_pii_leakage: boolean;
+    block_db_access: boolean;
+    block_code_execution: boolean;
+    block_toxicity: boolean;
+};
+
+interface GuardParams {
+    input: string;
+    system_id: string;
+    user_id?: string;
+}
+interface GuardResponse {
+    allowed: boolean;
+    reason?: string;
+    detected_pii?: boolean;
+}
+interface RequestOptions {
+    apiKey?: string;
+}
+interface LogParams {
+    event_id?: string;
+    system_id?: string;
+    input: string;
+    output: string;
+    model: string;
+    usage?: Record<string, number>;
+    tokens?: Record<string, number>;
+    latency?: number;
+    user_id?: string;
+    metadata?: Record<string, unknown>;
+    event_type?: "start" | "complete" | "error" | "human_override" | "security_alert" | "security_block" | "security_policy_violation";
+    severity?: "info" | "warning" | "error" | "high";
+    timestamp?: string;
+}
+type AgentIDConfig = {
+    apiKey: string;
+    baseUrl?: string;
+    piiMasking?: boolean;
+    checkInjection?: boolean;
+    aiScanEnabled?: boolean;
+    storePii?: boolean;
+};
+
+type PreparedInput = {
+    sanitizedInput: string;
+    capabilityConfig: CapabilityConfig;
+};
+declare class AgentID {
+    private baseUrl;
+    private apiKey;
+    private piiMasking;
+    private checkInjection;
+    private aiScanEnabled;
+    private storePii;
+    private pii;
+    private localEnforcer;
+    private injectionScanner;
+    constructor(config: AgentIDConfig);
+    private resolveApiKey;
+    getCapabilityConfig(force?: boolean, options?: RequestOptions): Promise<CapabilityConfig>;
+    private getCachedCapabilityConfig;
+    prepareInputForDispatch(params: {
+        input: string;
+        systemId: string;
+        stream: boolean;
+        skipInjectionScan?: boolean;
+    }, options?: RequestOptions): Promise<PreparedInput>;
+    scanPromptInjection(input: string, options?: RequestOptions): Promise<void>;
+    private withMaskedOpenAIRequest;
+    private logSecurityPolicyViolation;
+    /**
+     * GUARD: Checks limits, PII, and security before execution.
+     * FAIL-CLOSED: Returns allowed=false if the API fails.
+     */
+    guard(params: GuardParams, options?: RequestOptions): Promise<GuardResponse>;
+    /**
+     * LOG: Sends telemetry after execution.
+     * Non-blocking / Fire-and-forget.
+     */
+    log(params: LogParams, options?: RequestOptions): void;
+    /**
+     * Analytics alias for telemetry logging.
+     */
+    analytics(params: LogParams, options?: RequestOptions): void;
+    /**
+     * Trace alias for telemetry logging.
+     */
+    trace(params: LogParams, options?: RequestOptions): void;
+    /**
+     * Wrap an OpenAI client once; AgentID will automatically:
+     * - run guard() before chat.completions.create
+     * - measure latency
+     * - fire-and-forget ingest logging
+     */
+    wrapOpenAI<T>(openai: T, options: {
+        system_id: string;
+        apiKey?: string;
+        api_key?: string;
+        resolveApiKey?: (request: Record<string, unknown>) => string | undefined;
+    }): T;
+}
+
+/**
+ * LangChainJS callback handler (dependency-free shape).
+ *
+ * Usage (LangChain):
+ * callbacks: [new AgentIDCallbackHandler(agent, { system_id: "..." })]
+ */
+declare class AgentIDCallbackHandler {
+    private agent;
+    private systemId;
+    private apiKeyOverride?;
+    private runs;
+    constructor(agent: AgentID, options: {
+        system_id: string;
+        apiKey?: string;
+        api_key?: string;
+    });
+    private get requestOptions();
+    private preflight;
+    handleLLMStart(serialized: unknown, prompts: unknown, runId?: string, _parentRunId?: string, extraParams?: unknown): Promise<void>;
+    handleChatModelStart(serialized: unknown, messages: unknown, runId?: string, _parentRunId?: string, extraParams?: unknown): Promise<void>;
+    handleLLMEnd(output: unknown, runId?: string): Promise<void>;
+    handleLLMError(err: unknown, runId?: string): Promise<void>;
+}
+
+export { AgentID as A, type GuardParams as G, type LogParams as L, type PreparedInput as P, type RequestOptions as R, AgentIDCallbackHandler as a, type GuardResponse as b };

package/dist/langchain.d.mts

@@ -0,0 +1 @@
+export { a as AgentIDCallbackHandler } from './langchain-BdIOZZVq.mjs';

package/dist/langchain.d.ts

@@ -0,0 +1 @@
+export { a as AgentIDCallbackHandler } from './langchain-BdIOZZVq.js';

package/dist/langchain.js

@@ -0,0 +1,256 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/langchain.ts
+var langchain_exports = {};
+__export(langchain_exports, {
+  AgentIDCallbackHandler: () => AgentIDCallbackHandler
+});
+module.exports = __toCommonJS(langchain_exports);
+function safeString(val) {
+  return typeof val === "string" ? val : "";
+}
+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 = typed?.role ?? typed?.type;
+    if (role === "user" || role === "human") {
+      last = typed;
+    }
+  }
+  if (!last || typeof last !== "object") {
+    return "";
+  }
+  const typedLast = last;
+  return safeString(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 model = kw?.model ?? kw?.model_name ?? kw?.modelName;
+  if (typeof model === "string" && model) return model;
+  const ser = (serialized && typeof serialized === "object" ? serialized : null) ?? null;
+  const name = ser?.name ?? ser?.id;
+  if (typeof name === "string" && name) return name;
+  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;
+  return usage && typeof usage === "object" ? usage : void 0;
+}
+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 {
+  constructor(agent, options) {
+    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;
+  }
+  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 ?? "");
+    if (!input) {
+      throw new Error("AgentID: No prompt found. Security guard requires string input.");
+    }
+    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 verdict = await this.agent.guard({
+      input: sanitizedInput,
+      system_id: this.systemId
+    }, this.requestOptions);
+    if (!verdict.allowed) {
+      throw new Error(`AgentID: Security Blocked (${verdict.reason ?? "guard_denied"})`);
+    }
+    this.runs.set(id, {
+      input: sanitizedInput,
+      startedAtMs: Date.now(),
+      model: extractModel(serialized, extraParams)
+    });
+  }
+  async handleChatModelStart(serialized, messages, runId, _parentRunId, extraParams) {
+    const input = extractPromptFromMessages(messages);
+    const id = String(runId ?? "");
+    if (!input) {
+      throw new Error("AgentID: No user message found. Security guard requires string input.");
+    }
+    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 verdict = await this.agent.guard({
+      input: sanitizedInput,
+      system_id: this.systemId
+    }, this.requestOptions);
+    if (!verdict.allowed) {
+      throw new Error(`AgentID: Security Blocked (${verdict.reason ?? "guard_denied"})`);
+    }
+    this.runs.set(id, {
+      input: sanitizedInput,
+      startedAtMs: Date.now(),
+      model: extractModel(serialized, extraParams)
+    });
+  }
+  async handleLLMEnd(output, runId) {
+    const id = String(runId ?? "");
+    const state = this.runs.get(id);
+    if (!state) return;
+    this.runs.delete(id);
+    const latency = Date.now() - state.startedAtMs;
+    const outText = extractOutputText(output);
+    const usage = extractTokenUsage(output);
+    this.agent.log({
+      system_id: this.systemId,
+      input: state.input,
+      output: outText,
+      model: state.model ?? "unknown",
+      usage,
+      latency
+    }, this.requestOptions);
+  }
+  async handleLLMError(err, runId) {
+    const id = String(runId ?? "");
+    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 ?? "");
+    this.agent.log({
+      system_id: this.systemId,
+      input: state?.input ?? "",
+      output: "",
+      model: state?.model ?? "unknown",
+      event_type: "error",
+      severity: "error",
+      metadata: {
+        error_message: message
+      }
+    }, this.requestOptions);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentIDCallbackHandler
+});

package/dist/langchain.mjs

@@ -0,0 +1,6 @@
+import {
+  AgentIDCallbackHandler
+} from "./chunk-5VHWMLV2.mjs";
+export {
+  AgentIDCallbackHandler
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "agentid-sdk",
+  "version": "0.1.0",
+  "description": "AgentID JavaScript/TypeScript SDK for guard, ingest, tracing, and analytics.",
+  "license": "MIT",
+  "homepage": "https://agentid.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ondrejsukac-rgb/agentid.git",
+    "directory": "js-sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/ondrejsukac-rgb/agentid/issues"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./langchain": {
+      "types": "./dist/langchain.d.ts",
+      "import": "./dist/langchain.mjs",
+      "require": "./dist/langchain.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/langchain.ts --format esm,cjs --dts --clean",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "openai": "^4.0.0",
+    "langchain": "^0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "langchain": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.0.0"
+  }
+}