@evalguard/langchain 1.0.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for describing the origin of the Work and
+      reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Support. While redistributing the Work or
+      Derivative Works thereof, You may choose to offer, and charge a
+      fee for, acceptance of support, warranty, indemnity, or other
+      liability obligations and/or rights consistent with this License.
+      However, in accepting such obligations, You may act only on Your
+      own behalf and on Your sole responsibility, not on behalf of any
+      other Contributor, and only if You agree to indemnify, defend,
+      and hold each Contributor harmless for any liability incurred by,
+      or claims asserted against, such Contributor by reason of your
+      accepting any such warranty or support.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2024-2026 EvalGuard, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,334 @@
+# @evalguard/langchain
+
+Drop-in EvalGuard instrumentation for [LangChain](https://docs.langchain.com/) and [LangGraph](https://langchain-ai.github.io/langgraph/) in TypeScript / JavaScript.
+
+Adds **real-time firewall (2.57ms p95), 200+ eval scorers, 300+ attack plugins, and 50 compliance frameworks** to any LangChain chain or LangGraph agent — without rewriting your code. One callback handler, full coverage.
+
+<!-- Counts use the rounded FEATURE_COUNTS_DISPLAY forms from
+     packages/core/src/counts.ts so this README can't drift below the live
+     registry between releases (site-audit remediation 2026-07-12). -->
+
+## Why this exists
+
+LangChain users already have observability via LangSmith. This package adds the surface LangSmith doesn't ship:
+- Real-time input + output guardrail enforcement (block prompt injection, PII exfiltration, jailbreaks in the hot path)
+- 300+ plugin adaptive red teaming (run on demand from the dashboard against your chain)
+- 50 compliance frameworks (EU AI Act Annex IV, ISO 42001 SoA, SOC 2 evidence collector)
+- Vendor-neutral routing across [90+ first-party LLM providers](https://evalguard.ai/docs/providers) + 800+ via aggregators (OpenRouter / LiteLLM / CometAPI)
+
+You can run **alongside LangSmith** (both handlers in the same chain) or **replace it** by re-pointing your OTEL exporter to `https://evalguard.ai/api/v1/ingest/otlp/traces`.
+
+## Install
+
+```bash
+npm install @evalguard/langchain @langchain/core @langchain/openai
+```
+
+`@langchain/openai` is the chat model used by the examples below — swap it for
+`@langchain/anthropic`, `@langchain/google-genai`, or whichever provider
+package you actually use. Only `@evalguard/langchain` and `@langchain/core`
+are required by the wrapper itself.
+
+> ### ⚠️ ESM-only — requires `"type": "module"`
+>
+> `@evalguard/langchain` ships **ES modules only** (`"type": "module"`, no CJS build). The
+> quickstart below **will not type-check or run** in a default CommonJS
+> TypeScript project — you get `TS1479` ("the referenced file is an ECMAScript
+> module and cannot be imported with `require`") and, because the peer SDK's
+> types then resolve under a different module mode, a confusing
+> `TS2345 … Property '#private' … refers to a different member` on the very
+> first call.
+>
+> **To use this package, your consuming project must be ESM:**
+>
+> ```jsonc
+> // package.json
+> { "type": "module" }
+> ```
+> ```jsonc
+> // tsconfig.json
+> { "compilerOptions": { "module": "node16", "moduleResolution": "node16" } }
+> ```
+>
+> **Staying on CommonJS?** Load it with a dynamic `import()`. Unlike the
+> SDK-shaped wrappers (`@evalguard/openai`, `@evalguard/anthropic`,
+> `@evalguard/gemini`), the handler takes no instance of a peer class across
+> the boundary, and `@langchain/core` / `@langchain/openai` are dual-published,
+> so your LangChain imports can stay static. Verified against
+> `@langchain/core@0.3` + `@langchain/openai@0.6`.
+>
+> The `await` must sit **inside an async function**: top-level `await` is an
+> ESM-only feature, so a bare `await import(...)` at file scope in a CJS module
+> is `TS1309: The current file is a CommonJS module and cannot use 'await' at
+> the top level`.
+>
+> ```typescript
+> // ✅ compiles under module/moduleResolution "node16", no "type": "module"
+> import { ChatOpenAI } from "@langchain/openai";
+>
+> async function main() {
+>   const { EvalGuardCallbackHandler } = await import("@evalguard/langchain");
+>   const handler = new EvalGuardCallbackHandler({
+>     apiKey: process.env.EVALGUARD_API_KEY!,
+>     projectId: "proj-123",
+>   });
+>
+>   const model = new ChatOpenAI({ model: "gpt-4o", callbacks: [handler] });
+>   return model;
+> }
+>
+> void main();
+> ```
+>
+> If you swap in an LLM package that is itself ESM-only, that import has to
+> become dynamic as well — the rule is that **no ESM-only specifier may be
+> imported statically from a CJS file**, not just this one.
+>
+> Node.js ≥ 22.12 can also `require()` an ESM module directly
+> (`require(esm)`), but TypeScript still type-checks the import under CJS
+> rules, so the dynamic-import form above is the supported path.
+
+`@langchain/core` is a peer dependency — the wrapper compiles without it, so you can install lazily.
+
+## Usage
+
+### Per-model handler
+
+```ts
+import { ChatOpenAI } from "@langchain/openai";
+import { EvalGuardCallbackHandler } from "@evalguard/langchain";
+
+const handler = new EvalGuardCallbackHandler({
+  apiKey: process.env.EVALGUARD_API_KEY!,
+  projectId: "proj-123",        // optional
+  blockOnViolation: true,        // default: true
+  metadata: { env: "prod" },     // optional, attached to every trace
+});
+
+const model = new ChatOpenAI({
+  model: "gpt-4o",
+  callbacks: [handler],
+});
+
+const result = await model.invoke("Summarise this email…");
+```
+
+### Global env-based install
+
+```ts
+import { autoInstall } from "@evalguard/langchain";
+
+const handler = autoInstall();
+// Reads EVALGUARD_API_KEY + EVALGUARD_PROJECT_ID + EVALGUARD_BASE_URL.
+// Returns null if EVALGUARD_API_KEY is unset (safe to call at module load).
+```
+
+Then pass `handler` to any chain's `callbacks` array, or attach globally via `setGlobalCallbacks([handler])` from `@langchain/core/callbacks/manager`.
+
+### LangGraph
+
+The same handler covers LangGraph — node-level events (`handleChainStart`, `handleToolStart`, `handleAgentAction`) emit nested spans so the trace tree mirrors your graph topology.
+
+LangGraph ships in its own package, so install it alongside the wrapper:
+
+```bash
+npm install @langchain/langgraph
+```
+
+A complete graph, start to finish. The handler goes in the `RunnableConfig` you
+pass to `invoke`, which is what makes every node in the graph — not just the
+top-level call — emit a span:
+
+<!-- langgraph:example -->
+
+```ts
+import { StateGraph, StateSchema, MessagesValue, START, END } from "@langchain/langgraph";
+import { AIMessage, HumanMessage } from "@langchain/core/messages";
+import { EvalGuardCallbackHandler } from "@evalguard/langchain";
+
+const handler = new EvalGuardCallbackHandler({ apiKey: process.env.EVALGUARD_API_KEY! });
+
+const State = new StateSchema({ messages: MessagesValue });
+
+const app = new StateGraph(State)
+  .addNode("respond", (state) => ({
+    messages: [new AIMessage(`echo: ${state.messages.at(-1)?.text ?? ""}`)],
+  }))
+  .addEdge(START, "respond")
+  .addEdge("respond", END)
+  .compile();
+
+const result = await app.invoke(
+  { messages: [new HumanMessage("Summarise this email…")] },
+  { callbacks: [handler] },
+);
+
+console.log(result.messages.at(-1)?.text);
+```
+
+<!-- /langgraph:example -->
+
+<sub>Until 2026-08-03 this block referenced an undeclared `workflow` and wrote
+`{ messages: [...] }` with a literal `...` — `TS1109: Expression expected`. It
+never compiled, and LangGraph is a headline feature of this package. On
+2026-08-03 the replacement above was type-checked **and executed** verbatim
+against `@langchain/langgraph@1.4.8` + `@langchain/core@1.2.4`, from the packed
+tarball in a clean ESM consumer, `module`/`moduleResolution` `node16` +
+`strict`; it prints `echo: Summarise this email…` and emits three EvalGuard
+spans. That was a one-time check, not a CI gate — the `langgraph:example`
+anchors are there so the block can be extracted and re-run verbatim, which is
+the only way this stays true. Swap the `respond` node for a real chat model and
+the same `handler` covers its LLM span too.</sub>
+
+## Config
+
+| Option | Default | Notes |
+|---|---|---|
+| `apiKey` | required | Your EvalGuard API key. |
+| `projectId` | none | Tags every trace with a project. Visible in the dashboard. |
+| `baseUrl` | `https://evalguard.ai/api/v1` | Override for self-hosted deployments. |
+| `blockOnViolation` | `true` | When `true`, guardrail violations throw `EvalguardBlockedError` and abort the LangChain run. When `false`, violations are logged but the call proceeds. |
+| `disableLogging` | `false` | Skip trace logging entirely (guardrails still run). |
+| `disableGuardrails` | `false` | Skip pre-call firewall (tracing still runs). Setting this **and** `blockOnViolation: true` throws `EvalguardConfigError` at construction — with the firewall off there is nothing to block on, and silently accepting the pair would leave you believing you are protected. |
+| `metadata` | `{}` | Free-form fields attached to every trace. |
+
+### How blocking is actually enforced
+
+LangChain swallows callback-handler exceptions by default, and by default does
+not even *await* the handler — so a handler that merely throws is a no-op and
+the model call proceeds. This handler therefore declares the two flags
+LangChain reads off the instance, `awaitHandlers = true` and
+`raiseError = true`, which is what makes the throw abort the run. Enforcement
+is verified end-to-end against a real `@langchain/core` chat model through
+`invoke`, `stream` and a `RunnableSequence` in
+`src/__tests__/blocking-enforcement.test.ts`.
+
+Two consequences worth knowing:
+
+- **An unreadable prompt is rejected, not skipped.** If the handler cannot
+  extract the prompt text (for example a custom message class whose
+  `_getType()` throws), it fails **closed** with a `prompt_unreadable`
+  violation rather than letting an unscanned prompt reach the model. With
+  `blockOnViolation: false` the call proceeds and the trace records that
+  nothing was scanned. The prompt is never partially scanned or truncated.
+- **Only the guardrail decision can abort your run.** Model-name resolution
+  degrades to `"unknown"`, and every trace-logging hook is contained, so a
+  logging failure never bubbles into your chain.
+
+## What's traced
+
+Every LangChain run emits to EvalGuard with:
+- **LLM spans** — input, output, model, latency, token usage, cost (priced via the same table as openai-wrapper / anthropic-wrapper)
+- **Chain spans** — Runnable + LangGraph node entry/exit
+- **Tool spans** — every `Tool.invoke` or LangGraph tool node
+- **Agent actions** — chosen tool + input for each agent step
+
+All spans carry **OpenInference-compliant attributes** (`openinference.span.kind`, `llm.model_name`, `llm.token_count.*`, `input.value`, `output.value`, `status.code`). This means the same traces render natively in [Phoenix](https://github.com/Arize-ai/phoenix), [Arize AX](https://arize.com/docs/ax), and any OpenInference-aware viewer.
+
+## Outage semantics — fail-CLOSED by default
+
+> Corrected 2026-07-29. This section previously documented a fail-**open**
+> contract ("lets the LangChain call proceed — guardrails default-allow on
+> error"). That has not been true since 2026-05-28, when the wrappers moved
+> to fail-closed. Customers reading this were told a security control
+> degrades safely when it does the opposite.
+
+If EvalGuard is unreachable (network blip, our outage, DNS hiccup), this
+wrapper's behaviour depends on `blockOnViolation`:
+
+| `blockOnViolation` | Guardrail unreachable | Real violation detected |
+|---|---|---|
+| `true` (**default**) | **Blocks** — throws `EvalguardBlockedError` with a `guardrail_unavailable` violation | Blocks — throws `EvalguardBlockedError` |
+| `false` | Call proceeds, violation recorded on the trace | Call proceeds, violation recorded on the trace |
+
+Trace logging always fails silently either way — a trace-log failure never
+bubbles into your chain.
+
+If you need availability-first behaviour, set `blockOnViolation: false`.
+The legacy global escape hatch `EVALGUARD_GUARDRAIL_FAIL_OPEN_LEGACY=1`
+restores pre-2026-05-28 fail-open for every wrapper in the process; it
+prints a one-time warning and is not recommended.
+
+Same contract as our `openai-wrapper`, `anthropic-wrapper`,
+`gemini-wrapper`, `vercel-ai-wrapper`, and `llamaindex-wrapper`.
+
+## Blocking errors
+
+When `blockOnViolation: true` (default), policy violations throw `EvalguardBlockedError`:
+
+```ts
+import { EvalGuardCallbackHandler, EvalguardBlockedError } from "@evalguard/langchain";
+
+try {
+  const result = await chain.invoke({ input: userMessage });
+} catch (err) {
+  if (err instanceof EvalguardBlockedError) {
+    console.log("Blocked:", err.violations);
+    // err.violations: [{ type, severity, message }]
+    return "I can't help with that.";
+  }
+  throw err;
+}
+```
+
+## Migrating from LangSmith
+
+Already on LangSmith? Two paths:
+
+**Coexist (recommended for evaluating):**
+Keep your existing `LangChainTracer` in the callbacks array; add `EvalGuardCallbackHandler` alongside. Both will receive the same events; LangSmith continues to populate its dashboard while EvalGuard adds firewall + red-teaming + compliance.
+
+**Replace:**
+Remove the LangSmith tracer. Re-point your OTEL exporter:
+
+```bash
+# Before
+OTEL_EXPORTER_OTLP_ENDPOINT=https://api.smith.langchain.com/otel/
+
+# After (full traces path — use the signal-specific env var)
+OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://evalguard.ai/api/v1/ingest/otlp/traces
+OTEL_EXPORTER_OTLP_HEADERS=Authorization=Bearer%20${EVALGUARD_API_KEY}
+```
+
+We accept OpenInference-shaped spans natively, so traces emitted via LangChain's existing OTel integration continue to flow.
+
+## Cost estimates: unpriced models are reported as unpriced
+
+`estimateCost()` used to invent a price for any model outside a ~60-row table:
+`estimateCost("gpt-5", 1000, 500)` and `estimateCost("totally-unknown-model",
+1000, 500)` both returned `0.0105` from a blended $0.003/$0.015-per-1k
+fallback — with no flag and no warning. A FinOps figure you cannot tell apart
+from a real vendor price is worse than no figure at all.
+
+Two things changed:
+
+- **Coverage** — 2,200+ model ids now resolve to a real, sourced rate
+  (generated from EvalGuard's own pricing database, which is synced from the
+  LiteLLM catalogue). `gpt-5` is priced correctly.
+- **Honesty** — a genuinely unknown model is now *visibly* unknown.
+
+```typescript
+import { estimateCostDetailed, isModelPriced } from "@evalguard/langchain";
+
+estimateCostDetailed("gpt-5", 1000, 500);
+// { model: "gpt-5", costUsd: 0.00625, priced: true, pricingSource: "catalog" }
+
+estimateCostDetailed("totally-unknown-model", 1000, 500);
+// { model: "totally-unknown-model",
+//   costUsd: null,              // <- never a fabricated number
+//   priced: false,
+//   pricingSource: "unpriced",
+//   blendedFallbackUsd: 0.0105 } // <- opt-in rough figure, clearly labelled
+
+isModelPriced("totally-unknown-model"); // false
+```
+
+`estimateCost()` still returns a `number` for backwards compatibility, but it
+now emits a one-time `console.warn` naming the unpriced model. Traces carry
+`costPricingSource` alongside `cost`, and `cost` is `null` for an unpriced
+model rather than a guess, so your EvalGuard dashboard shows "unpriced" instead
+of a fake dollar amount.
+
+## License
+
+Apache-2.0

package/dist/cost.d.ts

@@ -0,0 +1,4 @@
+export { estimateCost } from "@evalguard/wrapper-core";
+export { estimateCostDetailed, isModelPriced } from "@evalguard/wrapper-core";
+export type { CostEstimate, PricingSource } from "@evalguard/wrapper-core";
+//# sourceMappingURL=cost.d.ts.map

package/dist/cost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost.d.ts","sourceRoot":"","sources":["../src/cost.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAMvD,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC9E,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/cost.js

@@ -0,0 +1,18 @@
+// Cost estimation is shared across all EvalGuard wrappers — re-exported from
+// @evalguard/wrapper-core so the model pricing table has a single source of
+// truth (as anthropic-wrapper/src/cost.ts and openai-wrapper/src/cost.ts
+// already do).
+//
+// This file used to carry its OWN partial price table that returned 0 for any
+// model it didn't list. That silently contradicts wrapper-core's explicit
+// policy — an unknown model falls back to a conservative $0.003/$0.015 per 1k
+// because reporting 0 is worse than slightly-off: it MASKS the bill. A customer
+// on a model missing from the local table (claude-sonnet-4-5, gpt-5, any new
+// release) saw $0.00 spend in every trace while burning real provider budget.
+export { estimateCost } from "@evalguard/wrapper-core";
+// 2026-07-30 (audit finding 5): `estimateCostDetailed` is re-exported alongside
+// it. The blended fallback above is no longer SILENT — an unpriced model now
+// reports `{ costUsd: null, priced: false }` instead of a number a customer
+// cannot tell apart from a real vendor price.
+export { estimateCostDetailed, isModelPriced } from "@evalguard/wrapper-core";
+//# sourceMappingURL=cost.js.map

package/dist/cost.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost.js","sourceRoot":"","sources":["../src/cost.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,4EAA4E;AAC5E,yEAAyE;AACzE,eAAe;AACf,EAAE;AACF,8EAA8E;AAC9E,0EAA0E;AAC1E,8EAA8E;AAC9E,gFAAgF;AAChF,6EAA6E;AAC7E,8EAA8E;AAC9E,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,gFAAgF;AAChF,6EAA6E;AAC7E,4EAA4E;AAC5E,8CAA8C;AAC9C,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/guardrail-client.d.ts

@@ -0,0 +1,3 @@
+export { GuardrailClient } from "@evalguard/wrapper-core";
+export type { GuardrailCheckResult, GuardrailViolation, TraceLogData, } from "@evalguard/wrapper-core";
+//# sourceMappingURL=guardrail-client.d.ts.map

package/dist/guardrail-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guardrail-client.d.ts","sourceRoot":"","sources":["../src/guardrail-client.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,YAAY,EACV,oBAAoB,EACpB,kBAAkB,EAClB,YAAY,GACb,MAAM,yBAAyB,CAAC"}

package/dist/guardrail-client.js

@@ -0,0 +1,15 @@
+// ── EvalGuard Guardrail Client (LangChain variant) ─────────────────────────
+// Converged onto @evalguard/wrapper-core's canonical GuardrailClient (#40,
+// 2026-06-24). This wrapper previously shipped its OWN copy of the client,
+// whose logTrace built a flat /traces payload the server matched against
+// NEITHER its OTLP nor its legacy branch — so every LangChain trace was
+// silently rejected, AND the copy lacked the traceId/idempotencyKey fields the
+// shared client carries. Re-exporting the canonical client fixes the trace
+// payload (steps[]+metadata the server understands), gives retry +
+// circuit-breaker + idempotency for free, and preserves the OpenInference
+// sidecar (now a first-class TraceLogData field forwarded into metadata).
+//
+// wrapper-core has zero runtime deps, so the single-package install footprint
+// is unchanged.
+export { GuardrailClient } from "@evalguard/wrapper-core";
+//# sourceMappingURL=guardrail-client.js.map

package/dist/guardrail-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guardrail-client.js","sourceRoot":"","sources":["../src/guardrail-client.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,2EAA2E;AAC3E,2EAA2E;AAC3E,yEAAyE;AACzE,wEAAwE;AACxE,+EAA+E;AAC/E,2EAA2E;AAC3E,mEAAmE;AACnE,0EAA0E;AAC1E,0EAA0E;AAC1E,EAAE;AACF,8EAA8E;AAC9E,gBAAgB;AAChB,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC"}