openlayer 0.22.2 → 0.23.1

package/src/lib/integrations/openAiTracer.ts

@@ -2,13 +2,15 @@ import OpenAI from 'openai';
 import { Stream } from 'openai/streaming';
 import performanceNow from 'performance-now';
 import { addChatCompletionStepToTrace } from '../tracing/tracer';
+import type { ResponseStreamEvent } from 'openai/resources/responses/responses';
 
 export function traceOpenAI(openai: OpenAI): OpenAI {
-  const createFunction = openai.chat.completions.create;
+  // Wrap Chat Completions API
+  const chatCreateFunction = openai.chat.completions.create;
 
   openai.chat.completions.create = async function (
     this: typeof openai.chat.completions,
-    ...args: Parameters<typeof createFunction>
+    ...args: Parameters<typeof chatCreateFunction>
   ): Promise<Stream<OpenAI.Chat.Completions.ChatCompletionChunk> | OpenAI.Chat.Completions.ChatCompletion> {
     const [params, options] = args;
     const stream = params?.stream ?? false;
@@ -17,7 +19,7 @@ export function traceOpenAI(openai: OpenAI): OpenAI {
       const startTime = performanceNow();
 
       // Call the original `create` function
-      let response = await createFunction.apply(this, args);
+      let response = await chatCreateFunction.apply(this, args);
 
       if (stream) {
         // Handle streaming responses
@@ -114,7 +116,150 @@ export function traceOpenAI(openai: OpenAI): OpenAI {
     }
     // Ensure a return statement is present
     return undefined as any;
-  } as typeof createFunction;
+  } as typeof chatCreateFunction;
+
+  // Wrap Responses API (only if available)
+  if (!openai.responses) {
+    return openai;
+  }
+  const responsesCreateFunction = openai.responses.create;
+
+  openai.responses.create = async function (
+    this: typeof openai.responses,
+    ...args: Parameters<typeof responsesCreateFunction>
+  ): Promise<Stream<ResponseStreamEvent> | OpenAI.Responses.Response> {
+    const [params, options] = args;
+    const stream = params?.stream ?? false;
+
+    try {
+      const startTime = performanceNow();
+
+      // Call the original `create` function
+      let response = await responsesCreateFunction.apply(this, args);
+
+      if (stream) {
+        // Handle streaming responses
+        const chunks: ResponseStreamEvent[] = [];
+        let collectedOutputData: any[] = [];
+        let firstTokenTime: number | undefined;
+        let completionTokens: number = 0;
+        if (isAsyncIterable(response)) {
+          async function* tracedOutputGenerator(): AsyncGenerator<ResponseStreamEvent, void, unknown> {
+            for await (const rawChunk of response as AsyncIterable<ResponseStreamEvent>) {
+              if (chunks.length === 0) {
+                firstTokenTime = performanceNow();
+              }
+              chunks.push(rawChunk);
+
+              // Handle different event types
+              if (rawChunk.type === 'response.output_text.delta') {
+                if ('delta' in rawChunk && rawChunk.delta) {
+                  collectedOutputData.push(rawChunk.delta);
+                }
+              } else if (rawChunk.type === 'response.function_call_arguments.delta') {
+                if ('delta' in rawChunk && rawChunk.delta) {
+                  collectedOutputData.push(rawChunk.delta);
+                }
+              } else if (rawChunk.type === 'response.completed') {
+                // Extract final response data
+                if ('response' in rawChunk && rawChunk.response) {
+                  const finalResponse = rawChunk.response;
+                  completionTokens = finalResponse.usage?.output_tokens ?? 0;
+                }
+              }
+
+              yield rawChunk;
+            }
+            const endTime = performanceNow();
+
+            // Find the final response from chunks
+            const doneChunk = chunks.find((c) => c.type === 'response.completed');
+            const finalResponse = doneChunk && 'response' in doneChunk ? (doneChunk as any).response : null;
+
+            const traceData = {
+              name: 'OpenAI Response',
+              inputs: { prompt: params.input },
+              output: collectedOutputData.join(''),
+              latency: endTime - startTime,
+              model: finalResponse?.model ?? params.model,
+              modelParameters: getResponsesModelParameters(args),
+              metadata: { timeToFistToken: firstTokenTime ? firstTokenTime - startTime : null },
+              provider: 'OpenAI',
+              completionTokens: finalResponse?.usage?.output_tokens ?? completionTokens,
+              promptTokens: finalResponse?.usage?.input_tokens ?? 0,
+              tokens: finalResponse?.usage?.total_tokens ?? completionTokens,
+              startTime: startTime,
+              endTime: endTime,
+            };
+            addChatCompletionStepToTrace(traceData);
+          }
+          return tracedOutputGenerator() as unknown as Stream<ResponseStreamEvent>;
+        }
+      } else {
+        // Handle non-streaming responses
+        response = response as OpenAI.Responses.Response;
+        const endTime = performanceNow();
+
+        // Extract output from the response
+        let output: string = response.output_text ?? '';
+
+        // If output_text is empty, try to extract from output array
+        if (!output && response.output && response.output.length > 0) {
+          const outputItems: string[] = [];
+
+          for (const outputItem of response.output) {
+            if (outputItem && 'type' in outputItem) {
+              if (outputItem.type === 'message' && 'content' in outputItem) {
+                // Extract text from message content
+                const content = outputItem.content;
+                if (Array.isArray(content)) {
+                  const textContent = content
+                    .filter((c: any) => c.type === 'output_text')
+                    .map((c: any) => c.text)
+                    .join('');
+                  if (textContent) {
+                    outputItems.push(textContent);
+                  }
+                }
+              } else if (outputItem.type === 'function_call') {
+                // Extract function call details - Responses API format
+                const functionCall = {
+                  name: (outputItem as any).name,
+                  arguments: (outputItem as any).arguments,
+                };
+                outputItems.push(JSON.stringify(functionCall, null, 2));
+              }
+            }
+          }
+
+          output = outputItems.join('\n');
+        }
+
+        const traceData = {
+          name: 'OpenAI Response',
+          inputs: { prompt: params.input },
+          output: output,
+          latency: endTime - startTime,
+          tokens: response.usage?.total_tokens ?? null,
+          promptTokens: response.usage?.input_tokens ?? null,
+          completionTokens: response.usage?.output_tokens ?? null,
+          model: response.model,
+          modelParameters: getResponsesModelParameters(args),
+          metadata: {},
+          provider: 'OpenAI',
+          startTime: startTime,
+          endTime: endTime,
+        };
+        addChatCompletionStepToTrace(traceData);
+        return response;
+      }
+    } catch (error) {
+      console.error('Failed to trace the create response request with Openlayer', error);
+      throw error;
+    }
+    // Ensure a return statement is present
+    return undefined as any;
+  } as typeof responsesCreateFunction;
 
   return openai;
 }
@@ -136,5 +281,16 @@ function getModelParameters(args: any): Record<string, any> {
   };
 }
 
+function getResponsesModelParameters(args: any): Record<string, any> {
+  const params = args[0];
+  return {
+    max_output_tokens: params?.max_output_tokens ?? null,
+    temperature: params?.temperature ?? null,
+    top_p: params?.top_p ?? null,
+    parallel_tool_calls: params?.parallel_tool_calls ?? null,
+    tool_choice: params?.tool_choice ?? null,
+  };
+}
+
 const isAsyncIterable = (x: any) =>
   x != null && typeof x === 'object' && typeof x[Symbol.asyncIterator] === 'function';

package/src/lib/tracing/tracer.ts

@@ -14,11 +14,22 @@ import Openlayer from '../../index';
 
 let currentTrace: Trace | null = null;
 
-const publish = process.env['OPENLAYER_DISABLE_PUBLISH'] != 'true';
+// Lazy-initialized Openlayer client to ensure environment variables are loaded
 let client: Openlayer | null = null;
-if (publish) {
-  console.debug('Publishing is enabled');
-  client = new Openlayer();
+let clientInitialized = false;
+
+function getOpenlayerClient(): Openlayer | null {
+  if (clientInitialized) {
+    return client;
+  }
+  clientInitialized = true;
+
+  const publish = process.env['OPENLAYER_DISABLE_PUBLISH'] !== 'true';
+  if (publish) {
+    console.debug('Publishing is enabled');
+    client = new Openlayer();
+  }
+  return client;
 }
 
 export function getCurrentTrace(): Trace | null {
@@ -85,10 +96,11 @@ function createStep(
       // Post process trace and get the input variable names
       const { traceData: processedTraceData, inputVariableNames } = postProcessTrace(traceData!);
 
-      if (publish && inferencePipelineId) {
+      const openlayerClient = getOpenlayerClient();
+      if (openlayerClient && inferencePipelineId) {
         console.debug('Uploading trace to Openlayer...');
 
-        client!.inferencePipelines.data
+        openlayerClient.inferencePipelines.data
           .stream(inferencePipelineId, {
             config: {
               outputColumnName: 'output',
@@ -121,8 +133,8 @@ function createStep(
             );
           });
       } else {
-        if (!publish) {
-          console.debug('Trace upload disabled (OPENLAYER_DISABLE_PUBLISH=true)');
+        if (!openlayerClient) {
+          console.debug('Trace upload disabled (OPENLAYER_DISABLE_PUBLISH=true or missing API key)');
         } else if (!inferencePipelineId) {
           console.warn('Trace upload skipped: OPENLAYER_INFERENCE_PIPELINE_ID environment variable not set');
         }

package/src/resources/index.ts

@@ -5,8 +5,10 @@ export {
   InferencePipelines,
   type InferencePipelineRetrieveResponse,
   type InferencePipelineUpdateResponse,
+  type InferencePipelineRetrieveUsersResponse,
   type InferencePipelineRetrieveParams,
   type InferencePipelineUpdateParams,
+  type InferencePipelineRetrieveUsersParams,
 } from './inference-pipelines/inference-pipelines';
 export {
   Projects,

package/src/resources/inference-pipelines/index.ts

@@ -5,8 +5,10 @@ export {
   InferencePipelines,
   type InferencePipelineRetrieveResponse,
   type InferencePipelineUpdateResponse,
+  type InferencePipelineRetrieveUsersResponse,
   type InferencePipelineRetrieveParams,
   type InferencePipelineUpdateParams,
+  type InferencePipelineRetrieveUsersParams,
 } from './inference-pipelines';
 export { Rows, type RowUpdateResponse, type RowUpdateParams } from './rows';
 export { TestResults, type TestResultListResponse, type TestResultListParams } from './test-results';

package/src/resources/inference-pipelines/inference-pipelines.ts

@@ -71,6 +71,29 @@ export class InferencePipelines extends APIResource {
       headers: buildHeaders([{ Accept: '*/*' }, options?.headers]),
     });
   }
+
+  /**
+   * Get aggregated user data for an inference pipeline with pagination and metadata.
+   *
+   * Returns a list of users who have interacted with the inference pipeline,
+   * including their activity statistics such as session counts, record counts, token
+   * usage, and costs.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.inferencePipelines.retrieveUsers(
+   *     '182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e',
+   *   );
+   * ```
+   */
+  retrieveUsers(
+    inferencePipelineID: string,
+    query: InferencePipelineRetrieveUsersParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<InferencePipelineRetrieveUsersResponse> {
+    return this._client.get(path`/inference-pipelines/${inferencePipelineID}/users`, { query, ...options });
+  }
 }
 
 export interface InferencePipelineRetrieveResponse {
@@ -809,6 +832,52 @@ export namespace InferencePipelineUpdateResponse {
   }
 }
 
+export interface InferencePipelineRetrieveUsersResponse {
+  /**
+   * Array of user aggregation data
+   */
+  items: Array<InferencePipelineRetrieveUsersResponse.Item>;
+}
+
+export namespace InferencePipelineRetrieveUsersResponse {
+  export interface Item {
+    /**
+     * The unique user identifier
+     */
+    id: string;
+
+    /**
+     * Total cost for this user
+     */
+    cost: number;
+
+    /**
+     * Timestamp of the user's first event/trace
+     */
+    dateOfFirstRecord: string;
+
+    /**
+     * Timestamp of the user's last event/trace
+     */
+    dateOfLastRecord: string;
+
+    /**
+     * Total number of traces/rows for this user
+     */
+    records: number;
+
+    /**
+     * Count of unique sessions for this user
+     */
+    sessions: number;
+
+    /**
+     * Total token count for this user
+     */
+    tokens: number;
+  }
+}
+
 export interface InferencePipelineRetrieveParams {
   /**
    * Expand specific nested objects.
@@ -834,6 +903,18 @@ export interface InferencePipelineUpdateParams {
   referenceDatasetUri?: string | null;
 }
 
+export interface InferencePipelineRetrieveUsersParams {
+  /**
+   * The page to return in a paginated query.
+   */
+  page?: number;
+
+  /**
+   * Maximum number of items to return per page.
+   */
+  perPage?: number;
+}
+
 InferencePipelines.Data = Data;
 InferencePipelines.Rows = Rows;
 InferencePipelines.TestResults = TestResults;
@@ -842,8 +923,10 @@ export declare namespace InferencePipelines {
   export {
     type InferencePipelineRetrieveResponse as InferencePipelineRetrieveResponse,
     type InferencePipelineUpdateResponse as InferencePipelineUpdateResponse,
+    type InferencePipelineRetrieveUsersResponse as InferencePipelineRetrieveUsersResponse,
     type InferencePipelineRetrieveParams as InferencePipelineRetrieveParams,
     type InferencePipelineUpdateParams as InferencePipelineUpdateParams,
+    type InferencePipelineRetrieveUsersParams as InferencePipelineRetrieveUsersParams,
   };
 
   export {

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.22.2'; // x-release-please-version
+export const VERSION = '0.23.1'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.22.2";
+export declare const VERSION = "0.23.1";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.22.2";
+export declare const VERSION = "0.23.1";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.22.2'; // x-release-please-version
+exports.VERSION = '0.23.1'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.22.2'; // x-release-please-version
+export const VERSION = '0.23.1'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map