@carbon-js/sdk 0.0.1

package/README.md

@@ -0,0 +1,26 @@
+# SDK
+
+Native Carbon ingestion SDK for capturing canonical AI events and sending them to the Carbon ingest API.
+
+## Usage
+
+```ts
+import { Carbon } from "@carbon-js/sdk";
+import { wrapOpenAISdk } from "@carbon-js/sdk/ai";
+
+const carbon = new Carbon({ apiKey: process.env.CARBON_API_KEY! });
+const openai = wrapOpenAISdk(client, carbon);
+```
+
+## Development
+
+```bash
+bun install
+bunx tsc --noEmit -p packages/sdk/tsconfig.json
+bun test packages/sdk/tests
+```
+## Smoke Test
+
+```bash
+bun run --cwd packages/sdk example:vercel
+```

package/dist/ai/anthropic/event-factory.d.mts

@@ -0,0 +1,22 @@
+import { T_CarbonObject } from '../../core/schema/carbon-object.mjs';
+import { T as T_LLMEvent, a as T_Event } from '../../internal/schema/events.mjs';
+import { MessageCreateParamsBase, Message } from '@anthropic-ai/sdk/resources/messages/messages';
+import 'zod';
+
+declare class AnthropicEventFactory {
+    private readonly carbonObject?;
+    constructor(args: {
+        carbonObject?: T_CarbonObject;
+    });
+    createMessageEvents(args: {
+        body: MessageCreateParamsBase;
+        endTimeMs: number;
+        message?: Message;
+        mode?: T_LLMEvent["properties"]["llm"]["output"]["mode"];
+        sourceFunction?: string;
+        startTimeMs: number;
+        status: T_LLMEvent["status"];
+    }): T_Event[];
+}
+
+export { AnthropicEventFactory };

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

@@ -0,0 +1,97 @@
+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 AnthropicEventFactory {
+  carbonObject;
+  constructor(args) {
+    this.carbonObject = args.carbonObject;
+  }
+  createMessageEvents(args) {
+    const usage = toAnthropicAiUsage({ usage: args.message?.usage });
+    return [
+      buildLlmEvent({
+        context: this.carbonObject?.context,
+        additionalProperties: this.carbonObject?.additionalProperties,
+        endTimeMs: args.endTimeMs,
+        instrumentation: createSdkInstrumentation({
+          sourceFunction: args.sourceFunction,
+          sourcePackage: "@anthropic-ai/sdk",
+          sourceProvider: "anthropic"
+        }),
+        llm: {
+          gateway: "anthropic",
+          model: String(args.message?.model ?? args.body.model ?? "unknown"),
+          input: {
+            prompt: stringify({ value: args.body.messages }),
+            system: stringify({ value: args.body.system }),
+            tools: getToolDescriptions({ tools: args.body.tools })
+          },
+          output: {
+            mode: args.mode ?? "generate",
+            reasoning: getReasoning({ content: args.message?.content }),
+            response: getResponseText({ content: args.message?.content }),
+            toolCalls: getToolCalls({ content: args.message?.content })
+          },
+          usage
+        },
+        startTimeMs: args.startTimeMs,
+        status: args.status,
+        traceId: this.carbonObject?.traceId
+      })
+    ];
+  }
+}
+function toAnthropicAiUsage(args) {
+  if (!args.usage) {
+    return EMPTY_AI_USAGE;
+  }
+  const cacheReadTokens = args.usage.cache_read_input_tokens ?? 0;
+  const cacheWriteTokens = args.usage.cache_creation_input_tokens ?? 0;
+  const inputTokens = args.usage.input_tokens + cacheReadTokens + cacheWriteTokens;
+  return {
+    inputTokenDetails: {
+      cacheReadTokens,
+      cacheWriteTokens,
+      uncachedTokens: args.usage.input_tokens
+    },
+    inputTokens,
+    outputTokenDetails: {
+      reasoningTokens: 0,
+      responseTokens: args.usage.output_tokens
+    },
+    outputTokens: args.usage.output_tokens,
+    totalTokens: inputTokens + args.usage.output_tokens
+  };
+}
+function getToolDescriptions(args) {
+  if (!args.tools) {
+    return [];
+  }
+  return args.tools.map((tool) => ({
+    description: "description" in tool && typeof tool.description === "string" ? tool.description : void 0,
+    name: tool.name
+  }));
+}
+function getReasoning(args) {
+  const thinking = args.content?.filter((block) => block.type === "thinking").map((block) => block.thinking).filter((text) => text.length > 0);
+  return stringify({ value: thinking && thinking.length > 0 ? thinking : void 0 });
+}
+function getResponseText(args) {
+  if (!args.content) {
+    return "";
+  }
+  return args.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+function getToolCalls(args) {
+  if (!args.content) {
+    return [];
+  }
+  return args.content.filter((block) => block.type === "tool_use" || block.type === "server_tool_use").map((block) => ({
+    args: stringify({ value: block.input }),
+    name: block.name
+  }));
+}
+export {
+  AnthropicEventFactory
+};

package/dist/ai/anthropic/fns/message-create.d.mts

@@ -0,0 +1,15 @@
+import { Carbon } from '../../../core/carbon.mjs';
+import Anthropic from '@anthropic-ai/sdk';
+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 createWrappedMessageCreate(args: {
+    client: Anthropic;
+    carbon: Carbon;
+}): typeof args.client.messages.create;
+
+export { createWrappedMessageCreate };

package/dist/ai/anthropic/fns/message-create.mjs

@@ -0,0 +1,248 @@
+import { createErrorStatus, createOkStatus } from "../../../core/utils/build-events.mjs";
+import { AnthropicEventFactory } from "../event-factory.mjs";
+function createWrappedMessageCreate(args) {
+  const createMessage = args.client.messages.create.bind(args.client.messages);
+  return ((body, requestOptions) => {
+    const { carbon: carbonObject, ...anthropicBody } = body;
+    const factory = new AnthropicEventFactory({
+      carbonObject
+    });
+    const startTimeMs = Date.now();
+    let messagePromise;
+    try {
+      messagePromise = createMessage(anthropicBody, requestOptions);
+    } catch (error) {
+      args.carbon.captureEvents({
+        events: factory.createMessageEvents({
+          body: anthropicBody,
+          endTimeMs: Date.now(),
+          mode: anthropicBody.stream ? "stream" : void 0,
+          sourceFunction: "messages.create",
+          startTimeMs,
+          status: createErrorStatus({ error })
+        })
+      });
+      throw error;
+    }
+    if (anthropicBody.stream) {
+      attachMessageCreateStreamCapture({
+        body: anthropicBody,
+        carbon: args.carbon,
+        factory,
+        messagePromise,
+        startTimeMs
+      });
+      return messagePromise;
+    }
+    void Promise.resolve(messagePromise).then(
+      (message) => {
+        args.carbon.captureEvents({
+          events: factory.createMessageEvents({
+            body: anthropicBody,
+            endTimeMs: Date.now(),
+            message,
+            sourceFunction: "messages.create",
+            startTimeMs,
+            status: createOkStatus()
+          })
+        });
+      },
+      (error) => {
+        args.carbon.captureEvents({
+          events: factory.createMessageEvents({
+            body: anthropicBody,
+            endTimeMs: Date.now(),
+            sourceFunction: "messages.create",
+            startTimeMs,
+            status: createErrorStatus({ error })
+          })
+        });
+      }
+    );
+    return messagePromise;
+  });
+}
+function attachMessageCreateStreamCapture(args) {
+  void Promise.resolve(args.messagePromise).then(
+    (stream) => {
+      captureMessageCreateStream({
+        ...args,
+        stream
+      });
+    },
+    (error) => {
+      args.carbon.captureEvents({
+        events: args.factory.createMessageEvents({
+          body: args.body,
+          endTimeMs: Date.now(),
+          mode: "stream",
+          sourceFunction: "messages.create",
+          startTimeMs: args.startTimeMs,
+          status: createErrorStatus({ error })
+        })
+      });
+    }
+  );
+}
+function captureMessageCreateStream(args) {
+  const streamWithIterator = args.stream;
+  const originalIterator = (streamWithIterator.iterator ?? args.stream[Symbol.asyncIterator]).bind(args.stream);
+  const accumulator = createMessageAccumulator({ body: args.body });
+  let captured = false;
+  const wrappedIterator = async function* () {
+    try {
+      for await (const event of {
+        [Symbol.asyncIterator]: originalIterator
+      }) {
+        accumulator.addEvent({ event });
+        yield event;
+      }
+      captured = true;
+      args.carbon.captureEvents({
+        events: args.factory.createMessageEvents({
+          body: args.body,
+          endTimeMs: Date.now(),
+          message: accumulator.toMessage(),
+          mode: "stream",
+          sourceFunction: "messages.create",
+          startTimeMs: args.startTimeMs,
+          status: createOkStatus()
+        })
+      });
+    } catch (error) {
+      if (!captured) {
+        captured = true;
+        args.carbon.captureEvents({
+          events: args.factory.createMessageEvents({
+            body: args.body,
+            endTimeMs: Date.now(),
+            mode: "stream",
+            sourceFunction: "messages.create",
+            startTimeMs: args.startTimeMs,
+            status: createErrorStatus({ error })
+          })
+        });
+      }
+      throw error;
+    }
+  };
+  if (streamWithIterator.iterator) {
+    streamWithIterator.iterator = wrappedIterator;
+    return;
+  }
+  args.stream[Symbol.asyncIterator] = wrappedIterator;
+}
+function createMessageAccumulator(args) {
+  let message;
+  const toolInputByIndex = /* @__PURE__ */ new Map();
+  return {
+    addEvent(addArgs) {
+      switch (addArgs.event.type) {
+        case "message_start":
+          message = {
+            ...addArgs.event.message,
+            content: [...addArgs.event.message.content],
+            usage: {
+              ...addArgs.event.message.usage
+            }
+          };
+          return;
+        case "content_block_start":
+          message?.content.push({ ...addArgs.event.content_block });
+          return;
+        case "content_block_delta":
+          applyContentDelta({
+            content: message?.content,
+            event: addArgs.event,
+            toolInputByIndex
+          });
+          return;
+        case "message_delta":
+          if (message) {
+            message = {
+              ...message,
+              stop_reason: addArgs.event.delta.stop_reason,
+              stop_sequence: addArgs.event.delta.stop_sequence,
+              usage: {
+                ...message.usage,
+                cache_creation_input_tokens: addArgs.event.usage.cache_creation_input_tokens ?? message.usage.cache_creation_input_tokens,
+                cache_read_input_tokens: addArgs.event.usage.cache_read_input_tokens ?? message.usage.cache_read_input_tokens,
+                input_tokens: addArgs.event.usage.input_tokens ?? message.usage.input_tokens,
+                output_tokens: addArgs.event.usage.output_tokens,
+                server_tool_use: addArgs.event.usage.server_tool_use ?? message.usage.server_tool_use
+              }
+            };
+          }
+          return;
+        case "content_block_stop":
+        case "message_stop":
+          return;
+      }
+    },
+    toMessage() {
+      return message ?? {
+        container: null,
+        content: [],
+        id: "",
+        model: String(args.body.model ?? "unknown"),
+        role: "assistant",
+        stop_details: null,
+        stop_reason: null,
+        stop_sequence: null,
+        type: "message",
+        usage: {
+          cache_creation: null,
+          cache_creation_input_tokens: 0,
+          cache_read_input_tokens: 0,
+          inference_geo: null,
+          input_tokens: 0,
+          output_tokens: 0,
+          server_tool_use: null,
+          service_tier: null
+        }
+      };
+    }
+  };
+}
+function applyContentDelta(args) {
+  const block = args.content?.[args.event.index];
+  if (!block) {
+    return;
+  }
+  switch (args.event.delta.type) {
+    case "text_delta":
+      if (block.type === "text") {
+        block.text = (block.text ?? "") + args.event.delta.text;
+      }
+      return;
+    case "thinking_delta":
+      if (block.type === "thinking") {
+        block.thinking = (block.thinking ?? "") + args.event.delta.thinking;
+      }
+      return;
+    case "signature_delta":
+      if (block.type === "thinking") {
+        block.signature = args.event.delta.signature;
+      }
+      return;
+    case "input_json_delta":
+      if (block.type === "tool_use" || block.type === "server_tool_use") {
+        const inputJson = (args.toolInputByIndex.get(args.event.index) ?? "") + args.event.delta.partial_json;
+        args.toolInputByIndex.set(args.event.index, inputJson);
+        try {
+          block.input = JSON.parse(inputJson);
+        } catch {
+          block.input = inputJson;
+        }
+      }
+      return;
+    case "citations_delta":
+      if (block.type === "text") {
+        block.citations = [...block.citations ?? [], args.event.delta.citation];
+      }
+      return;
+  }
+}
+export {
+  createWrappedMessageCreate
+};

package/dist/ai/anthropic/fns/message-stream.d.mts

@@ -0,0 +1,15 @@
+import { Carbon } from '../../../core/carbon.mjs';
+import Anthropic from '@anthropic-ai/sdk';
+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 createWrappedMessageStream(args: {
+    client: Anthropic;
+    carbon: Carbon;
+}): typeof args.client.messages.stream;
+
+export { createWrappedMessageStream };

package/dist/ai/anthropic/fns/message-stream.mjs

@@ -0,0 +1,59 @@
+import { createErrorStatus, createOkStatus } from "../../../core/utils/build-events.mjs";
+import { AnthropicEventFactory } from "../event-factory.mjs";
+function createWrappedMessageStream(args) {
+  const streamMessage = args.client.messages.stream.bind(args.client.messages);
+  return ((body, requestOptions) => {
+    const { carbon: carbonObject, ...anthropicBody } = body;
+    const factory = new AnthropicEventFactory({
+      carbonObject
+    });
+    const startTimeMs = Date.now();
+    let messageStream;
+    try {
+      messageStream = streamMessage(anthropicBody, requestOptions);
+    } catch (error) {
+      args.carbon.captureEvents({
+        events: factory.createMessageEvents({
+          body: anthropicBody,
+          endTimeMs: Date.now(),
+          mode: "stream",
+          sourceFunction: "messages.stream",
+          startTimeMs,
+          status: createErrorStatus({ error })
+        })
+      });
+      throw error;
+    }
+    void messageStream.finalMessage().then(
+      (message) => {
+        args.carbon.captureEvents({
+          events: factory.createMessageEvents({
+            body: anthropicBody,
+            endTimeMs: Date.now(),
+            message,
+            mode: "stream",
+            sourceFunction: "messages.stream",
+            startTimeMs,
+            status: createOkStatus()
+          })
+        });
+      },
+      (error) => {
+        args.carbon.captureEvents({
+          events: factory.createMessageEvents({
+            body: anthropicBody,
+            endTimeMs: Date.now(),
+            mode: "stream",
+            sourceFunction: "messages.stream",
+            startTimeMs,
+            status: createErrorStatus({ error })
+          })
+        });
+      }
+    );
+    return messageStream;
+  });
+}
+export {
+  createWrappedMessageStream
+};

package/dist/ai/anthropic/types.d.mts

@@ -0,0 +1,5 @@
+import Anthropic from '@anthropic-ai/sdk';
+
+type T_WrappedAnthropicSdk = Anthropic;
+
+export type { T_WrappedAnthropicSdk };

package/dist/ai/anthropic/wrap.d.mts

@@ -0,0 +1,13 @@
+import { Carbon } from '../../core/carbon.mjs';
+import { T_WrappedAnthropicSdk } from './types.mjs';
+import Anthropic from '@anthropic-ai/sdk';
+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 const wrapAnthropicSdk: (client: Anthropic, carbon: Carbon) => T_WrappedAnthropicSdk;
+
+export { wrapAnthropicSdk };

package/dist/ai/anthropic/wrap.mjs

@@ -0,0 +1,17 @@
+import { createWrappedMessageCreate } from "./fns/message-create.mjs";
+import { createWrappedMessageStream } from "./fns/message-stream.mjs";
+const wrapAnthropicSdk = (client, carbon) => {
+  const wrappedClient = client;
+  wrappedClient.messages.create = createWrappedMessageCreate({
+    client,
+    carbon
+  });
+  wrappedClient.messages.stream = createWrappedMessageStream({
+    client,
+    carbon
+  });
+  return wrappedClient;
+};
+export {
+  wrapAnthropicSdk
+};

package/dist/ai/openai/event-factory.d.mts

@@ -0,0 +1,34 @@
+import { T_CarbonObject } from '../../core/schema/carbon-object.mjs';
+import { T as T_LLMEvent, a as T_Event } from '../../internal/schema/events.mjs';
+import { ChatCompletionCreateParamsBase, ChatCompletion } from 'openai/resources/chat/completions/completions';
+import { ResponseCreateParamsBase, Response } from 'openai/resources/responses/responses';
+import 'zod';
+
+declare class OpenAIEventFactory {
+    private readonly carbonObject?;
+    constructor(args: {
+        carbonObject?: T_CarbonObject;
+    });
+    createResponseEvents(args: {
+        body: Partial<ResponseCreateParamsBase>;
+        endTimeMs: number;
+        mode?: T_LLMEvent["properties"]["llm"]["output"]["mode"];
+        response?: Response;
+        sourceFunction?: string;
+        startTimeMs: number;
+        status: T_LLMEvent["status"];
+    }): T_Event[];
+    createChatCompletionEvents(args: {
+        body: ChatCompletionCreateParamsBase;
+        completion?: ChatCompletion;
+        endTimeMs: number;
+        mode?: T_LLMEvent["properties"]["llm"]["output"]["mode"];
+        sourceFunction?: string;
+        startTimeMs: number;
+        status: T_LLMEvent["status"];
+    }): T_Event[];
+    private createResponseLlmInput;
+    private createChatCompletionLlmInput;
+}
+
+export { OpenAIEventFactory };