@evalguard/openai 1.1.1

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,123 @@
+# @evalguard/openai
+
+Drop-in OpenAI SDK wrapper that adds real-time guardrails, trace logging, and cost tracking via [EvalGuard](https://evalguard.ai).
+
+## Installation
+
+```bash
+npm install @evalguard/openai openai
+```
+
+## Quick Start
+
+```typescript
+import OpenAI from "openai";
+import { wrapOpenAI } from "@evalguard/openai";
+
+const openai = wrapOpenAI(new OpenAI(), {
+  apiKey: "eg_...",
+  projectId: "proj_...",
+});
+
+// Use exactly like the normal OpenAI SDK — guardrails are automatic
+const response = await openai.chat.completions.create({
+  model: "gpt-4o",
+  messages: [{ role: "user", content: "Hello, how are you?" }],
+});
+
+console.log(response.choices[0].message.content);
+```
+
+## Streaming
+
+Streaming works transparently. The wrapper intercepts chunks to log the assembled response without affecting stream behavior.
+
+```typescript
+const stream = await openai.chat.completions.create({
+  model: "gpt-4o",
+  messages: [{ role: "user", content: "Write a poem about AI safety" }],
+  stream: true,
+});
+
+for await (const chunk of stream) {
+  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
+}
+```
+
+## Configuration
+
+```typescript
+const openai = wrapOpenAI(new OpenAI(), {
+  // Required: your EvalGuard API key
+  apiKey: "eg_...",
+
+  // Optional: EvalGuard API base URL (default: https://evalguard.ai/api/v1)
+  baseUrl: "https://your-evalguard-instance.com/api/v1",
+
+  // Optional: block requests that fail guardrails (default: true)
+  blockOnViolation: true,
+
+  // Optional: log all requests to EvalGuard (default: true)
+  enableLogging: true,
+
+  // Optional: project ID for organizing traces
+  projectId: "proj_...",
+
+  // Optional: custom metadata attached to every trace
+  metadata: { environment: "production", service: "chatbot" },
+
+  // Optional: callback when a guardrail violation is detected
+  onViolation: (result) => {
+    console.warn("Guardrail violation:", result.violations);
+  },
+});
+```
+
+## What It Does
+
+| Phase | Action |
+|-------|--------|
+| **Pre-request** | Sends the prompt to EvalGuard's firewall for prompt injection detection, PII scanning, and toxicity checks |
+| **LLM call** | Passes through to the real OpenAI API unchanged |
+| **Post-response** | Logs model, tokens, latency, cost, and guardrail results as a trace to EvalGuard |
+
+## Fail-Open Design
+
+If EvalGuard is unreachable (network error, timeout, 5xx), the wrapper passes requests through to OpenAI directly. Your application never breaks because of EvalGuard downtime.
+
+## Error Handling
+
+When `blockOnViolation` is `true` (default) and a guardrail check fails:
+
+```typescript
+import { EvalGuardViolationError } from "@evalguard/openai";
+
+try {
+  const response = await openai.chat.completions.create({
+    model: "gpt-4o",
+    messages: [{ role: "user", content: "malicious prompt..." }],
+  });
+} catch (error) {
+  if (error instanceof EvalGuardViolationError) {
+    console.log("Blocked:", error.violations);
+    // [{ type: "prompt_injection", severity: "critical", message: "..." }]
+  }
+}
+```
+
+Set `blockOnViolation: false` to log violations without blocking:
+
+```typescript
+const openai = wrapOpenAI(new OpenAI(), {
+  apiKey: "eg_...",
+  blockOnViolation: false,
+  onViolation: (result) => {
+    // Log but don't block
+    analytics.track("guardrail_violation", result);
+  },
+});
+```
+
+## License
+
+MIT

package/dist/cost.d.ts

@@ -0,0 +1,2 @@
+export { estimateCost } 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":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/cost.js

@@ -0,0 +1,6 @@
+// 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 (and Gemini / future-provider pricing rolls in
+// without touching this package).
+export { estimateCost } 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,wEAAwE;AACxE,uEAAuE;AACvE,iEAAiE;AACjE,kCAAkC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/guardrail-client.d.ts

@@ -0,0 +1,8 @@
+import { GuardrailClient as CoreGuardrailClient } from "@evalguard/wrapper-core";
+import type { EvalGuardConfig } from "@evalguard/wrapper-core";
+export declare class GuardrailClient extends CoreGuardrailClient {
+    constructor(apiKey: string, baseUrl?: string);
+    constructor(config: EvalGuardConfig);
+}
+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":"AAUA,OAAO,EAAE,eAAe,IAAI,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACjF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,qBAAa,eAAgB,SAAQ,mBAAmB;gBAC1C,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM;gBAChC,MAAM,EAAE,eAAe;CAQpC;AAGD,YAAY,EACV,oBAAoB,EACpB,kBAAkB,EAClB,YAAY,GACb,MAAM,yBAAyB,CAAC"}

package/dist/guardrail-client.js

@@ -0,0 +1,21 @@
+// Thin back-compat subclass over @evalguard/wrapper-core's GuardrailClient.
+//
+// Preserves the v1.0.x public constructor signature:
+//   new GuardrailClient(apiKey: string, baseUrl?: string)
+//
+// so callers + the existing test suite that instantiate via this form
+// keep working. New callers should prefer the wrapper-core form:
+//   new GuardrailClient({ apiKey, baseUrl, retry, idempotency, ... })
+// which exposes BYOK, retry+circuit-breaker, idempotency, etc.
+import { GuardrailClient as CoreGuardrailClient } from "@evalguard/wrapper-core";
+export class GuardrailClient extends CoreGuardrailClient {
+    constructor(apiKeyOrConfig, baseUrl) {
+        if (typeof apiKeyOrConfig === "string") {
+            super({ apiKey: apiKeyOrConfig, baseUrl });
+        }
+        else {
+            super(apiKeyOrConfig);
+        }
+    }
+}
+//# 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,4EAA4E;AAC5E,EAAE;AACF,qDAAqD;AACrD,0DAA0D;AAC1D,EAAE;AACF,sEAAsE;AACtE,iEAAiE;AACjE,sEAAsE;AACtE,+DAA+D;AAE/D,OAAO,EAAE,eAAe,IAAI,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAGjF,MAAM,OAAO,eAAgB,SAAQ,mBAAmB;IAGtD,YAAY,cAAwC,EAAE,OAAgB;QACpE,IAAI,OAAO,cAAc,KAAK,QAAQ,EAAE,CAAC;YACvC,KAAK,CAAC,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,CAAC,CAAC;QAC7C,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,cAAc,CAAC,CAAC;QACxB,CAAC;IACH,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import type OpenAI from "openai";
+import { type EvalGuardConfig } from "@evalguard/wrapper-core";
+export { GuardrailClient } from "./guardrail-client.js";
+export { EvalGuardViolationError, EvalGuardOutputViolationError, estimateCost, } from "@evalguard/wrapper-core";
+export type { EvalGuardConfig, GuardrailCheckResult, GuardrailViolation, TraceLogData, OutputScoreResult, ByokKeyResolver, RetryConfig, CircuitConfig, EvalOnResponseConfig, } from "@evalguard/wrapper-core";
+/**
+ * Wrap an existing OpenAI client to add EvalGuard guardrails, logging, and
+ * cost tracking. Returns a proxied client that is fully type-compatible with
+ * the original.
+ *
+ * ```ts
+ * import OpenAI from "openai";
+ * import { wrapOpenAI } from "evalguardai-openai";
+ *
+ * const openai = wrapOpenAI(new OpenAI(), {
+ *   apiKey: "eg_...",
+ *   projectId: "proj_...",
+ * });
+ *
+ * // Use exactly like the normal OpenAI SDK
+ * const res = await openai.chat.completions.create({
+ *   model: "gpt-4o",
+ *   messages: [{ role: "user", content: "Hello" }],
+ * });
+ * ```
+ */
+export declare function wrapOpenAI(client: OpenAI, config: EvalGuardConfig): OpenAI;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC,OAAO,EAML,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAWjC,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EACL,uBAAuB,EACvB,6BAA6B,EAC7B,YAAY,GACb,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACV,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,WAAW,EACX,aAAa,EACb,oBAAoB,GACrB,MAAM,yBAAyB,CAAC;AA4BjC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,MAAM,CA2B1E"}

package/dist/index.js

@@ -0,0 +1,533 @@
+// ── evalguardai-openai ───────────────────────────────────────────────────────
+// Drop-in OpenAI SDK wrapper that auto-intercepts chat.completions.create()
+// to enforce guardrails, log traces, and track costs via EvalGuard.
+import { GuardrailClient } from "./guardrail-client.js";
+import { estimateCost, newTraceId, injectTraceHeader, resolveIdempotencyKey, runPostResponseEval, } from "@evalguard/wrapper-core";
+// ── Re-exports ──────────────────────────────────────────────────────────────
+// Public surface of v1.1.0:
+//   - EvalGuardConfig now widens `apiKey` to `ByokKeyResolver` (was `string`)
+//     and adds opt-in fields: retry, circuit, idempotency, evalOnResponse,
+//     onOutputViolation. Existing string-apiKey callers are unaffected.
+//   - EvalGuardOutputViolationError is new (thrown by eval-on-response when
+//     output score falls below failOnScore).
+//   - estimateCost / GuardrailClient / newTraceId etc. are unchanged shape.
+export { GuardrailClient } from "./guardrail-client.js";
+export { EvalGuardViolationError, EvalGuardOutputViolationError, estimateCost, } from "@evalguard/wrapper-core";
+import { EvalGuardViolationError } from "@evalguard/wrapper-core";
+// ── Helper: extract text from messages ──────────────────────────────────────
+function extractPromptText(messages) {
+    return messages
+        .map((m) => {
+        if (typeof m.content === "string")
+            return m.content;
+        if (Array.isArray(m.content)) {
+            return m.content
+                .map((part) => {
+                if (part.type === "text" && typeof part.text === "string")
+                    return part.text;
+                return "";
+            })
+                .join(" ");
+        }
+        return "";
+    })
+        .join("\n");
+}
+// ── Main wrapper ────────────────────────────────────────────────────────────
+/**
+ * Wrap an existing OpenAI client to add EvalGuard guardrails, logging, and
+ * cost tracking. Returns a proxied client that is fully type-compatible with
+ * the original.
+ *
+ * ```ts
+ * import OpenAI from "openai";
+ * import { wrapOpenAI } from "evalguardai-openai";
+ *
+ * const openai = wrapOpenAI(new OpenAI(), {
+ *   apiKey: "eg_...",
+ *   projectId: "proj_...",
+ * });
+ *
+ * // Use exactly like the normal OpenAI SDK
+ * const res = await openai.chat.completions.create({
+ *   model: "gpt-4o",
+ *   messages: [{ role: "user", content: "Hello" }],
+ * });
+ * ```
+ */
+export function wrapOpenAI(client, config) {
+    // Pass the full config to the GuardrailClient — this picks up BYOK
+    // (apiKey as function), retry+circuit-breaker, idempotency, and
+    // eval-on-response wiring for free via wrapper-core.
+    const guardrail = new GuardrailClient(config);
+    const blockOnViolation = config.blockOnViolation ?? true;
+    const enableLogging = config.enableLogging ?? true;
+    // We need to intercept client.chat.completions.create(). The OpenAI SDK
+    // exposes this as a deeply nested property chain. We use a Proxy on the
+    // top-level client that intercepts property access to build a chain of
+    // proxies down to the `create` method.
+    return new Proxy(client, {
+        get(target, prop, receiver) {
+            if (prop === "chat") {
+                return createChatProxy(target.chat, guardrail, blockOnViolation, enableLogging, config);
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
+function createChatProxy(chat, guardrail, blockOnViolation, enableLogging, config) {
+    return new Proxy(chat, {
+        get(target, prop, receiver) {
+            if (prop === "completions") {
+                return createCompletionsProxy(target.completions, guardrail, blockOnViolation, enableLogging, config);
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
+function createCompletionsProxy(completions, guardrail, blockOnViolation, enableLogging, config) {
+    return new Proxy(completions, {
+        get(target, prop, receiver) {
+            if (prop === "create") {
+                return createInterceptedCreate(target.create.bind(target), guardrail, blockOnViolation, enableLogging, config);
+            }
+            // check.txt #17: the SDK also exposes chat.completions.stream() — a
+            // convenience helper distinct from create({stream:true}). Left
+            // un-intercepted, every .stream() caller skipped the input guardrail,
+            // output eval, and cost tracking. Intercept it the same way Anthropic
+            // does (and then some — see wrapChatCompletionStream).
+            if (prop === "stream") {
+                return createInterceptedStream(target, guardrail, blockOnViolation, enableLogging, config);
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
+// ── Intercepted create() ────────────────────────────────────────────────────
+function createInterceptedCreate(originalCreate, guardrail, blockOnViolation, enableLogging, config) {
+    // The OpenAI SDK's create() has multiple overloads. We return a function
+    // that handles both streaming and non-streaming transparently.
+    return async function interceptedCreate(...args) {
+        const body = args[0];
+        const messages = (body.messages ?? []);
+        const model = body.model ?? "unknown";
+        const isStreaming = Boolean(body.stream);
+        // D8 (2026-05-19): one trace id per intercepted call. Flows three
+        // places: (1) header on the EvalGuard firewall-check, (2) header
+        // + body on the EvalGuard trace-log, (3) `x-evalguard-trace-id`
+        // on the upstream OpenAI request via the SDK's RequestOptions
+        // second arg.
+        const traceId = newTraceId();
+        const upstreamArgs = injectTraceHeader(args, traceId);
+        // ── Pre-request guardrail check ─────────────────────────────────────
+        const promptText = extractPromptText(messages);
+        let guardrailResult;
+        try {
+            guardrailResult = await guardrail.checkInput(promptText, {
+                model,
+                provider: "openai",
+                projectId: config.projectId,
+                ...config.metadata,
+            }, traceId);
+        }
+        catch (err) {
+            // 2026-05-28: previously this catch silently set
+            // `{ allowed: true, violations: [] }` — meaning any guardrail
+            // outage (network blip, EvalGuard 5xx, DNS hiccup) became a
+            // free pass for the prompt. Per check.txt audit P1 finding.
+            //
+            // New contract: an unreachable guardrail is itself a
+            // "guardrail_unavailable" violation. Honor blockOnViolation —
+            // true (default) → throw; false → onViolation callback + allow.
+            const unavailable = {
+                allowed: false,
+                violations: [
+                    {
+                        type: "guardrail_unavailable",
+                        severity: "high",
+                        message: err instanceof Error ? err.message : "guardrail check failed",
+                    },
+                ],
+            };
+            config.onViolation?.(unavailable);
+            if (blockOnViolation) {
+                throw new EvalGuardViolationError(unavailable);
+            }
+            guardrailResult = { allowed: true, violations: [] };
+        }
+        if (!guardrailResult.allowed) {
+            config.onViolation?.(guardrailResult);
+            if (blockOnViolation) {
+                throw new EvalGuardViolationError(guardrailResult);
+            }
+        }
+        // ── Execute LLM call ────────────────────────────────────────────────
+        const startTime = performance.now();
+        if (isStreaming) {
+            return handleStreamingResponse(originalCreate, upstreamArgs, model, messages, startTime, guardrail, enableLogging, config, guardrailResult, traceId);
+        }
+        return handleNonStreamingResponse(originalCreate, upstreamArgs, model, messages, startTime, guardrail, enableLogging, config, guardrailResult, traceId);
+    };
+}
+// ── Non-streaming handler ───────────────────────────────────────────────────
+async function handleNonStreamingResponse(originalCreate, args, model, messages, startTime, guardrail, enableLogging, config, guardrailResult, traceId) {
+    const response = await originalCreate(...args);
+    const latencyMs = Math.round(performance.now() - startTime);
+    const usage = response.usage;
+    const inputTokens = usage?.prompt_tokens ?? 0;
+    const outputTokens = usage?.completion_tokens ?? 0;
+    const cost = estimateCost(model, inputTokens, outputTokens);
+    const outputContent = response.choices?.[0]
+        ?.message ?? null;
+    const idempotencyKey = resolveIdempotencyKey(config);
+    // ── Eval-on-response (no-op unless config.evalOnResponse is set) ───────
+    // May throw EvalGuardOutputViolationError when failOnScore is breached
+    // and fireAndForget is NOT set.
+    const outputText = typeof outputContent === "object" && outputContent !== null
+        ? String(outputContent.content ?? "")
+        : String(outputContent ?? "");
+    let outputScore = null;
+    try {
+        outputScore = await runPostResponseEval(guardrail, config, outputText, { model, provider: "openai", projectId: config.projectId, ...config.metadata }, traceId, idempotencyKey);
+    }
+    catch (err) {
+        // Re-throw EvalGuardOutputViolationError after logging the trace
+        // (caller still wants the trace row for the blocked output).
+        if (enableLogging) {
+            guardrail
+                .logTrace({
+                model,
+                provider: "openai",
+                input: messages,
+                output: outputContent,
+                latencyMs,
+                tokenUsage: { input: inputTokens, output: outputTokens },
+                cost,
+                projectId: config.projectId,
+                metadata: config.metadata,
+                guardrailResult,
+                outputScore: outputScore ?? undefined,
+                traceId,
+                idempotencyKey,
+            })
+                .catch(() => {
+                /* logging never throws */
+            });
+        }
+        throw err;
+    }
+    // Log trace in background (non-blocking) — happy path.
+    if (enableLogging) {
+        guardrail
+            .logTrace({
+            model,
+            provider: "openai",
+            input: messages,
+            output: outputContent,
+            latencyMs,
+            tokenUsage: { input: inputTokens, output: outputTokens },
+            cost,
+            projectId: config.projectId,
+            metadata: config.metadata,
+            guardrailResult,
+            outputScore: outputScore ?? undefined,
+            traceId,
+            idempotencyKey,
+        })
+            .catch(() => {
+            /* logging must never throw */
+        });
+    }
+    return response;
+}
+// ── Streaming handler ───────────────────────────────────────────────────────
+async function handleStreamingResponse(originalCreate, args, model, messages, startTime, guardrail, enableLogging, config, guardrailResult, traceId) {
+    const stream = await originalCreate(...args);
+    if (!enableLogging) {
+        return stream;
+    }
+    // Wrap the async iterable to intercept chunks for logging while
+    // passing them through transparently to the caller.
+    return wrapAsyncIterable(stream, model, messages, startTime, guardrail, config, guardrailResult, traceId);
+}
+function finalizeOpenAIStream(state) {
+    const { assembledContent, inputTokens, outputTokens, model, messages, startTime, guardrail, config, guardrailResult, traceId, } = state;
+    const latencyMs = Math.round(performance.now() - startTime);
+    const cost = estimateCost(model, inputTokens, outputTokens);
+    const idempotencyKey = resolveIdempotencyKey(config);
+    runPostResponseEval(guardrail, config, assembledContent, { model, provider: "openai", projectId: config.projectId, ...config.metadata }, traceId, idempotencyKey)
+        .catch((err) => {
+        if (err && typeof err === "object" && err.score) {
+            const score = err.score;
+            try {
+                config.onOutputViolation?.(score);
+            }
+            catch {
+                /* user callback errors must not break the stream */
+            }
+            return score;
+        }
+        return null;
+    })
+        .then((outputScore) => {
+        guardrail
+            .logTrace({
+            model,
+            provider: "openai",
+            input: messages,
+            output: assembledContent,
+            latencyMs,
+            tokenUsage: { input: inputTokens, output: outputTokens },
+            cost,
+            projectId: config.projectId,
+            metadata: config.metadata,
+            guardrailResult,
+            outputScore: outputScore ?? undefined,
+            traceId,
+            idempotencyKey,
+        })
+            .catch(() => {
+            /* logging never throws */
+        });
+    });
+}
+function wrapAsyncIterable(stream, model, messages, startTime, guardrail, config, guardrailResult, traceId) {
+    let assembledContent = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    const originalIterator = Symbol.asyncIterator in stream
+        ? stream[Symbol.asyncIterator]()
+        : stream;
+    const wrappedIterator = {
+        async next() {
+            const result = await originalIterator.next();
+            if (result.done) {
+                // Stream complete -- finalize (eval-on-response + trace log) in the
+                // background. We never await inside `next()` — that would deadlock
+                // callers who hold the iterator.
+                finalizeOpenAIStream({
+                    assembledContent,
+                    inputTokens,
+                    outputTokens,
+                    model,
+                    messages,
+                    startTime,
+                    guardrail,
+                    config,
+                    guardrailResult,
+                    traceId,
+                });
+                return result;
+            }
+            // Accumulate content from chunk
+            const chunk = result.value;
+            const choices = chunk.choices;
+            if (choices?.[0]?.delta?.content) {
+                assembledContent += choices[0].delta.content;
+            }
+            // Capture usage if present (some models report on final chunk)
+            const usage = chunk.usage;
+            if (usage) {
+                inputTokens = usage.prompt_tokens ?? inputTokens;
+                outputTokens = usage.completion_tokens ?? outputTokens;
+            }
+            return result;
+        },
+        async return(value) {
+            if (originalIterator.return) {
+                return originalIterator.return(value);
+            }
+            return { done: true, value: undefined };
+        },
+        async throw(error) {
+            if (originalIterator.throw) {
+                return originalIterator.throw(error);
+            }
+            throw error;
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+    // Preserve additional properties on the stream object (e.g., .controller,
+    // .response, .toReadableStream() from the OpenAI SDK).
+    return new Proxy(stream, {
+        get(_target, prop, receiver) {
+            if (prop === Symbol.asyncIterator) {
+                return () => wrappedIterator;
+            }
+            // Delegate everything else to the original stream
+            return Reflect.get(stream, prop, receiver);
+        },
+    });
+}
+// ── Intercepted stream() helper method (check.txt #17) ──────────────────────
+/**
+ * Intercept `chat.completions.stream()` — the SDK's streaming convenience
+ * helper that returns a ChatCompletionStream (async-iterable AND event-emitter
+ * with .finalChatCompletion()/.finalContent()/.on('content')).
+ *
+ * Mirrors the Anthropic wrapper's stream() interception, then goes further:
+ * the OpenAI helper is very commonly consumed via `await stream.finalChatCompletion()`
+ * WITHOUT `for await`, so an iteration-only hook would leave cost + output-eval
+ * unmeasured for those callers (a half-fix). We hook BOTH consumption modes and
+ * use a one-shot `settled` latch so whichever resolves first finalizes exactly
+ * once. The pre-request input guardrail fires regardless of consumption mode.
+ */
+function createInterceptedStream(completions, guardrail, blockOnViolation, enableLogging, config) {
+    const originalStream = "stream" in completions &&
+        typeof completions.stream === "function"
+        ? completions.stream.bind(completions)
+        : null;
+    // Older SDKs (or a fake without .stream) — fall through to the real value.
+    if (!originalStream) {
+        return completions.stream;
+    }
+    // NOTE: like every EvalGuard wrapper (anthropic/vercel/gemini), the wrapped
+    // .stream() resolves through a Promise so the async input guardrail runs
+    // BEFORE the upstream request — a blocked prompt never reaches the provider.
+    // Callers `await client.chat.completions.stream(...)`; the resolved value is
+    // the full ChatCompletionStream (async-iterable + .on/.finalChatCompletion/…).
+    return async function interceptedStream(...args) {
+        const body = (args[0] ?? {});
+        const messages = (body.messages ?? []);
+        const model = body.model ?? "unknown";
+        const traceId = newTraceId();
+        const upstreamArgs = injectTraceHeader(args, traceId);
+        // ── Pre-request guardrail check ─────────────────────────────────────
+        const promptText = extractPromptText(messages);
+        let guardrailResult;
+        try {
+            guardrailResult = await guardrail.checkInput(promptText, { model, provider: "openai", projectId: config.projectId, ...config.metadata }, traceId);
+        }
+        catch (err) {
+            // Unreachable guardrail is itself a high-severity violation
+            // (fail-closed by default) — symmetric with the create() path.
+            const unavailable = {
+                allowed: false,
+                violations: [
+                    {
+                        type: "guardrail_unavailable",
+                        severity: "high",
+                        message: err instanceof Error ? err.message : "guardrail check failed",
+                    },
+                ],
+            };
+            config.onViolation?.(unavailable);
+            if (blockOnViolation) {
+                throw new EvalGuardViolationError(unavailable);
+            }
+            guardrailResult = { allowed: true, violations: [] };
+        }
+        if (!guardrailResult.allowed) {
+            config.onViolation?.(guardrailResult);
+            if (blockOnViolation) {
+                throw new EvalGuardViolationError(guardrailResult);
+            }
+        }
+        const startTime = performance.now();
+        const stream = originalStream(...upstreamArgs);
+        const resolved = stream instanceof Promise ? await stream : stream;
+        if (!enableLogging) {
+            return resolved;
+        }
+        return wrapChatCompletionStream(resolved, model, messages, startTime, guardrail, config, guardrailResult, traceId);
+    };
+}
+/**
+ * Wrap a ChatCompletionStream so that cost + eval-on-response + trace logging
+ * fire exactly once, whether the caller drains it via `for await`, via
+ * `.finalChatCompletion()`, or via `.finalContent()`. All other methods/props
+ * (`.on`, `.controller`, `.toReadableStream`, `.totalUsage`, …) pass through.
+ */
+function wrapChatCompletionStream(stream, model, messages, startTime, guardrail, config, guardrailResult, traceId) {
+    let assembledContent = "";
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let settled = false;
+    const finalizeOnce = (content, inTok, outTok) => {
+        if (settled)
+            return;
+        settled = true;
+        finalizeOpenAIStream({
+            assembledContent: content,
+            inputTokens: inTok,
+            outputTokens: outTok,
+            model,
+            messages,
+            startTime,
+            guardrail,
+            config,
+            guardrailResult,
+            traceId,
+        });
+    };
+    const originalIterator = Symbol.asyncIterator in stream
+        ? stream[Symbol.asyncIterator]()
+        : stream;
+    const wrappedIterator = {
+        async next() {
+            const result = await originalIterator.next();
+            if (result.done) {
+                finalizeOnce(assembledContent, inputTokens, outputTokens);
+                return result;
+            }
+            const chunk = result.value;
+            const choices = chunk.choices;
+            if (choices?.[0]?.delta?.content) {
+                assembledContent += choices[0].delta.content;
+            }
+            const usage = chunk.usage;
+            if (usage) {
+                inputTokens = usage.prompt_tokens ?? inputTokens;
+                outputTokens = usage.completion_tokens ?? outputTokens;
+            }
+            return result;
+        },
+        async return(value) {
+            if (originalIterator.return) {
+                return originalIterator.return(value);
+            }
+            return { done: true, value: undefined };
+        },
+        async throw(error) {
+            if (originalIterator.throw) {
+                return originalIterator.throw(error);
+            }
+            throw error;
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+    return new Proxy(stream, {
+        get(_target, prop, receiver) {
+            if (prop === Symbol.asyncIterator) {
+                return () => wrappedIterator;
+            }
+            // .finalChatCompletion() resolves to the assembled completion with usage
+            // — the cost-accurate finalize path for non-iterating consumers.
+            if (prop === "finalChatCompletion" && typeof stream.finalChatCompletion === "function") {
+                return async (...a) => {
+                    const completion = (await stream.finalChatCompletion(...a));
+                    const choice = completion.choices?.[0];
+                    const text = String(choice?.message?.content ?? "");
+                    const u = completion.usage;
+                    finalizeOnce(text, u?.prompt_tokens ?? inputTokens, u?.completion_tokens ?? outputTokens);
+                    return completion;
+                };
+            }
+            // .finalContent() returns just the text (no usage) — still finalize so
+            // output-eval + the trace fire; cost is best-effort from any chunks seen.
+            if (prop === "finalContent" && typeof stream.finalContent === "function") {
+                return async (...a) => {
+                    const text = await stream.finalContent(...a);
+                    finalizeOnce(String(text ?? ""), inputTokens, outputTokens);
+                    return text;
+                };
+            }
+            return Reflect.get(stream, prop, receiver);
+        },
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@evalguard/openai",
+  "version": "1.1.1",
+  "description": "Drop-in OpenAI SDK wrapper with EvalGuard guardrails, logging & cost tracking",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "openai",
+    "llm",
+    "guardrails",
+    "evalguard",
+    "ai-safety",
+    "prompt-injection",
+    "pii-detection",
+    "cost-tracking",
+    "observability"
+  ],
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/EvalGuardAi/evalguard.git",
+    "directory": "packages/openai-wrapper"
+  },
+  "homepage": "https://evalguard.ai",
+  "bugs": {
+    "url": "https://github.com/EvalGuardAi/evalguard/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "peerDependencies": {
+    "openai": ">=4.0.0"
+  },
+  "dependencies": {
+    "@evalguard/wrapper-core": "1.0.1"
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^8.59.3",
+    "@typescript-eslint/parser": "^8.59.3",
+    "eslint": "^10.4.0",
+    "openai": "^6.37.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.6",
+    "@evalguard/config": "0.0.1"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "lint": "eslint src --quiet",
+    "clean": "rm -rf dist .turbo"
+  }
+}