@carbon-js/sdk 0.0.1

package/dist/ai/openai/event-factory.mjs

@@ -0,0 +1,189 @@
+import { buildLlmEvent } from "../../core/utils/build-events.mjs";
+import { EMPTY_AI_USAGE } from "../../core/utils/build-events.mjs";
+import { createSdkInstrumentation } from "../../core/utils/instrumentation.mjs";
+import { stringify } from "../../utils/stringify.mjs";
+class OpenAIEventFactory {
+  carbonObject;
+  constructor(args) {
+    this.carbonObject = args.carbonObject;
+  }
+  createResponseEvents(args) {
+    const usage = toResponseAiUsage({ usage: args.response?.usage });
+    return [
+      buildLlmEvent({
+        context: this.carbonObject?.context,
+        additionalProperties: this.carbonObject?.additionalProperties,
+        endTimeMs: args.endTimeMs,
+        instrumentation: createSdkInstrumentation({
+          sourceFunction: args.sourceFunction,
+          sourcePackage: "openai",
+          sourceProvider: "openai"
+        }),
+        llm: {
+          gateway: "openai",
+          model: String(args.response?.model ?? args.body.model ?? "unknown"),
+          input: this.createResponseLlmInput({ body: args.body }),
+          output: {
+            mode: args.mode ?? "generate",
+            reasoning: stringify({ value: getResponseReasoning({ response: args.response }) }),
+            response: getResponseOutputText({ response: args.response }),
+            toolCalls: getResponseToolCalls({ response: args.response })
+          },
+          usage
+        },
+        startTimeMs: args.startTimeMs,
+        status: args.status,
+        traceId: this.carbonObject?.traceId
+      })
+    ];
+  }
+  createChatCompletionEvents(args) {
+    const usage = toCompletionAiUsage({ usage: args.completion?.usage });
+    return [
+      buildLlmEvent({
+        context: this.carbonObject?.context,
+        additionalProperties: this.carbonObject?.additionalProperties,
+        endTimeMs: args.endTimeMs,
+        instrumentation: createSdkInstrumentation({
+          sourceFunction: args.sourceFunction,
+          sourcePackage: "openai",
+          sourceProvider: "openai"
+        }),
+        llm: {
+          gateway: "openai",
+          model: String(args.completion?.model ?? args.body.model ?? "unknown"),
+          input: this.createChatCompletionLlmInput({ body: args.body }),
+          output: {
+            mode: args.mode ?? "generate",
+            reasoning: "",
+            response: stringify({ value: args.completion?.choices[0]?.message.content }),
+            toolCalls: args.completion?.choices[0]?.message.tool_calls?.map((toolCall) => ({
+              args: stringify({ value: toolCall.type === "function" ? toolCall.function.arguments : toolCall.custom.input }),
+              name: toolCall.type === "function" ? toolCall.function.name : toolCall.custom.name
+            })) ?? []
+          },
+          usage
+        },
+        startTimeMs: args.startTimeMs,
+        status: args.status,
+        traceId: this.carbonObject?.traceId
+      })
+    ];
+  }
+  createResponseLlmInput(args) {
+    return {
+      prompt: stringify({ value: args.body.input ?? args.body.prompt }),
+      system: stringify({ value: args.body.instructions }),
+      tools: getResponseToolDescriptions({ tools: args.body.tools })
+    };
+  }
+  createChatCompletionLlmInput(args) {
+    const systemMessages = args.body.messages.filter(
+      (message) => message.role === "system" || message.role === "developer"
+    );
+    return {
+      prompt: stringify({ value: args.body.messages }),
+      system: stringify({ value: systemMessages.length > 0 ? systemMessages : void 0 }),
+      tools: getChatCompletionToolDescriptions({ tools: args.body.tools })
+    };
+  }
+}
+const toResponseAiUsage = (args) => {
+  if (!args.usage) {
+    return EMPTY_AI_USAGE;
+  }
+  const cachedTokens = args.usage.input_tokens_details.cached_tokens ?? 0;
+  const reasoningTokens = args.usage.output_tokens_details.reasoning_tokens ?? 0;
+  return {
+    inputTokenDetails: {
+      cacheReadTokens: cachedTokens,
+      cacheWriteTokens: 0,
+      uncachedTokens: Math.max(args.usage.input_tokens - cachedTokens, 0)
+    },
+    inputTokens: args.usage.input_tokens,
+    outputTokenDetails: {
+      reasoningTokens,
+      responseTokens: Math.max(args.usage.output_tokens - reasoningTokens, 0)
+    },
+    outputTokens: args.usage.output_tokens,
+    totalTokens: args.usage.total_tokens
+  };
+};
+const toCompletionAiUsage = (args) => {
+  if (!args.usage) {
+    return EMPTY_AI_USAGE;
+  }
+  const cachedTokens = args.usage.prompt_tokens_details?.cached_tokens ?? 0;
+  const reasoningTokens = args.usage.completion_tokens_details?.reasoning_tokens ?? 0;
+  return {
+    inputTokenDetails: {
+      cacheReadTokens: cachedTokens,
+      cacheWriteTokens: 0,
+      uncachedTokens: Math.max(args.usage.prompt_tokens - cachedTokens, 0)
+    },
+    inputTokens: args.usage.prompt_tokens,
+    outputTokenDetails: {
+      reasoningTokens,
+      responseTokens: Math.max(args.usage.completion_tokens - reasoningTokens, 0)
+    },
+    outputTokens: args.usage.completion_tokens,
+    totalTokens: args.usage.total_tokens
+  };
+};
+function getResponseToolDescriptions(args) {
+  if (!args.tools) {
+    return [];
+  }
+  return args.tools.map((tool) => ({
+    description: "description" in tool && typeof tool.description === "string" ? tool.description : void 0,
+    name: "name" in tool && typeof tool.name === "string" ? tool.name : tool.type
+  }));
+}
+function getChatCompletionToolDescriptions(args) {
+  if (!args.tools) {
+    return [];
+  }
+  return args.tools.map((tool) => ({
+    description: tool.type === "function" ? tool.function.description ?? void 0 : typeof tool.custom.description === "string" ? tool.custom.description : void 0,
+    name: tool.type === "function" ? tool.function.name : tool.custom.name
+  }));
+}
+function getResponseReasoning(args) {
+  return args.response?.output.filter((item) => item.type === "reasoning").map((item) => item.summary).filter((summary) => summary.length > 0);
+}
+function getResponseOutputText(args) {
+  if (!args.response) {
+    return "";
+  }
+  if (typeof args.response.output_text === "string") {
+    return args.response.output_text;
+  }
+  return args.response.output.flatMap((output) => output.type === "message" ? output.content : []).filter((content) => content.type === "output_text").map((content) => content.text).join("");
+}
+function getResponseToolCalls(args) {
+  if (!args.response) {
+    return [];
+  }
+  return args.response.output.flatMap((output) => {
+    if (output.type === "function_call") {
+      return [
+        {
+          args: output.arguments,
+          name: output.name
+        }
+      ];
+    }
+    if (output.type === "custom_tool_call") {
+      return [
+        {
+          args: output.input,
+          name: output.name
+        }
+      ];
+    }
+    return [];
+  });
+}
+export {
+  OpenAIEventFactory
+};

package/dist/ai/openai/fns/chat-completions-create.d.mts

@@ -0,0 +1,15 @@
+import { Carbon } from '../../../core/carbon.mjs';
+import OpenAI from 'openai';
+import '../../../core/schema/carbon-object.mjs';
+import '../../../internal/schema/events.mjs';
+import 'zod';
+import '../../../core/runtime.mjs';
+import '../../../core/transport/types.mjs';
+import '../../../core/tools/wrap-tool.mjs';
+
+declare function createWrappedChatCompletionCreate(args: {
+    client: OpenAI;
+    carbon: Carbon;
+}): typeof args.client.chat.completions.create;
+
+export { createWrappedChatCompletionCreate };

package/dist/ai/openai/fns/chat-completions-create.mjs

@@ -0,0 +1,219 @@
+import { createErrorStatus, createOkStatus } from "../../../core/utils/build-events.mjs";
+import { OpenAIEventFactory } from "../event-factory.mjs";
+import { SKIP_CAPTURE_FIELD } from "../utils/capture-options.mjs";
+function createWrappedChatCompletionCreate(args) {
+  const createChatCompletion = args.client.chat.completions.create.bind(args.client.chat.completions);
+  return ((body, requestOptions) => {
+    const { carbon: carbonObject, [SKIP_CAPTURE_FIELD]: skipCapture, ...openAiBody } = body;
+    const factory = new OpenAIEventFactory({
+      carbonObject
+    });
+    const startTimeMs = Date.now();
+    const bodyWithUsage = openAiBody.stream ? {
+      ...openAiBody,
+      stream_options: {
+        ...openAiBody.stream_options ?? {},
+        include_usage: true
+      }
+    } : openAiBody;
+    let completionPromise;
+    try {
+      completionPromise = createChatCompletion(bodyWithUsage, requestOptions);
+    } catch (error) {
+      if (!skipCapture) {
+        args.carbon.captureEvents({
+          events: factory.createChatCompletionEvents({
+            body: bodyWithUsage,
+            endTimeMs: Date.now(),
+            mode: openAiBody.stream ? "stream" : void 0,
+            sourceFunction: "chat.completions.create",
+            startTimeMs,
+            status: createErrorStatus({ error })
+          })
+        });
+      }
+      throw error;
+    }
+    if (skipCapture) {
+      return completionPromise;
+    }
+    if (openAiBody.stream) {
+      attachChatCompletionCreateStreamCapture({
+        body: bodyWithUsage,
+        carbon: args.carbon,
+        factory,
+        completionPromise,
+        startTimeMs
+      });
+      return completionPromise;
+    }
+    void Promise.resolve(completionPromise).then(
+      (completion) => {
+        args.carbon.captureEvents({
+          events: factory.createChatCompletionEvents({
+            body: openAiBody,
+            completion,
+            endTimeMs: Date.now(),
+            sourceFunction: "chat.completions.create",
+            startTimeMs,
+            status: createOkStatus()
+          })
+        });
+      },
+      (error) => {
+        args.carbon.captureEvents({
+          events: factory.createChatCompletionEvents({
+            body: openAiBody,
+            endTimeMs: Date.now(),
+            sourceFunction: "chat.completions.create",
+            startTimeMs,
+            status: createErrorStatus({ error })
+          })
+        });
+      }
+    );
+    return completionPromise;
+  });
+}
+function attachChatCompletionCreateStreamCapture(args) {
+  void Promise.resolve(args.completionPromise).then(
+    (stream) => {
+      captureChatCompletionCreateStream({
+        ...args,
+        stream
+      });
+    },
+    (error) => {
+      args.carbon.captureEvents({
+        events: args.factory.createChatCompletionEvents({
+          body: args.body,
+          endTimeMs: Date.now(),
+          mode: "stream",
+          sourceFunction: "chat.completions.create",
+          startTimeMs: args.startTimeMs,
+          status: createErrorStatus({ error })
+        })
+      });
+    }
+  );
+}
+function captureChatCompletionCreateStream(args) {
+  const streamWithIterator = args.stream;
+  const originalIterator = (streamWithIterator.iterator ?? args.stream[Symbol.asyncIterator]).bind(args.stream);
+  const accumulator = createChatCompletionAccumulator({ body: args.body });
+  let captured = false;
+  const wrappedIterator = async function* () {
+    try {
+      for await (const chunk of {
+        [Symbol.asyncIterator]: originalIterator
+      }) {
+        accumulator.addChunk({ chunk });
+        yield chunk;
+      }
+      captured = true;
+      args.carbon.captureEvents({
+        events: args.factory.createChatCompletionEvents({
+          body: args.body,
+          completion: accumulator.toCompletion(),
+          endTimeMs: Date.now(),
+          mode: "stream",
+          sourceFunction: "chat.completions.create",
+          startTimeMs: args.startTimeMs,
+          status: createOkStatus()
+        })
+      });
+    } catch (error) {
+      if (!captured) {
+        captured = true;
+        args.carbon.captureEvents({
+          events: args.factory.createChatCompletionEvents({
+            body: args.body,
+            endTimeMs: Date.now(),
+            mode: "stream",
+            sourceFunction: "chat.completions.create",
+            startTimeMs: args.startTimeMs,
+            status: createErrorStatus({ error })
+          })
+        });
+      }
+      throw error;
+    }
+  };
+  if (streamWithIterator.iterator) {
+    streamWithIterator.iterator = wrappedIterator;
+    return;
+  }
+  args.stream[Symbol.asyncIterator] = wrappedIterator;
+}
+function createChatCompletionAccumulator(args) {
+  const choices = [];
+  let created = 0;
+  let id = "";
+  let model = String(args.body.model ?? "unknown");
+  let usage;
+  return {
+    addChunk(addArgs) {
+      id = addArgs.chunk.id || id;
+      created = addArgs.chunk.created || created;
+      model = addArgs.chunk.model || model;
+      usage = addArgs.chunk.usage ?? usage;
+      for (const chunkChoice of addArgs.chunk.choices) {
+        const choice = choices[chunkChoice.index] ??= {
+          finish_reason: chunkChoice.finish_reason ?? "stop",
+          index: chunkChoice.index,
+          logprobs: chunkChoice.logprobs ?? null,
+          message: {
+            content: "",
+            refusal: null,
+            role: "assistant"
+          }
+        };
+        if (chunkChoice.finish_reason) {
+          choice.finish_reason = chunkChoice.finish_reason;
+        }
+        if (chunkChoice.logprobs) {
+          choice.logprobs = chunkChoice.logprobs;
+        }
+        if (chunkChoice.delta.content) {
+          choice.message.content = (choice.message.content ?? "") + chunkChoice.delta.content;
+        }
+        if (chunkChoice.delta.refusal) {
+          choice.message.refusal = (choice.message.refusal ?? "") + chunkChoice.delta.refusal;
+        }
+        if (chunkChoice.delta.role === "assistant") {
+          choice.message.role = chunkChoice.delta.role;
+        }
+        if (chunkChoice.delta.tool_calls) {
+          choice.message.tool_calls ??= [];
+          for (const toolCallDelta of chunkChoice.delta.tool_calls) {
+            const toolCall = choice.message.tool_calls[toolCallDelta.index] ??= {
+              function: {
+                arguments: "",
+                name: ""
+              },
+              id: "",
+              type: "function"
+            };
+            toolCall.id = toolCallDelta.id ?? toolCall.id;
+            toolCall.type = toolCallDelta.type ?? toolCall.type;
+            toolCall.function.arguments += toolCallDelta.function?.arguments ?? "";
+            toolCall.function.name = toolCallDelta.function?.name ?? toolCall.function.name;
+          }
+        }
+      }
+    },
+    toCompletion() {
+      return {
+        choices,
+        created,
+        id,
+        model,
+        object: "chat.completion",
+        ...usage ? { usage } : {}
+      };
+    }
+  };
+}
+export {
+  createWrappedChatCompletionCreate
+};

package/dist/ai/openai/fns/chat-completions-run-tools.d.mts

@@ -0,0 +1,15 @@
+import { Carbon } from '../../../core/carbon.mjs';
+import OpenAI from 'openai';
+import '../../../core/schema/carbon-object.mjs';
+import '../../../internal/schema/events.mjs';
+import 'zod';
+import '../../../core/runtime.mjs';
+import '../../../core/transport/types.mjs';
+import '../../../core/tools/wrap-tool.mjs';
+
+declare function createWrappedChatCompletionRunTools(args: {
+    client: OpenAI;
+    carbon: Carbon;
+}): typeof args.client.chat.completions.runTools;
+
+export { createWrappedChatCompletionRunTools };

package/dist/ai/openai/fns/chat-completions-run-tools.mjs

@@ -0,0 +1,112 @@
+import { buildToolEvent, createErrorStatus, createOkStatus } from "../../../core/utils/build-events.mjs";
+import { createSdkInstrumentation } from "../../../core/utils/instrumentation.mjs";
+import { stringify } from "../../../utils/stringify.mjs";
+import { OpenAIEventFactory } from "../event-factory.mjs";
+import { SKIP_CAPTURE_FIELD } from "../utils/capture-options.mjs";
+function createWrappedChatCompletionRunTools(args) {
+  const runTools = args.client.chat.completions.runTools.bind(args.client.chat.completions);
+  return ((body, requestOptions) => {
+    const { carbon: carbonObject, ...openAiBody } = body;
+    const bodyWithInternalCapture = {
+      ...openAiBody,
+      carbon: carbonObject,
+      [SKIP_CAPTURE_FIELD]: true
+    };
+    const factory = new OpenAIEventFactory({
+      carbonObject
+    });
+    const startTimeMs = Date.now();
+    let runner;
+    try {
+      runner = runTools(bodyWithInternalCapture, requestOptions);
+    } catch (error) {
+      args.carbon.captureEvents({
+        events: factory.createChatCompletionEvents({
+          body: openAiBody,
+          endTimeMs: Date.now(),
+          mode: openAiBody.stream ? "stream" : void 0,
+          sourceFunction: "chat.completions.runTools",
+          startTimeMs,
+          status: createErrorStatus({ error })
+        })
+      });
+      throw error;
+    }
+    attachRunToolsCapture({
+      body: openAiBody,
+      carbon: args.carbon,
+      carbonObject,
+      factory,
+      mode: openAiBody.stream ? "stream" : "generate",
+      runner
+    });
+    return runner;
+  });
+}
+function attachRunToolsCapture(args) {
+  let nextLlmStartTimeMs = Date.now();
+  const pendingToolCalls = [];
+  args.runner.on("chatCompletion", (completion) => {
+    const endTimeMs = Date.now();
+    args.carbon.captureEvents({
+      events: args.factory.createChatCompletionEvents({
+        body: args.body,
+        completion,
+        endTimeMs,
+        mode: args.mode,
+        sourceFunction: "chat.completions.runTools",
+        startTimeMs: nextLlmStartTimeMs,
+        status: createOkStatus()
+      })
+    });
+    nextLlmStartTimeMs = Date.now();
+  });
+  args.runner.on("functionToolCall", (functionCall) => {
+    pendingToolCalls.push({
+      args: functionCall.arguments,
+      name: functionCall.name,
+      startTimeMs: Date.now()
+    });
+  });
+  args.runner.on("functionToolCallResult", (result) => {
+    const toolCall = pendingToolCalls.shift();
+    const endTimeMs = Date.now();
+    args.carbon.captureEvents({
+      events: [
+        buildToolEvent({
+          additionalProperties: args.carbonObject?.additionalProperties,
+          context: args.carbonObject?.context,
+          endTimeMs,
+          instrumentation: createSdkInstrumentation({
+            sourceFunction: "chat.completions.runTools",
+            sourcePackage: "openai",
+            sourceProvider: "openai"
+          }),
+          startTimeMs: toolCall?.startTimeMs ?? endTimeMs,
+          status: createOkStatus(),
+          tool: {
+            args: toolCall?.args ?? "",
+            name: toolCall?.name ?? "unknown",
+            result: stringify({ value: result })
+          },
+          traceId: args.carbonObject?.traceId
+        })
+      ]
+    });
+  });
+  args.runner.on("error", (error) => {
+    args.carbon.captureEvents({
+      events: args.factory.createChatCompletionEvents({
+        body: args.body,
+        endTimeMs: Date.now(),
+        mode: args.mode,
+        sourceFunction: "chat.completions.runTools",
+        startTimeMs: nextLlmStartTimeMs,
+        status: createErrorStatus({ error })
+      })
+    });
+  });
+}
+export {
+  createWrappedChatCompletionRunTools
+};

package/dist/ai/openai/fns/chat-completions-stream.d.mts

@@ -0,0 +1,15 @@
+import { Carbon } from '../../../core/carbon.mjs';
+import OpenAI from 'openai';
+import '../../../core/schema/carbon-object.mjs';
+import '../../../internal/schema/events.mjs';
+import 'zod';
+import '../../../core/runtime.mjs';
+import '../../../core/transport/types.mjs';
+import '../../../core/tools/wrap-tool.mjs';
+
+declare function createWrappedChatCompletionStream(args: {
+    client: OpenAI;
+    carbon: Carbon;
+}): typeof args.client.chat.completions.stream;
+
+export { createWrappedChatCompletionStream };

package/dist/ai/openai/fns/chat-completions-stream.mjs

@@ -0,0 +1,69 @@
+import { createErrorStatus, createOkStatus } from "../../../core/utils/build-events.mjs";
+import { OpenAIEventFactory } from "../event-factory.mjs";
+function createWrappedChatCompletionStream(args) {
+  const streamChatCompletion = args.client.chat.completions.stream.bind(args.client.chat.completions);
+  return ((body, requestOptions) => {
+    const { carbon: carbonObject, ...openAiBody } = body;
+    const bodyWithUsage = {
+      ...openAiBody,
+      stream_options: {
+        ...openAiBody.stream_options ?? {},
+        include_usage: true
+      }
+    };
+    const factory = new OpenAIEventFactory({
+      carbonObject
+    });
+    const startTimeMs = Date.now();
+    let completionStream;
+    try {
+      completionStream = streamChatCompletion(
+        bodyWithUsage,
+        requestOptions
+      );
+    } catch (error) {
+      args.carbon.captureEvents({
+        events: factory.createChatCompletionEvents({
+          body: bodyWithUsage,
+          endTimeMs: Date.now(),
+          mode: "stream",
+          sourceFunction: "chat.completions.stream",
+          startTimeMs,
+          status: createErrorStatus({ error })
+        })
+      });
+      throw error;
+    }
+    void completionStream.finalChatCompletion().then(
+      (completion) => {
+        args.carbon.captureEvents({
+          events: factory.createChatCompletionEvents({
+            body: bodyWithUsage,
+            completion,
+            endTimeMs: Date.now(),
+            mode: "stream",
+            sourceFunction: "chat.completions.stream",
+            startTimeMs,
+            status: createOkStatus()
+          })
+        });
+      },
+      (error) => {
+        args.carbon.captureEvents({
+          events: factory.createChatCompletionEvents({
+            body: bodyWithUsage,
+            endTimeMs: Date.now(),
+            mode: "stream",
+            sourceFunction: "chat.completions.stream",
+            startTimeMs,
+            status: createErrorStatus({ error })
+          })
+        });
+      }
+    );
+    return completionStream;
+  });
+}
+export {
+  createWrappedChatCompletionStream
+};

package/dist/ai/openai/fns/response-create.d.mts

@@ -0,0 +1,15 @@
+import { Carbon } from '../../../core/carbon.mjs';
+import OpenAI from 'openai';
+import '../../../core/schema/carbon-object.mjs';
+import '../../../internal/schema/events.mjs';
+import 'zod';
+import '../../../core/runtime.mjs';
+import '../../../core/transport/types.mjs';
+import '../../../core/tools/wrap-tool.mjs';
+
+declare function createWrappedResponseCreate(args: {
+    client: OpenAI;
+    carbon: Carbon;
+}): typeof args.client.responses.create;
+
+export { createWrappedResponseCreate };