@lockllm/sdk 1.0.0

package/dist/wrappers/generic-wrapper.mjs

@@ -0,0 +1,225 @@
+/**
+ * Generic SDK wrapper for any provider
+ *
+ * This wrapper provides a generic way to create clients for any LLM provider
+ * by routing requests through the LockLLM proxy.
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from '@lockllm/sdk/wrappers';
+ *
+ * // For providers with official SDKs
+ * const mistral = createClient('mistral', MistralClient, {
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * // For providers with OpenAI-compatible APIs
+ * const groq = createClient('groq', OpenAI, {
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ * ```
+ */
+import { getProxyURL } from '../utils';
+/**
+ * Create a client for any provider using their official SDK
+ *
+ * This is a generic factory function that works with any LLM provider SDK
+ * by configuring it to use the LockLLM proxy.
+ *
+ * @param provider - The provider name (e.g., 'openai', 'anthropic', 'mistral')
+ * @param ClientConstructor - The provider's SDK client constructor
+ * @param config - Configuration options
+ * @returns Configured client instance
+ *
+ * @example
+ * ```typescript
+ * // Mistral AI
+ * import MistralClient from '@mistralai/mistralai';
+ * const mistral = createClient('mistral', MistralClient, {
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * // Groq (OpenAI-compatible)
+ * import OpenAI from 'openai';
+ * const groq = createClient('groq', OpenAI, {
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * // Cohere
+ * import { CohereClient } from 'cohere-ai';
+ * const cohere = createClient('cohere', CohereClient, {
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ * ```
+ */
+export function createClient(provider, ClientConstructor, config) {
+    const { apiKey, baseURL, ...otherOptions } = config;
+    // Use provided baseURL or default to LockLLM proxy
+    const clientBaseURL = baseURL || getProxyURL(provider);
+    // Create client with LockLLM proxy configuration
+    return new ClientConstructor({
+        apiKey,
+        baseURL: clientBaseURL,
+        ...otherOptions,
+    });
+}
+/**
+ * Lazy-load OpenAI SDK constructor
+ * @internal - exposed for testing purposes
+ */
+export function getGenericOpenAIConstructor(requireFn = require) {
+    try {
+        const openaiModule = requireFn('openai');
+        return openaiModule.default || openaiModule.OpenAI || openaiModule;
+    }
+    catch (error) {
+        throw new Error('OpenAI SDK not found. Please install it with: npm install openai');
+    }
+}
+/**
+ * Helper to create OpenAI-compatible clients for providers
+ *
+ * Many providers (Groq, DeepSeek, Perplexity, etc.) use OpenAI-compatible APIs.
+ * This helper makes it easy to create clients for these providers.
+ *
+ * @param provider - The provider name
+ * @param config - Configuration options
+ * @returns OpenAI client configured for the provider
+ *
+ * @example
+ * ```typescript
+ * // Groq
+ * const groq = createOpenAICompatible('groq', {
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * // DeepSeek
+ * const deepseek = createOpenAICompatible('deepseek', {
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * // Use like OpenAI
+ * const response = await groq.chat.completions.create({
+ *   model: 'llama-3.1-70b-versatile',
+ *   messages: [{ role: 'user', content: 'Hello!' }]
+ * });
+ * ```
+ */
+export function createOpenAICompatible(provider, config) {
+    const OpenAIConstructor = getGenericOpenAIConstructor();
+    return createClient(provider, OpenAIConstructor, config);
+}
+/**
+ * Pre-configured factory functions for specific providers
+ */
+/**
+ * Create a Groq client (OpenAI-compatible)
+ */
+export function createGroq(config) {
+    return createOpenAICompatible('groq', config);
+}
+/**
+ * Create a DeepSeek client (OpenAI-compatible)
+ */
+export function createDeepSeek(config) {
+    return createOpenAICompatible('deepseek', config);
+}
+/**
+ * Create a Perplexity client (OpenAI-compatible)
+ */
+export function createPerplexity(config) {
+    return createOpenAICompatible('perplexity', config);
+}
+/**
+ * Create a Mistral AI client (OpenAI-compatible)
+ */
+export function createMistral(config) {
+    return createOpenAICompatible('mistral', config);
+}
+/**
+ * Create an OpenRouter client (OpenAI-compatible)
+ */
+export function createOpenRouter(config) {
+    return createOpenAICompatible('openrouter', config);
+}
+/**
+ * Create a Together AI client (OpenAI-compatible)
+ */
+export function createTogether(config) {
+    return createOpenAICompatible('together', config);
+}
+/**
+ * Create an xAI (Grok) client (OpenAI-compatible)
+ */
+export function createXAI(config) {
+    return createOpenAICompatible('xai', config);
+}
+/**
+ * Create a Fireworks AI client (OpenAI-compatible)
+ */
+export function createFireworks(config) {
+    return createOpenAICompatible('fireworks', config);
+}
+/**
+ * Create an Anyscale client (OpenAI-compatible)
+ */
+export function createAnyscale(config) {
+    return createOpenAICompatible('anyscale', config);
+}
+/**
+ * Create a Hugging Face client (OpenAI-compatible)
+ */
+export function createHuggingFace(config) {
+    return createOpenAICompatible('huggingface', config);
+}
+/**
+ * Create a Google Gemini client
+ *
+ * Note: For Gemini, you should use the @google/generative-ai SDK
+ * or an OpenAI-compatible wrapper if available.
+ */
+export function createGemini(config) {
+    return createOpenAICompatible('gemini', config);
+}
+/**
+ * Get Cohere SDK constructor
+ * @internal - exposed for testing purposes
+ */
+export function getCohereConstructor(requireFn = require) {
+    try {
+        const cohereModule = requireFn('cohere-ai');
+        return cohereModule.CohereClient || cohereModule;
+    }
+    catch (error) {
+        throw new Error('Cohere SDK not found. Please install it with: npm install cohere-ai');
+    }
+}
+/**
+ * Create a Cohere client
+ *
+ * Note: For Cohere, you should use the cohere-ai SDK
+ */
+export function createCohere(config) {
+    // Check if Cohere SDK is installed
+    const CohereConstructor = getCohereConstructor();
+    return createClient('cohere', CohereConstructor, config);
+}
+/**
+ * Create an Azure OpenAI client
+ */
+export function createAzure(config) {
+    return createOpenAICompatible('azure', config);
+}
+/**
+ * Create an AWS Bedrock client
+ */
+export function createBedrock(config) {
+    return createOpenAICompatible('bedrock', config);
+}
+/**
+ * Create a Google Vertex AI client
+ */
+export function createVertexAI(config) {
+    return createOpenAICompatible('vertex-ai', config);
+}
+//# sourceMappingURL=generic-wrapper.js.map

package/dist/wrappers/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * SDK Wrappers - Drop-in replacements for official SDKs
+ *
+ * @example
+ * ```typescript
+ * import { createOpenAI, createAnthropic, createGroq } from '@lockllm/sdk/wrappers';
+ *
+ * const openai = createOpenAI({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * const anthropic = createAnthropic({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * const groq = createGroq({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ * ```
+ */
+export { createOpenAI } from './openai-wrapper';
+export type { CreateOpenAIConfig } from './openai-wrapper';
+export { createAnthropic } from './anthropic-wrapper';
+export type { CreateAnthropicConfig } from './anthropic-wrapper';
+export { createClient, createOpenAICompatible, createGroq, createDeepSeek, createPerplexity, createMistral, createOpenRouter, createTogether, createXAI, createFireworks, createAnyscale, createHuggingFace, createGemini, createCohere, createAzure, createBedrock, createVertexAI, } from './generic-wrapper';
+export type { GenericClientConfig } from './generic-wrapper';
+//# sourceMappingURL=index.d.ts.map

package/dist/wrappers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/wrappers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,YAAY,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAGjE,OAAO,EACL,YAAY,EACZ,sBAAsB,EACtB,UAAU,EACV,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,SAAS,EACT,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,aAAa,EACb,cAAc,GACf,MAAM,mBAAmB,CAAC;AAC3B,YAAY,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/wrappers/index.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * SDK Wrappers - Drop-in replacements for official SDKs
+ *
+ * @example
+ * ```typescript
+ * import { createOpenAI, createAnthropic, createGroq } from '@lockllm/sdk/wrappers';
+ *
+ * const openai = createOpenAI({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * const anthropic = createAnthropic({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * const groq = createGroq({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVertexAI = exports.createBedrock = exports.createAzure = exports.createCohere = exports.createGemini = exports.createHuggingFace = exports.createAnyscale = exports.createFireworks = exports.createXAI = exports.createTogether = exports.createOpenRouter = exports.createMistral = exports.createPerplexity = exports.createDeepSeek = exports.createGroq = exports.createOpenAICompatible = exports.createClient = exports.createAnthropic = exports.createOpenAI = void 0;
+// Provider-specific wrappers
+var openai_wrapper_1 = require("./openai-wrapper");
+Object.defineProperty(exports, "createOpenAI", { enumerable: true, get: function () { return openai_wrapper_1.createOpenAI; } });
+var anthropic_wrapper_1 = require("./anthropic-wrapper");
+Object.defineProperty(exports, "createAnthropic", { enumerable: true, get: function () { return anthropic_wrapper_1.createAnthropic; } });
+// Generic wrapper and utilities
+var generic_wrapper_1 = require("./generic-wrapper");
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return generic_wrapper_1.createClient; } });
+Object.defineProperty(exports, "createOpenAICompatible", { enumerable: true, get: function () { return generic_wrapper_1.createOpenAICompatible; } });
+Object.defineProperty(exports, "createGroq", { enumerable: true, get: function () { return generic_wrapper_1.createGroq; } });
+Object.defineProperty(exports, "createDeepSeek", { enumerable: true, get: function () { return generic_wrapper_1.createDeepSeek; } });
+Object.defineProperty(exports, "createPerplexity", { enumerable: true, get: function () { return generic_wrapper_1.createPerplexity; } });
+Object.defineProperty(exports, "createMistral", { enumerable: true, get: function () { return generic_wrapper_1.createMistral; } });
+Object.defineProperty(exports, "createOpenRouter", { enumerable: true, get: function () { return generic_wrapper_1.createOpenRouter; } });
+Object.defineProperty(exports, "createTogether", { enumerable: true, get: function () { return generic_wrapper_1.createTogether; } });
+Object.defineProperty(exports, "createXAI", { enumerable: true, get: function () { return generic_wrapper_1.createXAI; } });
+Object.defineProperty(exports, "createFireworks", { enumerable: true, get: function () { return generic_wrapper_1.createFireworks; } });
+Object.defineProperty(exports, "createAnyscale", { enumerable: true, get: function () { return generic_wrapper_1.createAnyscale; } });
+Object.defineProperty(exports, "createHuggingFace", { enumerable: true, get: function () { return generic_wrapper_1.createHuggingFace; } });
+Object.defineProperty(exports, "createGemini", { enumerable: true, get: function () { return generic_wrapper_1.createGemini; } });
+Object.defineProperty(exports, "createCohere", { enumerable: true, get: function () { return generic_wrapper_1.createCohere; } });
+Object.defineProperty(exports, "createAzure", { enumerable: true, get: function () { return generic_wrapper_1.createAzure; } });
+Object.defineProperty(exports, "createBedrock", { enumerable: true, get: function () { return generic_wrapper_1.createBedrock; } });
+Object.defineProperty(exports, "createVertexAI", { enumerable: true, get: function () { return generic_wrapper_1.createVertexAI; } });
+//# sourceMappingURL=index.js.map

package/dist/wrappers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/wrappers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,6BAA6B;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGhD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGtD,gCAAgC;AAChC,OAAO,EACL,YAAY,EACZ,sBAAsB,EACtB,UAAU,EACV,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,SAAS,EACT,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,aAAa,EACb,cAAc,GACf,MAAM,mBAAmB,CAAC"}

package/dist/wrappers/index.mjs

@@ -0,0 +1,26 @@
+/**
+ * SDK Wrappers - Drop-in replacements for official SDKs
+ *
+ * @example
+ * ```typescript
+ * import { createOpenAI, createAnthropic, createGroq } from '@lockllm/sdk/wrappers';
+ *
+ * const openai = createOpenAI({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * const anthropic = createAnthropic({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * const groq = createGroq({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ * ```
+ */
+// Provider-specific wrappers
+export { createOpenAI } from './openai-wrapper';
+export { createAnthropic } from './anthropic-wrapper';
+// Generic wrapper and utilities
+export { createClient, createOpenAICompatible, createGroq, createDeepSeek, createPerplexity, createMistral, createOpenRouter, createTogether, createXAI, createFireworks, createAnyscale, createHuggingFace, createGemini, createCohere, createAzure, createBedrock, createVertexAI, } from './generic-wrapper';
+//# sourceMappingURL=index.js.map

package/dist/wrappers/openai-wrapper.d.ts

@@ -0,0 +1,70 @@
+/**
+ * OpenAI SDK wrapper - Drop-in replacement
+ *
+ * This wrapper allows you to use the official OpenAI SDK with LockLLM protection
+ * by simply changing how you initialize the client.
+ *
+ * @example
+ * ```typescript
+ * // Replace this:
+ * // import OpenAI from 'openai';
+ * // const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * // With this:
+ * import { createOpenAI } from '@lockllm/sdk/wrappers';
+ * const openai = createOpenAI({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * // Everything else stays the same!
+ * const response = await openai.chat.completions.create({
+ *   model: "gpt-4",
+ *   messages: [{ role: "user", content: "Hello!" }]
+ * });
+ * ```
+ */
+export interface CreateOpenAIConfig {
+    /**
+     * Your LockLLM API key
+     * Get it from: https://www.lockllm.com/dashboard
+     */
+    apiKey: string;
+    /**
+     * Base URL for LockLLM proxy (default: https://api.lockllm.com/v1/proxy/openai)
+     * Override this only if you're using a custom LockLLM endpoint
+     */
+    baseURL?: string;
+    /**
+     * Other OpenAI client options
+     */
+    [key: string]: any;
+}
+/**
+ * Create an OpenAI client that routes through LockLLM proxy
+ *
+ * All requests are automatically scanned for prompt injection before being
+ * forwarded to OpenAI. Your OpenAI API key should be configured in the
+ * LockLLM dashboard at https://www.lockllm.com/dashboard
+ *
+ * @param config - Configuration options
+ * @returns OpenAI client instance
+ *
+ * @example
+ * ```typescript
+ * const openai = createOpenAI({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * const response = await openai.chat.completions.create({
+ *   model: "gpt-4",
+ *   messages: [{ role: "user", content: "Hello!" }]
+ * });
+ * ```
+ */
+/**
+ * Lazy-load OpenAI SDK constructor
+ * @internal - exposed for testing purposes
+ */
+export declare function getOpenAIConstructor(requireFn?: NodeJS.Require): any;
+export declare function createOpenAI(config: CreateOpenAIConfig): any;
+//# sourceMappingURL=openai-wrapper.d.ts.map

package/dist/wrappers/openai-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-wrapper.d.ts","sourceRoot":"","sources":["../../src/wrappers/openai-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,iBAAU,GAAG,GAAG,CAS7D;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,GAAG,CAY5D"}

package/dist/wrappers/openai-wrapper.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * OpenAI SDK wrapper - Drop-in replacement
+ *
+ * This wrapper allows you to use the official OpenAI SDK with LockLLM protection
+ * by simply changing how you initialize the client.
+ *
+ * @example
+ * ```typescript
+ * // Replace this:
+ * // import OpenAI from 'openai';
+ * // const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * // With this:
+ * import { createOpenAI } from '@lockllm/sdk/wrappers';
+ * const openai = createOpenAI({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * // Everything else stays the same!
+ * const response = await openai.chat.completions.create({
+ *   model: "gpt-4",
+ *   messages: [{ role: "user", content: "Hello!" }]
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOpenAIConstructor = getOpenAIConstructor;
+exports.createOpenAI = createOpenAI;
+/**
+ * Create an OpenAI client that routes through LockLLM proxy
+ *
+ * All requests are automatically scanned for prompt injection before being
+ * forwarded to OpenAI. Your OpenAI API key should be configured in the
+ * LockLLM dashboard at https://www.lockllm.com/dashboard
+ *
+ * @param config - Configuration options
+ * @returns OpenAI client instance
+ *
+ * @example
+ * ```typescript
+ * const openai = createOpenAI({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * const response = await openai.chat.completions.create({
+ *   model: "gpt-4",
+ *   messages: [{ role: "user", content: "Hello!" }]
+ * });
+ * ```
+ */
+/**
+ * Lazy-load OpenAI SDK constructor
+ * @internal - exposed for testing purposes
+ */
+function getOpenAIConstructor(requireFn = require) {
+    try {
+        const openaiModule = requireFn('openai');
+        return openaiModule.default || openaiModule.OpenAI || openaiModule;
+    }
+    catch (error) {
+        throw new Error('OpenAI SDK not found. Please install it with: npm install openai');
+    }
+}
+function createOpenAI(config) {
+    // Get OpenAI SDK constructor
+    const OpenAIConstructor = getOpenAIConstructor();
+    const { apiKey, baseURL, ...otherOptions } = config;
+    // Create OpenAI client with LockLLM proxy
+    return new OpenAIConstructor({
+        apiKey,
+        baseURL: baseURL || 'https://api.lockllm.com/v1/proxy/openai',
+        ...otherOptions,
+    });
+}
+//# sourceMappingURL=openai-wrapper.js.map

package/dist/wrappers/openai-wrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-wrapper.js","sourceRoot":"","sources":["../../src/wrappers/openai-wrapper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAqBH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,SAAS,GAAG,OAAO;IACtD,IAAI,CAAC;QACH,MAAM,YAAY,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;QACzC,OAAO,YAAY,CAAC,OAAO,IAAI,YAAY,CAAC,MAAM,IAAI,YAAY,CAAC;IACrE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,kEAAkE,CACnE,CAAC;IACJ,CAAC;AACH,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,MAA0B;IACrD,6BAA6B;IAC7B,MAAM,iBAAiB,GAAG,oBAAoB,EAAE,CAAC;IAEjD,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,YAAY,EAAC,GAAG,MAAM,CAAC;IAEnD,0CAA0C;IAC1C,OAAO,IAAI,iBAAiB,CAAC;QAC3B,MAAM;QACN,OAAO,EAAE,OAAO,IAAI,yCAAyC;QAC7D,GAAG,YAAY;KAChB,CAAC,CAAC;AACL,CAAC"}

package/dist/wrappers/openai-wrapper.mjs

@@ -0,0 +1,72 @@
+/**
+ * OpenAI SDK wrapper - Drop-in replacement
+ *
+ * This wrapper allows you to use the official OpenAI SDK with LockLLM protection
+ * by simply changing how you initialize the client.
+ *
+ * @example
+ * ```typescript
+ * // Replace this:
+ * // import OpenAI from 'openai';
+ * // const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * // With this:
+ * import { createOpenAI } from '@lockllm/sdk/wrappers';
+ * const openai = createOpenAI({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * // Everything else stays the same!
+ * const response = await openai.chat.completions.create({
+ *   model: "gpt-4",
+ *   messages: [{ role: "user", content: "Hello!" }]
+ * });
+ * ```
+ */
+/**
+ * Create an OpenAI client that routes through LockLLM proxy
+ *
+ * All requests are automatically scanned for prompt injection before being
+ * forwarded to OpenAI. Your OpenAI API key should be configured in the
+ * LockLLM dashboard at https://www.lockllm.com/dashboard
+ *
+ * @param config - Configuration options
+ * @returns OpenAI client instance
+ *
+ * @example
+ * ```typescript
+ * const openai = createOpenAI({
+ *   apiKey: process.env.LOCKLLM_API_KEY
+ * });
+ *
+ * const response = await openai.chat.completions.create({
+ *   model: "gpt-4",
+ *   messages: [{ role: "user", content: "Hello!" }]
+ * });
+ * ```
+ */
+/**
+ * Lazy-load OpenAI SDK constructor
+ * @internal - exposed for testing purposes
+ */
+export function getOpenAIConstructor(requireFn = require) {
+    try {
+        const openaiModule = requireFn('openai');
+        return openaiModule.default || openaiModule.OpenAI || openaiModule;
+    }
+    catch (error) {
+        throw new Error('OpenAI SDK not found. Please install it with: npm install openai');
+    }
+}
+export function createOpenAI(config) {
+    // Get OpenAI SDK constructor
+    const OpenAIConstructor = getOpenAIConstructor();
+    const { apiKey, baseURL, ...otherOptions } = config;
+    // Create OpenAI client with LockLLM proxy
+    return new OpenAIConstructor({
+        apiKey,
+        baseURL: baseURL || 'https://api.lockllm.com/v1/proxy/openai',
+        ...otherOptions,
+    });
+}
+//# sourceMappingURL=openai-wrapper.js.map

package/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@lockllm/sdk",
+  "version": "1.0.0",
+  "description": "Enterprise-grade AI security SDK providing real-time protection against prompt injection, jailbreaks, and adversarial attacks. Drop-in replacement for OpenAI, Anthropic, and 15+ providers with zero code changes. Includes REST API, proxy mode, browser extension, and webhook support. Free BYOK model with unlimited scanning.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./wrappers": {
+      "import": "./dist/wrappers/index.mjs",
+      "require": "./dist/wrappers/index.js",
+      "types": "./dist/wrappers/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
+    "CODE_OF_CONDUCT.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "npm run build:cjs && npm run build:esm && npm run build:fix-extensions",
+    "build:cjs": "tsc",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:fix-extensions": "node -e \"const fs=require('fs');const path=require('path');function rename(dir){fs.readdirSync(dir,{withFileTypes:true}).forEach(f=>{const p=path.join(dir,f.name);if(f.isDirectory())rename(p);else if(f.name.endsWith('.js')){fs.renameSync(p,p.replace(/\\.js$/,'.mjs'));}})}rename('dist-esm');fs.cpSync('dist-esm',path.join('dist'),{recursive:true});fs.rmSync('dist-esm',{recursive:true,force:true});\"",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build"
+  },
+  "keywords": [
+    "openai",
+    "anthropic",
+    "chatgpt",
+    "claude",
+    "llm",
+    "ai",
+    "proxy",
+    "security",
+    "prompt-injection",
+    "jailbreak",
+    "openai-sdk",
+    "anthropic-sdk",
+    "ai-security",
+    "llm-security",
+    "prompt-security",
+    "openai-proxy",
+    "chatgpt-api",
+    "gpt-5",
+    "claude-api",
+    "langchain",
+    "ai-gateway",
+    "llm-firewall",
+    "rag",
+    "agents",
+    "typescript",
+    "production"
+  ],
+  "author": "LockLLM",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lockllm/lockllm-npm"
+  },
+  "homepage": "https://lockllm.com",
+  "peerDependencies": {
+    "@anthropic-ai/sdk": "^0.20.0",
+    "cohere-ai": "^7.0.0",
+    "openai": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "openai": {
+      "optional": true
+    },
+    "@anthropic-ai/sdk": {
+      "optional": true
+    },
+    "cohere-ai": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@anthropic-ai/sdk": "^0.71.2",
+    "@types/node": "^20.19.30",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "@vitest/coverage-v8": "^1.0.0",
+    "cohere-ai": "^7.20.0",
+    "eslint": "^8.0.0",
+    "openai": "^6.16.0",
+    "prettier": "^3.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^1.0.0"
+  }
+}