promptlayer 1.0.39 → 1.0.40

package/src/utils/blueprint-builder.ts

@@ -0,0 +1,198 @@
+const _buildToolCall = (id: string, name: string, input: any) => {
+  return {
+    id,
+    function: {
+      name,
+      input,
+    },
+  };
+};
+
+const _buildContentBlock = ({
+  type,
+  ...rest
+}: {
+  type: string;
+  [key: string]: any;
+}) => {
+  return {
+    type,
+    ...rest,
+  };
+};
+
+const _buildAssistantMessage = (content: any[], tool_calls: any[]) => {
+  return {
+    input_variables: [],
+    template_format: "f-string" as const,
+    content: content,
+    role: "assistant" as const,
+    function_call: null,
+    name: null,
+    tool_calls: tool_calls,
+  };
+};
+
+const _buildPromptTemplate = (assistantMessage: any, metadata: any) => {
+  const promptTemplate = {
+    messages: [assistantMessage],
+    type: "chat" as const,
+    input_variables: [],
+  };
+
+  return {
+    prompt_template: promptTemplate,
+    metadata: metadata,
+  };
+};
+
+export const buildPromptBlueprintFromAnthropicEvent = (
+  event: any,
+  metadata: any
+) => {
+  const assistantContent: any[] = [];
+  const tool_calls: any[] = [];
+
+  if (event.type === "content_block_start") {
+    if (event.content_block.type === "thinking") {
+      assistantContent.push(
+        _buildContentBlock({
+          type: "thinking",
+          thinking: "",
+          signature: "",
+        })
+      );
+    } else if (event.content_block.type === "text") {
+      assistantContent.push(
+        _buildContentBlock({
+          type: "text",
+          text: "",
+        })
+      );
+    } else if (event.content_block.type === "tool_use") {
+      tool_calls.push(
+        _buildToolCall(
+          event.content_block.id || "",
+          event.content_block.name || "",
+          {}
+        )
+      );
+    }
+  } else if (event.type === "content_block_delta") {
+    if (event.delta.type === "thinking_delta") {
+      assistantContent.push(
+        _buildContentBlock({
+          type: "thinking",
+          thinking: event.delta.thinking || "",
+          signature: "",
+        })
+      );
+    } else if (event.delta.type === "text_delta") {
+      assistantContent.push(
+        _buildContentBlock({
+          type: "text",
+          text: event.delta.text || "",
+        })
+      );
+    } else if (event.delta.type === "signature_delta") {
+      assistantContent.push(
+        _buildContentBlock({
+          type: "thinking",
+          thinking: "",
+          signature: event.delta.signature || "",
+        })
+      );
+    } else if (event.delta.type === "input_json_delta") {
+      tool_calls.push(_buildToolCall("", "", event.delta.partial_json));
+    }
+  }
+
+  const assistantMessage = _buildAssistantMessage(assistantContent, tool_calls);
+  return _buildPromptTemplate(assistantMessage, metadata);
+};
+
+export const buildPromptBlueprintFromGoogleEvent = (
+  event: any,
+  metadata: any
+) => {
+  const assistantContent: any[] = [];
+  const tool_calls: any[] = [];
+
+  for (const candidate of event.candidates) {
+    if (
+      candidate.content &&
+      candidate.content.parts &&
+      Array.isArray(candidate.content.parts)
+    ) {
+      for (const part of candidate.content.parts) {
+        if (part.text) {
+          if (part.thought === true) {
+            assistantContent.push(
+              _buildContentBlock({
+                type: "thinking",
+                thinking: part.text,
+                signature: part.thoughtSignature || "",
+              })
+            );
+          } else {
+            assistantContent.push(
+              _buildContentBlock({
+                type: "text",
+                text: part.text,
+              })
+            );
+          }
+        } else if (part.functionCall) {
+          tool_calls.push(
+            _buildToolCall(
+              part.functionCall.id || "",
+              part.functionCall.name || "",
+              part.functionCall.args || {}
+            )
+          );
+        }
+      }
+    }
+  }
+
+  const assistantMessage = _buildAssistantMessage(assistantContent, tool_calls);
+  return _buildPromptTemplate(assistantMessage, metadata);
+};
+
+export const buildPromptBlueprintFromOpenAIEvent = (
+  event: any,
+  metadata: any
+) => {
+  const assistantContent: any[] = [];
+  const tool_calls: any[] = [];
+
+  for (const choice of event.choices) {
+    if (choice.delta) {
+      if (choice.delta.content) {
+        assistantContent.push(
+          _buildContentBlock({
+            type: "text",
+            text: choice.delta.content,
+          })
+        );
+      }
+
+      if (choice.delta.tool_calls && Array.isArray(choice.delta.tool_calls)) {
+        for (const toolCall of choice.delta.tool_calls) {
+          if (toolCall.function) {
+            tool_calls.push(
+              _buildToolCall(
+                toolCall.id || "",
+                toolCall.function.name || "",
+                toolCall.function.arguments || ""
+              )
+            );
+          }
+        }
+      }
+    }
+  }
+
+  const assistantMessage = _buildAssistantMessage(assistantContent, tool_calls);
+  return _buildPromptTemplate(assistantMessage, metadata);
+};

package/src/utils/utils.ts

@@ -15,6 +15,11 @@ import {
   TrackScore,
   WorkflowResponse,
 } from "@/types";
+import {
+  buildPromptBlueprintFromAnthropicEvent,
+  buildPromptBlueprintFromGoogleEvent,
+  buildPromptBlueprintFromOpenAIEvent,
+} from "./blueprint-builder";
 import type TypeAnthropic from "@anthropic-ai/sdk";
 import {
   Completion as AnthropicCompletion,
@@ -883,7 +888,8 @@ const anthropicStreamCompletion = (results: AnthropicCompletion[]) => {
 async function* streamResponse<Item>(
   generator: AsyncIterable<Item>,
   afterStream: (body: object) => any,
-  mapResults: any
+  mapResults: any,
+  metadata: any
 ) {
   const data: {
     request_id: number | null;
@@ -898,6 +904,31 @@ async function* streamResponse<Item>(
   for await (const result of generator) {
     results.push(result);
     data.raw_response = result;
+
+    // Build prompt blueprint for Anthropic streaming events
+    if (result && typeof result === "object" && "type" in result) {
+      data.prompt_blueprint = buildPromptBlueprintFromAnthropicEvent(
+        result as MessageStreamEvent,
+        metadata
+      );
+    }
+
+    // Build prompt blueprint for Google streaming events
+    if (result && typeof result === "object" && "candidates" in result) {
+      data.prompt_blueprint = buildPromptBlueprintFromGoogleEvent(
+        result,
+        metadata
+      );
+    }
+
+    // Build prompt blueprint for OpenAI streaming events
+    if (result && typeof result === "object" && "choices" in result) {
+      data.prompt_blueprint = buildPromptBlueprintFromOpenAIEvent(
+        result,
+        metadata
+      );
+    }
+
     yield data;
   }
   const request_response = mapResults(results);
@@ -1157,24 +1188,32 @@ const googleRequest = async (
   const requestToMake =
     MAP_TYPE_TO_GOOGLE_FUNCTION[promptBlueprint.prompt_template.type];
 
-  const kwargsCamelCased = convertKeysToCamelCase(kwargs);
-  if (kwargsCamelCased.generationConfig)
-    kwargsCamelCased.generationConfig = convertKeysToCamelCase(
-      kwargsCamelCased.generationConfig
-    );
-
-  return await requestToMake(genAI, kwargsCamelCased);
+  return await requestToMake(genAI, kwargs);
 };
 
 const snakeToCamel = (str: string): string =>
   str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
 
-const convertKeysToCamelCase = <T>(obj: T): T => {
+const convertKeysToCamelCase = <T>(
+  obj: T,
+  ignoreValuesWithKeys: Set<string> = new Set()
+): T => {
   if (!obj || typeof obj !== "object") return obj;
-  if (Array.isArray(obj)) return obj.map(convertKeysToCamelCase) as T;
+  if (Array.isArray(obj))
+    return obj.map((item) =>
+      convertKeysToCamelCase(item, ignoreValuesWithKeys)
+    ) as T;
 
   return Object.fromEntries(
-    Object.entries(obj).map(([key, value]) => [snakeToCamel(key), value])
+    Object.entries(obj).map(([key, value]) => {
+      if (ignoreValuesWithKeys.has(key)) {
+        return [snakeToCamel(key), value];
+      }
+      return [
+        snakeToCamel(key),
+        convertKeysToCamelCase(value, ignoreValuesWithKeys),
+      ];
+    })
   ) as T;
 };
 
@@ -1238,12 +1277,18 @@ const configureProviderSettings = (
     );
   }
 
-  const kwargs = {
+  let kwargs = {
     ...(promptBlueprint.llm_kwargs || {}),
     ...modelParameterOverrides,
     stream,
   };
 
+  if (
+    ["google", "vertexai"].includes(provider_type) &&
+    promptBlueprint.metadata?.model?.name.startsWith("gemini")
+  )
+    kwargs = convertKeysToCamelCase(kwargs, new Set(["function_declarations"]));
+
   const providerConfig = {
     baseURL: customProvider?.base_url ?? promptBlueprint.provider_base_url?.url,
     apiKey: customProvider?.api_key,