promptlayer 1.0.61 → 1.2.0

package/.github/workflows/node.js.yml

@@ -1,30 +0,0 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run lint across different versions of node
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
-
-name: Node.js CI
-
-on:
-  push:
-    branches: ["master"]
-  pull_request:
-    branches: ["master"]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [18.x, 20.x, 22.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v3
-        with:
-          node-version: ${{ matrix.node-version }}
-          cache: "npm"
-      - run: npm ci
-      - run: npm test
-      - run: npm run lint && npm run build

package/.github/workflows/npm-publish.yml

@@ -1,35 +0,0 @@
-# This workflow will publish a package to NPM when a release is created
-# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
-
-name: Node.js Package
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-          cache: "npm"
-      - run: npm ci
-      - run: npm run lint && npm run build
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v3
-        with:
-          node-version: 16
-          registry-url: https://registry.npmjs.org/
-          cache: "npm"
-      - run: npm ci
-      - run: npm run release
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/src/groups.ts

@@ -1,16 +0,0 @@
-import { promptLayerCreateGroup } from "@/utils/utils";
-
-export class GroupManager {
-  apiKey: string;
-  baseURL: string;
-  throwOnError: boolean;
-
-  constructor(apiKey: string, baseURL: string, throwOnError: boolean = true) {
-    this.apiKey = apiKey;
-    this.baseURL = baseURL;
-    this.throwOnError = throwOnError;
-  }
-
-  create = () =>
-    promptLayerCreateGroup(this.apiKey, this.baseURL, this.throwOnError);
-}

package/src/index.ts

@@ -1,383 +0,0 @@
-import { GroupManager } from "@/groups";
-import { promptLayerBase } from "@/promptlayer";
-import { wrapWithSpan } from "@/span-wrapper";
-import { TemplateManager } from "@/templates";
-import { getTracer, setupTracing } from "@/tracing";
-import { TrackManager } from "@/track";
-import {
-  GetPromptTemplateParams,
-  LogRequest,
-  RunRequest,
-  WorkflowRequest,
-  WorkflowResponse,
-} from "@/types";
-import {
-  amazonBedrockRequest,
-  anthropicBedrockRequest,
-  anthropicRequest,
-  azureOpenAIRequest,
-  configureProviderSettings,
-  getProviderConfig,
-  googleRequest,
-  mistralRequest,
-  openaiRequest,
-  readEnv,
-  runWorkflowRequest,
-  trackRequest,
-  utilLogRequest,
-  vertexaiRequest,
-} from "@/utils/utils";
-import { categorizeError } from "@/utils/errors";
-import { streamResponse } from "@/utils/streaming";
-import * as opentelemetry from "@opentelemetry/api";
-
-const MAP_PROVIDER_TO_FUNCTION: Record<string, any> = {
-  openai: openaiRequest,
-  anthropic: anthropicRequest,
-  "openai.azure": azureOpenAIRequest,
-  google: googleRequest,
-  vertexai: vertexaiRequest,
-  "amazon.bedrock": amazonBedrockRequest,
-  "anthropic.bedrock": anthropicBedrockRequest,
-  mistral: mistralRequest,
-};
-
-export interface ClientOptions {
-  apiKey?: string;
-  enableTracing?: boolean;
-  workspaceId?: number;
-  throwOnError?: boolean;
-  baseURL?: string;
-}
-
-const isWorkflowResultsDict = (obj: any): boolean => {
-  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
-    return false;
-  }
-
-  const REQUIRED_KEYS = [
-    "status",
-    "value",
-    "error_message",
-    "raw_error_message",
-    "is_output_node",
-  ];
-  const values = Object.values(obj);
-
-  return values.every((val) => {
-    if (typeof val !== "object" || val === null) return false;
-    return REQUIRED_KEYS.every((key) => key in val);
-  });
-};
-
-export class PromptLayer {
-  apiKey: string;
-  baseURL: string;
-  templates: TemplateManager;
-  group: GroupManager;
-  track: TrackManager;
-  enableTracing: boolean;
-  throwOnError: boolean;
-  wrapWithSpan: typeof wrapWithSpan;
-
-  constructor({
-    apiKey = readEnv("PROMPTLAYER_API_KEY"),
-    baseURL = readEnv("PROMPTLAYER_BASE_URL"),
-    enableTracing = false,
-    throwOnError = true,
-  }: ClientOptions = {}) {
-    if (apiKey === undefined) {
-      throw new Error(
-        "PromptLayer API key not provided. Please set the PROMPTLAYER_API_KEY environment variable or pass the api_key parameter."
-      );
-    }
-
-    this.apiKey = apiKey;
-    this.baseURL = baseURL || "https://api.promptlayer.com";
-    this.enableTracing = enableTracing;
-    this.throwOnError = throwOnError;
-    this.templates = new TemplateManager(
-      apiKey,
-      this.baseURL,
-      this.throwOnError
-    );
-    this.group = new GroupManager(apiKey, this.baseURL, this.throwOnError);
-    this.track = new TrackManager(apiKey, this.baseURL, this.throwOnError);
-    this.wrapWithSpan = wrapWithSpan;
-
-    if (enableTracing) {
-      setupTracing(enableTracing, apiKey, this.baseURL);
-    }
-  }
-
-  get Anthropic() {
-    try {
-      const module = require("@anthropic-ai/sdk").default;
-      return promptLayerBase(
-        this.apiKey,
-        this.baseURL,
-        module,
-        "anthropic",
-        "anthropic"
-      );
-    } catch (e) {
-      console.error(
-        "To use the Anthropic module, you must install the @anthropic-ai/sdk package."
-      );
-    }
-  }
-
-  get OpenAI() {
-    try {
-      const module = require("openai").default;
-      return promptLayerBase(
-        this.apiKey,
-        this.baseURL,
-        module,
-        "openai",
-        "openai"
-      );
-    } catch (e) {
-      console.error(
-        "To use the OpenAI module, you must install the @openai/api package."
-      );
-    }
-  }
-
-  async run({
-    promptName,
-    promptVersion,
-    promptReleaseLabel,
-    inputVariables,
-    tags,
-    metadata,
-    groupId,
-    modelParameterOverrides,
-    stream = false,
-    provider,
-    model,
-  }: RunRequest) {
-    const tracer = getTracer();
-
-    return tracer.startActiveSpan("PromptLayer Run", async (span) => {
-      try {
-        const functionInput = {
-          promptName,
-          promptVersion,
-          promptReleaseLabel,
-          inputVariables,
-          tags,
-          metadata,
-          groupId,
-          modelParameterOverrides,
-          stream,
-        };
-        span.setAttribute("function_input", JSON.stringify(functionInput));
-
-        const prompt_input_variables = inputVariables;
-        const templateGetParams: GetPromptTemplateParams = {
-          label: promptReleaseLabel,
-          version: promptVersion,
-          metadata_filters: metadata,
-          provider,
-          model,
-          model_parameter_overrides: modelParameterOverrides,
-        };
-        if (inputVariables) templateGetParams.input_variables = inputVariables;
-
-        const promptBlueprint = await this.templates.get(
-          promptName,
-          templateGetParams
-        );
-
-        if (!promptBlueprint) {
-          throw new Error(
-            `Cannot proceed: prompt template '${promptName}' could not be fetched. ` +
-              `Check the warnings above for the actual error.`
-          );
-        }
-
-        const promptTemplate = promptBlueprint.prompt_template;
-        if (!promptBlueprint!.llm_kwargs) {
-          const errorMessage = `Prompt '${promptName}' does not have any LLM kwargs associated with it. Please set your model parameters in the registry in the PromptLayer dashboard.`;
-          if (this.throwOnError) {
-            throw new Error(errorMessage);
-          } else {
-            console.warn(`WARNING: ${errorMessage}`);
-          }
-        }
-
-        const promptBlueprintMetadata = promptBlueprint!.metadata;
-        if (!promptBlueprintMetadata) {
-          throw new Error(
-            `Prompt '${promptName}' does not have any metadata associated with it.`
-          );
-        }
-
-        const promptBlueprintModel = promptBlueprintMetadata.model;
-        if (!promptBlueprintModel) {
-          throw new Error(
-            `Prompt '${promptName}' does not have a model parameters associated with it.`
-          );
-        }
-
-        const customProvider = promptBlueprint!.custom_provider;
-        const request_start_time = new Date().toISOString();
-
-        const { provider_type, kwargs } = configureProviderSettings(
-          promptBlueprint,
-          customProvider,
-          modelParameterOverrides,
-          stream
-        );
-
-        let provider_type_config = provider_type;
-        if (provider_type === "openai" || provider_type === "openai.azure") {
-          const api_type = promptBlueprintModel.api_type;
-          provider_type_config = `${provider_type}:${api_type}`;
-        }
-
-        if (promptBlueprintModel.name.startsWith("gemini")) {
-          provider_type_config = "google";
-        } else if (promptBlueprintModel.name.startsWith("claude")) {
-          provider_type_config = "anthropic";
-        }
-
-        const config = getProviderConfig(provider_type_config, promptTemplate);
-        const { function_name, stream_function } = config;
-
-        const request_function = MAP_PROVIDER_TO_FUNCTION[provider_type];
-        if (!request_function) {
-          throw new Error(
-            `No request function found for provider: ${provider_type}`
-          );
-        }
-
-        const _trackRequest = (body: object) => {
-          const request_end_time = new Date().toISOString();
-          return trackRequest(
-            this.baseURL,
-            {
-              function_name,
-              provider_type,
-              args: [],
-              kwargs,
-              tags,
-              request_start_time,
-              request_end_time,
-              api_key: this.apiKey,
-              metadata,
-              prompt_id: promptBlueprint!.id,
-              prompt_version: promptBlueprint!.version,
-              prompt_input_variables,
-              group_id: groupId,
-              return_prompt_blueprint: true,
-              span_id: span.spanContext().spanId,
-              ...body,
-            },
-            this.throwOnError
-          );
-        };
-
-        let response: any;
-        try {
-          response = await request_function(promptBlueprint!, kwargs);
-        } catch (llmError: unknown) {
-          const errorType = categorizeError(llmError);
-          const errorMessage =
-            llmError instanceof Error ? llmError.message : String(llmError);
-          await _trackRequest({
-            request_response: {},
-            status: "ERROR",
-            error_type: errorType,
-            error_message: errorMessage,
-          });
-          throw llmError;
-        }
-
-        if (stream)
-          return streamResponse(
-            response,
-            _trackRequest,
-            stream_function,
-            metadata || promptBlueprint!.metadata
-          );
-        const requestLog = await _trackRequest({ request_response: response });
-
-        const functionOutput = {
-          request_id: requestLog.request_id,
-          raw_response: response,
-          prompt_blueprint: requestLog.prompt_blueprint,
-        };
-        span.setAttribute("function_output", JSON.stringify(functionOutput));
-
-        return functionOutput;
-      } catch (error) {
-        span.setStatus({
-          code: opentelemetry.SpanStatusCode.ERROR,
-          message: error instanceof Error ? error.message : "Unknown error",
-        });
-        throw error;
-      } finally {
-        span.end();
-      }
-    });
-  }
-
-  async runWorkflow({
-    workflowName,
-    inputVariables = {},
-    metadata = {},
-    workflowLabelName = null,
-    workflowVersion = null, // This is the version number, not the version ID
-    returnAllOutputs = false,
-  }: WorkflowRequest): Promise<WorkflowResponse> {
-    try {
-      const result = await runWorkflowRequest({
-        workflow_name: workflowName,
-        input_variables: inputVariables,
-        metadata,
-        workflow_label_name: workflowLabelName,
-        workflow_version_number: workflowVersion,
-        return_all_outputs: returnAllOutputs,
-        api_key: this.apiKey,
-        baseURL: this.baseURL,
-      });
-
-      if (!returnAllOutputs) {
-        if (isWorkflowResultsDict(result)) {
-          const nodeValues = Object.values(result);
-
-          const outputNodes = nodeValues.filter(
-            (node: any) => node.is_output_node === true
-          );
-
-          if (outputNodes.length === 0) {
-            throw new Error(JSON.stringify(result, null, 2));
-          }
-
-          const anyOutputSuccess = outputNodes.some(
-            (node: any) => node.status === "SUCCESS"
-          );
-          if (!anyOutputSuccess) {
-            throw new Error(JSON.stringify(result, null, 2));
-          }
-        }
-      }
-
-      return result;
-    } catch (error) {
-      if (error instanceof Error) {
-        console.error("Error running workflow:", error.message);
-        throw new Error(`Error running workflow: ${error.message}`);
-      } else {
-        console.error("Unknown error running workflow:", error);
-        throw new Error("Unknown error running workflow");
-      }
-    }
-  }
-
-  async logRequest(body: LogRequest) {
-    return utilLogRequest(this.apiKey, this.baseURL, body, this.throwOnError);
-  }
-}

package/src/promptlayer.ts

@@ -1,125 +0,0 @@
-import { getTracer } from "@/tracing";
-import { promptlayerApiHandler } from "@/utils/utils";
-
-const tracer = getTracer();
-
-export const promptLayerBase = (
-  apiKey: string,
-  baseURL: string,
-  llm: object,
-  function_name = "",
-  provider = "openai"
-) => {
-  const handler: ProxyHandler<any> = {
-    construct: (target, args) => {
-      const newTarget = Reflect.construct(target, args);
-      Object.defineProperties(newTarget, {
-        function_name: {
-          value: function_name,
-          writable: true,
-        },
-        provider: {
-          value: provider,
-        },
-      });
-      return new Proxy(newTarget, handler);
-    },
-    get: (target, prop, receiver) => {
-      const value = target[prop];
-      const function_name = `${Reflect.get(
-        target,
-        "function_name"
-      )}.${prop.toString()}`;
-
-      if (typeof value === "object") {
-        Object.defineProperties(value, {
-          function_name: {
-            value: function_name,
-            writable: true,
-          },
-          provider: {
-            value: provider,
-          },
-        });
-        return new Proxy(value, handler);
-      }
-
-      if (typeof value === "function") {
-        return (...args: any[]) => {
-          const request_start_time = new Date().toISOString();
-          const provider_type = Reflect.get(target, "provider");
-          const return_pl_id = args[0]?.return_pl_id;
-          const pl_tags = args[0]?.pl_tags;
-          const pl_warn_on_error = args[0]?.pl_warn_on_error;
-          delete args[0]?.return_pl_id;
-          delete args[0]?.pl_tags;
-          delete args[0]?.pl_warn_on_error;
-
-          return tracer.startActiveSpan(
-            `${provider_type}.${function_name}`,
-            async (span: any) => {
-              try {
-                span.setAttribute("function_input", JSON.stringify(args));
-                const response = Reflect.apply(value, target, args);
-                const spanId = span.spanContext().spanId;
-
-                if (response instanceof Promise) {
-                  return new Promise((resolve, reject) => {
-                    response
-                      .then(async (request_response) => {
-                        const response = await promptlayerApiHandler(
-                          apiKey,
-                          baseURL,
-                          {
-                            api_key: apiKey,
-                            provider_type,
-                            function_name,
-                            request_start_time,
-                            request_end_time: new Date().toISOString(),
-                            request_response,
-                            kwargs: args[0],
-                            return_pl_id,
-                            tags: pl_tags,
-                            span_id: spanId,
-                          },
-                          !pl_warn_on_error
-                        );
-
-                        span.setAttribute(
-                          "function_output",
-                          JSON.stringify(response)
-                        );
-                        span.setAttribute("response_status", "success");
-                        span.end();
-                        resolve(response);
-                      })
-                      .catch((error) => {
-                        span.recordException(error);
-                        span.setAttribute("response_status", "error");
-                        span.end();
-                        reject(error);
-                      });
-                  });
-                }
-
-                span.setAttribute("function_output", JSON.stringify(response));
-                span.setAttribute("response_status", "success");
-                span.end();
-                return response;
-              } catch (error) {
-                span.recordException(error);
-                span.setAttribute("response_status", "error");
-                span.end();
-                throw error;
-              }
-            }
-          );
-        };
-      }
-
-      return Reflect.get(target, prop, receiver);
-    },
-  };
-
-  return new Proxy(llm, handler);
-};