openlit 1.0.0 → 1.2.0

package/README.md

@@ -6,7 +6,7 @@ OpenTelemetry Auto-Instrumentation for GenAI & LLM Applications</h1>
 
 [![OpenLIT](https://img.shields.io/badge/OpenLIT-orange)](https://github.com/openlit/openlit)
 [![License](https://img.shields.io/github/license/openlit/openlit?label=License&logo=github&color=f80&logoColor=white)](https://github.com/openlit/openlit/blob/main/LICENSE)
-[![Downloads](https://img.shields.io/npm/dm/%40openlit%2Fts)](https://www.npmjs.com/package/openlit)
+[![Downloads](https://img.shields.io/npm/dw/openlit)](https://www.npmjs.com/package/openlit)
 [![GitHub Last Commit](https://img.shields.io/github/last-commit/openlit/openlit)](https://github.com/openlit/openlit/pulse)
 [![GitHub Contributors](https://img.shields.io/github/contributors/openlit/openlit)](https://github.com/openlit/openlit/graphs/contributors)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openlit",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "homepage": "https://github.com/openlit/openlit#readme",
   "bugs": {
     "url": "https://github.com/openlit/openlit/issues",
@@ -53,8 +53,9 @@
     "@opentelemetry/sdk-trace-base": "^1.24.1",
     "@opentelemetry/sdk-trace-node": "^1.24.1",
     "@opentelemetry/semantic-conventions": "^1.24.1",
+    "cohere-ai": "^7.13.0",
     "js-tiktoken": "^1.0.12",
     "openai": "^4.47.1",
     "tiktoken": "^1.0.15"
   }
-}
+}

package/src/constant.ts

@@ -1,5 +1,6 @@
-export const SDK_NAME = "openlit";
-export const DEFAULT_ENVIRONMENT = "default";
-export const DEFAULT_APPLICATION_NAME = "default";
-export const INSTRUMENTATION_PREFIX = "@openlit";
-export const TELEMETRY_SDK_NAME = 'opentelemetry';
+export const SDK_NAME = 'openlit';
+export const DEFAULT_ENVIRONMENT = 'default';
+export const DEFAULT_APPLICATION_NAME = 'default';
+export const INSTRUMENTATION_PREFIX = '@openlit';
+export const TELEMETRY_SDK_NAME = 'opentelemetry';
+export const OPENLIT_URL = 'http://127.0.0.1:3000';

package/src/index.ts

@@ -9,8 +9,9 @@ import { OpenlitOptions } from './types';
 import Tracing from './tracing';
 import { DEFAULT_APPLICATION_NAME, DEFAULT_ENVIRONMENT, SDK_NAME } from './constant';
 import { SpanExporter } from '@opentelemetry/sdk-trace-base';
+import PromptHub from './prompt-hub';
 
-export default class Openlit {
+export default class Openlit extends PromptHub {
   static resource: Resource;
   static options: OpenlitOptions;
   static _sdk: NodeSDK;

package/src/instrumentation/anthropic/wrapper.ts

@@ -1,29 +1,11 @@
-import { Span, SpanKind, SpanStatusCode, Tracer, context, trace } from '@opentelemetry/api';
+import { Span, SpanKind, Tracer, context, trace } from '@opentelemetry/api';
 import OpenlitConfig from '../../config';
 import OpenLitHelper from '../../helpers';
 import SemanticConvention from '../../semantic-convention';
-import { SDK_NAME, TELEMETRY_SDK_NAME } from '../../constant';
+import BaseWrapper from '../base-wrapper';
 
-export default class AnthropicWrapper {
-  static setBaseSpanAttributes(
-    span: any,
-    { genAIEndpoint, model, user, cost, environment, applicationName }: any
-  ) {
-    span.setAttributes({
-      [TELEMETRY_SDK_NAME]: SDK_NAME,
-    });
-
-    span.setAttribute(TELEMETRY_SDK_NAME, SDK_NAME);
-    span.setAttribute(SemanticConvention.GEN_AI_SYSTEM, SemanticConvention.GEN_AI_SYSTEM_ANTHROPIC);
-    span.setAttribute(SemanticConvention.GEN_AI_ENDPOINT, genAIEndpoint);
-    span.setAttribute(SemanticConvention.GEN_AI_ENVIRONMENT, environment);
-    span.setAttribute(SemanticConvention.GEN_AI_APPLICATION_NAME, applicationName);
-    span.setAttribute(SemanticConvention.GEN_AI_REQUEST_MODEL, model);
-    span.setAttribute(SemanticConvention.GEN_AI_REQUEST_USER, user);
-    if (cost !== undefined) span.setAttribute(SemanticConvention.GEN_AI_USAGE_COST, cost);
-
-    span.setStatus({ code: SpanStatusCode.OK });
-  }
+export default class AnthropicWrapper extends BaseWrapper {
+  static aiSystem = SemanticConvention.GEN_AI_SYSTEM_ANTHROPIC;
 
   static _patchMessageCreate(tracer: Tracer): any {
     const genAIEndpoint = 'anthropic.resources.messages';
@@ -174,8 +156,6 @@ export default class AnthropicWrapper {
     result: any;
     span: Span;
   }) {
-    const applicationName = OpenlitConfig.applicationName;
-    const environment = OpenlitConfig.environment;
     const traceContent = OpenlitConfig.traceContent;
     const {
       messages,
@@ -234,8 +214,7 @@ export default class AnthropicWrapper {
       model,
       user,
       cost,
-      applicationName,
-      environment,
+      aiSystem: AnthropicWrapper.aiSystem,
     });
 
     // Request Params attributes : Start

package/src/instrumentation/base-wrapper.ts

@@ -0,0 +1,39 @@
+import OpenlitConfig from '../config';
+import { SDK_NAME, TELEMETRY_SDK_NAME } from '../constant';
+import SemanticConvention from '../semantic-convention';
+import { Span, SpanStatusCode } from '@opentelemetry/api';
+
+type BaseSpanAttributes = {
+  genAIEndpoint: string;
+  model: string;
+  user?: unknown;
+  cost?: number | string;
+  aiSystem: string;
+};
+
+export default class BaseWrapper {
+  static setBaseSpanAttributes(
+    span: Span,
+    { genAIEndpoint, model, user, cost, aiSystem }: BaseSpanAttributes
+  ) {
+    const applicationName = OpenlitConfig.applicationName!;
+    const environment = OpenlitConfig.environment!;
+
+    span.setAttributes({
+      [TELEMETRY_SDK_NAME]: SDK_NAME,
+    });
+
+    span.setAttribute(TELEMETRY_SDK_NAME, SDK_NAME);
+    span.setAttribute(SemanticConvention.GEN_AI_SYSTEM, aiSystem);
+    span.setAttribute(SemanticConvention.GEN_AI_ENDPOINT, genAIEndpoint);
+    span.setAttribute(SemanticConvention.GEN_AI_ENVIRONMENT, environment);
+    span.setAttribute(SemanticConvention.GEN_AI_APPLICATION_NAME, applicationName);
+    span.setAttribute(SemanticConvention.GEN_AI_REQUEST_MODEL, model);
+    span.setAttribute(SemanticConvention.GEN_AI_REQUEST_USER, user as any);
+    if (cost !== undefined) {
+      span.setAttribute(SemanticConvention.GEN_AI_USAGE_COST, cost);
+    }
+
+    span.setStatus({ code: SpanStatusCode.OK });
+  }
+}

package/src/instrumentation/cohere/index.ts

@@ -0,0 +1,79 @@
+import {
+  InstrumentationBase,
+  InstrumentationModuleDefinition,
+  InstrumentationNodeModuleDefinition,
+  isWrapped,
+} from '@opentelemetry/instrumentation';
+import { InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { INSTRUMENTATION_PREFIX } from '../../constant';
+import Cohere from 'cohere-ai';
+import CohereWrapper from './wrapper';
+
+export interface CohereInstrumentationConfig extends InstrumentationConfig {}
+
+export default class OpenlitCohereInstrumentation extends InstrumentationBase {
+  constructor(config: CohereInstrumentationConfig = {}) {
+    super(`${INSTRUMENTATION_PREFIX}/instrumentation-cohere-ai`, '1.0.0', config);
+  }
+
+  protected init(): void | InstrumentationModuleDefinition | InstrumentationModuleDefinition[] {
+    const module = new InstrumentationNodeModuleDefinition(
+      'cohere-ai',
+      ['>=7.2.0'],
+      (moduleExports) => {
+        this._patch(moduleExports);
+        return moduleExports;
+      },
+      (moduleExports) => {
+        if (moduleExports !== undefined) {
+          this._unpatch(moduleExports);
+        }
+      }
+    );
+    return [module];
+  }
+
+  public manualPatch(cohere: any): void {
+    this._patch(cohere);
+  }
+
+  protected _patch(moduleExports: typeof Cohere) {
+    try {
+      if (isWrapped(moduleExports.CohereClient.prototype.embed)) {
+        this._unwrap(moduleExports.CohereClient.prototype, 'embed');
+      }
+      if (isWrapped(moduleExports.CohereClient.prototype.chat)) {
+        this._unwrap(moduleExports.CohereClient.prototype, 'chat');
+      }
+      if (isWrapped(moduleExports.CohereClient.prototype.chatStream)) {
+        this._unwrap(moduleExports.CohereClient.prototype, 'chatStream');
+      }
+
+      this._wrap(
+        moduleExports.CohereClient.prototype,
+        'embed',
+        CohereWrapper._patchEmbed(this.tracer)
+      );
+
+      this._wrap(
+        moduleExports.CohereClient.prototype,
+        'chat',
+        CohereWrapper._patchChat(this.tracer)
+      );
+
+      this._wrap(
+        moduleExports.CohereClient.prototype,
+        'chatStream',
+        CohereWrapper._patchChatStream(this.tracer)
+      );
+    } catch (e) {
+      console.error('Error in _patch method:', e);
+    }
+  }
+
+  protected _unpatch(moduleExports: typeof Cohere) {
+    this._unwrap(moduleExports.CohereClient.prototype, 'embed');
+    this._unwrap(moduleExports.CohereClient.prototype, 'chat');
+    this._unwrap(moduleExports.CohereClient.prototype, 'chatStream');
+  }
+}

package/src/instrumentation/cohere/wrapper.ts

@@ -0,0 +1,286 @@
+import { Span, SpanKind, Tracer, context, trace } from '@opentelemetry/api';
+import OpenlitConfig from '../../config';
+import OpenLitHelper from '../../helpers';
+import SemanticConvention from '../../semantic-convention';
+import { SDK_NAME, TELEMETRY_SDK_NAME } from '../../constant';
+import BaseWrapper from '../base-wrapper';
+
+export default class CohereWrapper extends BaseWrapper {
+  static aiSystem = SemanticConvention.GEN_AI_SYSTEM_COHERE;
+  static _patchEmbed(tracer: Tracer): any {
+    const genAIEndpoint = 'cohere.embed';
+    const traceContent = OpenlitConfig.traceContent;
+
+    return (originalMethod: (...args: any[]) => any) => {
+      return async function (this: any, ...args: any[]) {
+        const span = tracer.startSpan(genAIEndpoint, { kind: SpanKind.CLIENT });
+        return context.with(trace.setSpan(context.active(), span), async () => {
+          try {
+            const response = await originalMethod.apply(this, args);
+            span.setAttributes({
+              [TELEMETRY_SDK_NAME]: SDK_NAME,
+            });
+
+            const model = response.model || 'embed-english-v2.0';
+            const pricingInfo = await OpenlitConfig.updatePricingJson(OpenlitConfig.pricing_json);
+            const cost = OpenLitHelper.getEmbedModelCost(
+              model,
+              pricingInfo,
+              response.meta.billedUnits.inputTokens
+            );
+
+            span.setAttribute(
+              SemanticConvention.GEN_AI_TYPE,
+              SemanticConvention.GEN_AI_TYPE_EMBEDDING
+            );
+
+            const { dimensions, encoding_format = 'float', input, user, texts = [] } = args[0];
+            // Set base span attribues
+            CohereWrapper.setBaseSpanAttributes(span, {
+              genAIEndpoint,
+              model,
+              user,
+              cost,
+              aiSystem: CohereWrapper.aiSystem,
+            });
+
+            // Request Params attributes : Start
+
+            span.setAttribute(SemanticConvention.GEN_AI_REQUEST_EMBEDDING_FORMAT, encoding_format);
+            span.setAttribute(SemanticConvention.GEN_AI_REQUEST_EMBEDDING_DIMENSION, dimensions);
+            if (traceContent) {
+              span.setAttribute(SemanticConvention.GEN_AI_CONTENT_PROMPT, JSON.stringify(texts));
+            }
+            // Request Params attributes : End
+
+            span.setAttribute(SemanticConvention.GEN_AI_RESPONSE_ID, response.id);
+
+            span.setAttribute(
+              SemanticConvention.GEN_AI_USAGE_PROMPT_TOKENS,
+              response.meta.billedUnits.inputTokens
+            );
+            span.setAttribute(
+              SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS,
+              response.meta.billedUnits.inputTokens
+            );
+
+            return response;
+          } catch (e: any) {
+            OpenLitHelper.handleException(span, e);
+          } finally {
+            span.end();
+          }
+        });
+      };
+    };
+  }
+
+  static _patchChat(tracer: Tracer): any {
+    const genAIEndpoint = 'cohere.chat';
+    return (originalMethod: (...args: any[]) => any) => {
+      return async function (this: any, ...args: any[]) {
+        const span = tracer.startSpan(genAIEndpoint, { kind: SpanKind.CLIENT });
+        return context
+          .with(trace.setSpan(context.active(), span), async () => {
+            return originalMethod.apply(this, args);
+          })
+          .then((response) => {
+            return CohereWrapper._chat({ args, genAIEndpoint, response, span });
+          })
+          .catch((e: any) => {
+            OpenLitHelper.handleException(span, e);
+            span.end();
+          });
+      };
+    };
+  }
+
+  static _patchChatStream(tracer: Tracer): any {
+    const genAIEndpoint = 'cohere.chat';
+    return (originalMethod: (...args: any[]) => any) => {
+      return async function (this: any, ...args: any[]) {
+        const span = tracer.startSpan(genAIEndpoint, { kind: SpanKind.CLIENT });
+        return context
+          .with(trace.setSpan(context.active(), span), async () => {
+            return originalMethod.apply(this, args);
+          })
+          .then((response) => {
+            return OpenLitHelper.createStreamProxy(
+              response,
+              CohereWrapper._chatGenerator({
+                args,
+                genAIEndpoint,
+                response,
+                span,
+              })
+            );
+          })
+          .catch((e: any) => {
+            OpenLitHelper.handleException(span, e);
+            span.end();
+          });
+      };
+    };
+  }
+
+  static async _chat({
+    args,
+    genAIEndpoint,
+    response,
+    span,
+  }: {
+    args: any[];
+    genAIEndpoint: string;
+    response: any;
+    span: Span;
+  }): Promise<any> {
+    try {
+      await CohereWrapper._chatCommonSetter({
+        args,
+        genAIEndpoint,
+        result: response,
+        span,
+        stream: false,
+      });
+      return response;
+    } catch (e: any) {
+      OpenLitHelper.handleException(span, e);
+    } finally {
+      span.end();
+    }
+  }
+
+  static async *_chatGenerator({
+    args,
+    genAIEndpoint,
+    response,
+    span,
+  }: {
+    args: any[];
+    genAIEndpoint: string;
+    response: any;
+    span: Span;
+  }): AsyncGenerator<unknown, any, unknown> {
+    try {
+      let result = {
+        response_id: '',
+        text: '',
+        generationId: '',
+        chatHistory: [],
+        finishReason: '',
+        meta: {
+          apiVersion: { version: '1' },
+          billedUnits: { inputTokens: 0, outputTokens: 0 },
+        },
+      };
+      for await (const chunk of response) {
+        if (chunk.eventType === 'stream-end') {
+          result = chunk.response;
+        }
+
+        yield chunk;
+      }
+
+      await CohereWrapper._chatCommonSetter({
+        args,
+        genAIEndpoint,
+        result,
+        span,
+        stream: true,
+      });
+
+      return result;
+    } catch (e: any) {
+      OpenLitHelper.handleException(span, e);
+    } finally {
+      span.end();
+    }
+  }
+
+  static async _chatCommonSetter({
+    args,
+    genAIEndpoint,
+    result,
+    span,
+    stream,
+  }: {
+    args: any[];
+    genAIEndpoint: string;
+    result: any;
+    span: Span;
+    stream: boolean;
+  }) {
+    const traceContent = OpenlitConfig.traceContent;
+    const {
+      message,
+      model = 'command-r-plus-08-2024',
+      frequency_penalty = 0,
+      max_tokens = null,
+      presence_penalty = 0,
+      seed = null,
+      temperature = 1,
+      user,
+      tools,
+    } = args[0];
+
+    // Request Params attributes : Start
+    span.setAttribute(SemanticConvention.GEN_AI_REQUEST_MAX_TOKENS, max_tokens);
+    span.setAttribute(SemanticConvention.GEN_AI_REQUEST_TEMPERATURE, temperature);
+    span.setAttribute(SemanticConvention.GEN_AI_REQUEST_PRESENCE_PENALTY, presence_penalty);
+    span.setAttribute(SemanticConvention.GEN_AI_REQUEST_FREQUENCY_PENALTY, frequency_penalty);
+    span.setAttribute(SemanticConvention.GEN_AI_REQUEST_SEED, seed);
+    span.setAttribute(SemanticConvention.GEN_AI_REQUEST_IS_STREAM, stream);
+
+    if (traceContent) {
+      span.setAttribute(SemanticConvention.GEN_AI_CONTENT_PROMPT, message);
+    }
+    // Request Params attributes : End
+
+    span.setAttribute(SemanticConvention.GEN_AI_TYPE, SemanticConvention.GEN_AI_TYPE_CHAT);
+
+    span.setAttribute(SemanticConvention.GEN_AI_RESPONSE_ID, result.response_id);
+
+    const pricingInfo = await OpenlitConfig.updatePricingJson(OpenlitConfig.pricing_json);
+
+    // Calculate cost of the operation
+    const cost = OpenLitHelper.getChatModelCost(
+      model,
+      pricingInfo,
+      result.meta.billedUnits.inputTokens,
+      result.meta.billedUnits.outputTokens
+    );
+
+    CohereWrapper.setBaseSpanAttributes(span, {
+      genAIEndpoint,
+      model,
+      user,
+      cost,
+      aiSystem: CohereWrapper.aiSystem,
+    });
+
+    span.setAttribute(
+      SemanticConvention.GEN_AI_USAGE_PROMPT_TOKENS,
+      result.meta.billedUnits.inputTokens
+    );
+    span.setAttribute(
+      SemanticConvention.GEN_AI_USAGE_COMPLETION_TOKENS,
+      result.meta.billedUnits.outputTokens
+    );
+    span.setAttribute(
+      SemanticConvention.GEN_AI_USAGE_TOTAL_TOKENS,
+      result.meta.billedUnits.inputTokens + result.meta.billedUnits.outputTokens
+    );
+
+    if (result.finishReason) {
+      span.setAttribute(SemanticConvention.GEN_AI_RESPONSE_FINISH_REASON, result.finishReason);
+    }
+
+    if (tools) {
+      span.setAttribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION, 'Function called with tools');
+    } else {
+      if (traceContent) {
+        span.setAttribute(SemanticConvention.GEN_AI_CONTENT_COMPLETION, result.text);
+      }
+    }
+  }
+}

package/src/instrumentation/index.ts

@@ -4,11 +4,13 @@ import { InstrumentationType, OpenlitInstrumentations } from '../types';
 import { TracerProvider } from '@opentelemetry/api';
 import OpenAIInstrumentation from './openai';
 import AnthropicInstrumentation from './anthropic';
+import CohereInstrumentation from './cohere';
 
 export default class Instrumentations {
   static availableInstrumentations: OpenlitInstrumentations = {
     openai: new OpenAIInstrumentation(),
     anthropic: new AnthropicInstrumentation(),
+    cohere: new CohereInstrumentation(),
   };
 
   static setup(

package/src/instrumentation/openai/wrapper.ts

@@ -1,30 +1,11 @@
-import { Span, SpanKind, SpanStatusCode, Tracer, context, trace } from '@opentelemetry/api';
+import { Span, SpanKind, Tracer, context, trace } from '@opentelemetry/api';
 import OpenlitConfig from '../../config';
 import OpenLitHelper from '../../helpers';
 import SemanticConvention from '../../semantic-convention';
-import { SDK_NAME, TELEMETRY_SDK_NAME } from '../../constant';
-
-export default class OpenAIWrapper {
-  static setBaseSpanAttributes(
-    span: any,
-    { genAIEndpoint, model, user, cost, environment, applicationName }: any
-  ) {
-    span.setAttributes({
-      [TELEMETRY_SDK_NAME]: SDK_NAME,
-    });
-
-    span.setAttribute(TELEMETRY_SDK_NAME, SDK_NAME);
-    span.setAttribute(SemanticConvention.GEN_AI_SYSTEM, SemanticConvention.GEN_AI_SYSTEM_OPENAI);
-    span.setAttribute(SemanticConvention.GEN_AI_ENDPOINT, genAIEndpoint);
-    span.setAttribute(SemanticConvention.GEN_AI_ENVIRONMENT, environment);
-    span.setAttribute(SemanticConvention.GEN_AI_APPLICATION_NAME, applicationName);
-    span.setAttribute(SemanticConvention.GEN_AI_REQUEST_MODEL, model);
-    span.setAttribute(SemanticConvention.GEN_AI_REQUEST_USER, user);
-    if (cost !== undefined) span.setAttribute(SemanticConvention.GEN_AI_USAGE_COST, cost);
-
-    span.setStatus({ code: SpanStatusCode.OK });
-  }
+import BaseWrapper from '../base-wrapper';
 
+export default class OpenAIWrapper extends BaseWrapper {
+  static aiSystem = SemanticConvention.GEN_AI_SYSTEM_OPENAI;
   static _patchChatCompletionCreate(tracer: Tracer): any {
     const genAIEndpoint = 'openai.resources.chat.completions';
     return (originalMethod: (...args: any[]) => any) => {
@@ -184,8 +165,6 @@ export default class OpenAIWrapper {
     result: any;
     span: Span;
   }) {
-    const applicationName = OpenlitConfig.applicationName;
-    const environment = OpenlitConfig.environment;
     const traceContent = OpenlitConfig.traceContent;
     const {
       messages,
@@ -261,8 +240,7 @@ export default class OpenAIWrapper {
       model,
       user,
       cost,
-      applicationName,
-      environment,
+      aiSystem: OpenAIWrapper.aiSystem,
     });
 
     span.setAttribute(SemanticConvention.GEN_AI_USAGE_PROMPT_TOKENS, result.usage.prompt_tokens);
@@ -302,8 +280,6 @@ export default class OpenAIWrapper {
 
   static _patchEmbedding(tracer: Tracer): any {
     const genAIEndpoint = 'openai.resources.embeddings';
-    const applicationName = OpenlitConfig.applicationName;
-    const environment = OpenlitConfig.environment;
     const traceContent = OpenlitConfig.traceContent;
 
     return (originalMethod: (...args: any[]) => any) => {
@@ -312,9 +288,6 @@ export default class OpenAIWrapper {
         return context.with(trace.setSpan(context.active(), span), async () => {
           try {
             const response = await originalMethod.apply(this, args);
-            span.setAttributes({
-              [TELEMETRY_SDK_NAME]: SDK_NAME,
-            });
 
             const model = response.model || 'text-embedding-ada-002';
             const pricingInfo = await OpenlitConfig.updatePricingJson(OpenlitConfig.pricing_json);
@@ -336,8 +309,7 @@ export default class OpenAIWrapper {
               model,
               user,
               cost,
-              applicationName,
-              environment,
+              aiSystem: OpenAIWrapper.aiSystem,
             });
 
             // Request Params attributes : Start
@@ -371,8 +343,6 @@ export default class OpenAIWrapper {
 
   static _patchFineTune(tracer: Tracer): any {
     const genAIEndpoint = 'openai.resources.fine_tuning.jobs';
-    const applicationName = OpenlitConfig.applicationName;
-    const environment = OpenlitConfig.environment;
 
     return (originalMethod: (...args: any[]) => any) => {
       return async function (this: any, ...args: any[]) {
@@ -380,9 +350,6 @@ export default class OpenAIWrapper {
         return context.with(trace.setSpan(context.active(), span), async () => {
           try {
             const response = await originalMethod.apply(this, args);
-            span.setAttributes({
-              [TELEMETRY_SDK_NAME]: SDK_NAME,
-            });
 
             const model = response.model || 'gpt-3.5-turbo';
             const {
@@ -398,8 +365,7 @@ export default class OpenAIWrapper {
               genAIEndpoint,
               model,
               user,
-              applicationName,
-              environment,
+              aiSystem: OpenAIWrapper.aiSystem,
             });
 
             span.setAttribute(
@@ -446,8 +412,6 @@ export default class OpenAIWrapper {
 
   static _patchImageGenerate(tracer: Tracer): any {
     const genAIEndpoint = 'openai.resources.images';
-    const applicationName = OpenlitConfig.applicationName;
-    const environment = OpenlitConfig.environment;
     const traceContent = OpenlitConfig.traceContent;
     return (originalMethod: (...args: any[]) => any) => {
       return async function (this: any, ...args: any[]) {
@@ -481,8 +445,7 @@ export default class OpenAIWrapper {
               model,
               user,
               cost,
-              applicationName,
-              environment,
+              aiSystem: OpenAIWrapper.aiSystem,
             });
 
             // Request Params attributes : Start
@@ -524,8 +487,6 @@ export default class OpenAIWrapper {
 
   static _patchImageVariation(tracer: Tracer): any {
     const genAIEndpoint = 'openai.resources.images';
-    const applicationName = OpenlitConfig.applicationName;
-    const environment = OpenlitConfig.environment;
     const traceContent = OpenlitConfig.traceContent;
     return (originalMethod: (...args: any[]) => any) => {
       return async function (this: any, ...args: any[]) {
@@ -560,8 +521,7 @@ export default class OpenAIWrapper {
               model,
               user,
               cost,
-              applicationName,
-              environment,
+              aiSystem: OpenAIWrapper.aiSystem,
             });
 
             // Request Params attributes : Start
@@ -602,8 +562,6 @@ export default class OpenAIWrapper {
 
   static _patchAudioCreate(tracer: Tracer): any {
     const genAIEndpoint = 'openai.resources.audio.speech';
-    const applicationName = OpenlitConfig.applicationName;
-    const environment = OpenlitConfig.environment;
     const traceContent = OpenlitConfig.traceContent;
     return (originalMethod: (...args: any[]) => any) => {
       return async function (this: any, ...args: any[]) {
@@ -628,8 +586,7 @@ export default class OpenAIWrapper {
               model,
               user,
               cost,
-              applicationName,
-              environment,
+              aiSystem: OpenAIWrapper.aiSystem,
             });
 
             // Request Params attributes : Start

package/src/prompt-hub.ts

@@ -0,0 +1,64 @@
+import OpenlitConfig from './config';
+import { OPENLIT_URL } from './constant';
+import { PromptHubOptions } from './types';
+
+export default class PromptHub {
+  static async getPrompts(options: PromptHubOptions) {
+    const url = process.env.OPENLIT_URL || options.url || OPENLIT_URL;
+    const apiKey = process.env.OPENLIT_API_KEY || options.apiKey || '';
+    let metaProperties = {
+      applicationName: OpenlitConfig.applicationName,
+      environment: OpenlitConfig.environment,
+    };
+    if (
+      options.metaProperties &&
+      typeof options.metaProperties === 'object' &&
+      !Array.isArray(options.metaProperties)
+    ) {
+      metaProperties = {
+        ...metaProperties,
+        ...options.metaProperties,
+      };
+    }
+
+    try {
+      return await fetch(`${url}/api/prompt/get-compiled`, {
+        method: 'POST',
+        body: JSON.stringify({
+          name: options.name,
+          version: options.version,
+          shouldCompile: !!options.shouldCompile,
+          variables: options.variables || {},
+          id: options.promptId,
+          metaProperties,
+          source: 'ts-sdk',
+        }),
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+        },
+      })
+        .then(async (response) => {
+          if (!response.ok) {
+            return {
+              err: `Openlit Error : HTTP error! Status: ${response.status}`,
+            };
+          }
+          return response.json();
+        })
+        .then((resp: any) => {
+          return resp;
+        });
+    } catch (e: any) {
+      if (e && typeof e.toString === 'function') {
+        return {
+          err: `Openlit Error : ${e.toString()}`,
+          data: null,
+        };
+      }
+
+      return {
+        err: `Openlit Error : ${e}`,
+      };
+    }
+  }
+}

package/src/types.ts

@@ -2,7 +2,7 @@
 import { Resource } from '@opentelemetry/resources';
 import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
 
-export type InstrumentationType = 'openai' | 'anthropic';
+export type InstrumentationType = 'openai' | 'anthropic' | 'cohere';
 
 export type OpenlitInstrumentations = Partial<Record<InstrumentationType, any>>;
 
@@ -46,3 +46,14 @@ export type OpenlitOptions = {
 export type SetupTracerOptions = OpenlitOptions & {
   resource: Resource;
 };
+
+export type PromptHubOptions = {
+  url?: string;
+  apiKey?: string;
+  name?: string;
+  version?: string;
+  shouldCompile?: boolean;
+  variables?: Record<string, any>;
+  promptId?: string;
+  metaProperties?: Record<string, any>;
+};