@carbon-js/sdk 0.0.1

package/dist/ai/openai/fns/response-create.mjs

@@ -0,0 +1,137 @@
+import { createErrorStatus, createOkStatus } from "../../../core/utils/build-events.mjs";
+import { OpenAIEventFactory } from "../event-factory.mjs";
+function createWrappedResponseCreate(args) {
+  const createResponse = args.client.responses.create.bind(args.client.responses);
+  return ((body, requestOptions) => {
+    const { carbon: carbonObject, ...openAiBody } = body;
+    const factory = new OpenAIEventFactory({
+      carbonObject
+    });
+    const startTimeMs = Date.now();
+    let responsePromise;
+    try {
+      responsePromise = createResponse(openAiBody, requestOptions);
+    } catch (error) {
+      args.carbon.captureEvents({
+        events: factory.createResponseEvents({
+          body: openAiBody,
+          endTimeMs: Date.now(),
+          mode: openAiBody.stream ? "stream" : void 0,
+          startTimeMs,
+          sourceFunction: "responses.create",
+          status: createErrorStatus({ error })
+        })
+      });
+      throw error;
+    }
+    if (openAiBody.stream) {
+      attachResponseCreateStreamCapture({
+        body: openAiBody,
+        carbon: args.carbon,
+        factory,
+        responsePromise,
+        startTimeMs
+      });
+      return responsePromise;
+    }
+    void Promise.resolve(responsePromise).then(
+      (response) => {
+        args.carbon.captureEvents({
+          events: factory.createResponseEvents({
+            body: openAiBody,
+            endTimeMs: Date.now(),
+            response,
+            startTimeMs,
+            sourceFunction: "responses.create",
+            status: createOkStatus()
+          })
+        });
+      },
+      (error) => {
+        args.carbon.captureEvents({
+          events: factory.createResponseEvents({
+            body: openAiBody,
+            endTimeMs: Date.now(),
+            startTimeMs,
+            sourceFunction: "responses.create",
+            status: createErrorStatus({ error })
+          })
+        });
+      }
+    );
+    return responsePromise;
+  });
+}
+function attachResponseCreateStreamCapture(args) {
+  void Promise.resolve(args.responsePromise).then(
+    (stream) => {
+      captureResponseCreateStream({
+        ...args,
+        stream
+      });
+    },
+    (error) => {
+      args.carbon.captureEvents({
+        events: args.factory.createResponseEvents({
+          body: args.body,
+          endTimeMs: Date.now(),
+          mode: "stream",
+          startTimeMs: args.startTimeMs,
+          sourceFunction: "responses.create",
+          status: createErrorStatus({ error })
+        })
+      });
+    }
+  );
+}
+function captureResponseCreateStream(args) {
+  const streamWithIterator = args.stream;
+  const originalIterator = (streamWithIterator.iterator ?? args.stream[Symbol.asyncIterator]).bind(args.stream);
+  let captured = false;
+  const wrappedIterator = async function* () {
+    try {
+      for await (const event of {
+        [Symbol.asyncIterator]: originalIterator
+      }) {
+        if (!captured && event.type === "response.completed") {
+          captured = true;
+          args.carbon.captureEvents({
+            events: args.factory.createResponseEvents({
+              body: args.body,
+              endTimeMs: Date.now(),
+              mode: "stream",
+              response: event.response,
+              startTimeMs: args.startTimeMs,
+              sourceFunction: "responses.create",
+              status: createOkStatus()
+            })
+          });
+        }
+        yield event;
+      }
+    } catch (error) {
+      if (!captured) {
+        captured = true;
+        args.carbon.captureEvents({
+          events: args.factory.createResponseEvents({
+            body: args.body,
+            endTimeMs: Date.now(),
+            mode: "stream",
+            startTimeMs: args.startTimeMs,
+            sourceFunction: "responses.create",
+            status: createErrorStatus({ error })
+          })
+        });
+      }
+      throw error;
+    }
+  };
+  if (streamWithIterator.iterator) {
+    streamWithIterator.iterator = wrappedIterator;
+    return;
+  }
+  args.stream[Symbol.asyncIterator] = wrappedIterator;
+}
+export {
+  createWrappedResponseCreate
+};

package/dist/ai/openai/fns/response-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 createWrappedResponseStream(args: {
+    client: OpenAI;
+    carbon: Carbon;
+}): typeof args.client.responses.stream;
+
+export { createWrappedResponseStream };

package/dist/ai/openai/fns/response-stream.mjs

@@ -0,0 +1,59 @@
+import { createErrorStatus, createOkStatus } from "../../../core/utils/build-events.mjs";
+import { OpenAIEventFactory } from "../event-factory.mjs";
+function createWrappedResponseStream(args) {
+  const streamResponse = args.client.responses.stream.bind(args.client.responses);
+  return ((body, requestOptions) => {
+    const { carbon: carbonObject, ...openAiBody } = body;
+    const factory = new OpenAIEventFactory({
+      carbonObject
+    });
+    const startTimeMs = Date.now();
+    let responseStream;
+    try {
+      responseStream = streamResponse(openAiBody, requestOptions);
+    } catch (error) {
+      args.carbon.captureEvents({
+        events: factory.createResponseEvents({
+          body: openAiBody,
+          endTimeMs: Date.now(),
+          mode: "stream",
+          sourceFunction: "responses.stream",
+          startTimeMs,
+          status: createErrorStatus({ error })
+        })
+      });
+      throw error;
+    }
+    void responseStream.finalResponse().then(
+      (response) => {
+        args.carbon.captureEvents({
+          events: factory.createResponseEvents({
+            body: openAiBody,
+            endTimeMs: Date.now(),
+            mode: "stream",
+            response,
+            sourceFunction: "responses.stream",
+            startTimeMs,
+            status: createOkStatus()
+          })
+        });
+      },
+      (error) => {
+        args.carbon.captureEvents({
+          events: factory.createResponseEvents({
+            body: openAiBody,
+            endTimeMs: Date.now(),
+            mode: "stream",
+            sourceFunction: "responses.stream",
+            startTimeMs,
+            status: createErrorStatus({ error })
+          })
+        });
+      }
+    );
+    return responseStream;
+  });
+}
+export {
+  createWrappedResponseStream
+};

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

@@ -0,0 +1,5 @@
+import OpenAI from 'openai';
+
+type T_WrappedOpenAISdk = OpenAI;
+
+export type { T_WrappedOpenAISdk };

package/dist/ai/openai/utils/capture-options.d.mts

@@ -0,0 +1,6 @@
+declare const SKIP_CAPTURE_FIELD = "__carbonSkipCapture";
+type T_OpenAIInternalCaptureOptions = {
+    [SKIP_CAPTURE_FIELD]?: boolean;
+};
+
+export { SKIP_CAPTURE_FIELD, type T_OpenAIInternalCaptureOptions };

package/dist/ai/openai/utils/capture-options.mjs

@@ -0,0 +1,4 @@
+const SKIP_CAPTURE_FIELD = "__carbonSkipCapture";
+export {
+  SKIP_CAPTURE_FIELD
+};

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

@@ -0,0 +1,13 @@
+import { Carbon } from '../../core/carbon.mjs';
+import { T_WrappedOpenAISdk } from './types.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 const wrapOpenAISdk: (client: OpenAI, carbon: Carbon) => T_WrappedOpenAISdk;
+
+export { wrapOpenAISdk };

package/dist/ai/openai/wrap.mjs

@@ -0,0 +1,32 @@
+import { createWrappedChatCompletionCreate } from "./fns/chat-completions-create.mjs";
+import { createWrappedChatCompletionRunTools } from "./fns/chat-completions-run-tools.mjs";
+import { createWrappedChatCompletionStream } from "./fns/chat-completions-stream.mjs";
+import { createWrappedResponseCreate } from "./fns/response-create.mjs";
+import { createWrappedResponseStream } from "./fns/response-stream.mjs";
+const wrapOpenAISdk = (client, carbon) => {
+  const wrappedClient = client;
+  wrappedClient.responses.create = createWrappedResponseCreate({
+    client,
+    carbon
+  });
+  wrappedClient.responses.stream = createWrappedResponseStream({
+    client,
+    carbon
+  });
+  wrappedClient.chat.completions.create = createWrappedChatCompletionCreate({
+    client,
+    carbon
+  });
+  wrappedClient.chat.completions.stream = createWrappedChatCompletionStream({
+    client,
+    carbon
+  });
+  wrappedClient.chat.completions.runTools = createWrappedChatCompletionRunTools({
+    client,
+    carbon
+  });
+  return wrappedClient;
+};
+export {
+  wrapOpenAISdk
+};

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

@@ -0,0 +1,52 @@
+import { T_CarbonObject } from '../../core/schema/carbon-object.mjs';
+import { T as T_LLMEvent, b as T_ToolEvent } from '../../internal/schema/events.mjs';
+import { OnStartEvent, OnFinishEvent, OnStepStartEvent, OnStepFinishEvent, OnToolCallStartEvent, OnToolCallFinishEvent } from 'ai';
+import 'zod';
+
+type T_VercelRecordingMode = "generate" | "stream";
+type T_LlmInputEvent = OnStartEvent | OnFinishEvent | OnStepStartEvent | OnStepFinishEvent | OnToolCallStartEvent | OnToolCallFinishEvent;
+type T_PendingLlmEvent = Pick<T_LLMEvent, "id" | "startTimeMs"> & {
+    gateway: NonNullable<T_LLMEvent["properties"]["llm"]["gateway"]>;
+    input: T_LLMEvent["properties"]["llm"]["input"];
+    model: T_LLMEvent["properties"]["llm"]["model"];
+};
+type T_PendingToolEvent = Pick<T_ToolEvent, "id" | "startTimeMs"> & {
+    args: T_ToolEvent["properties"]["tool"]["args"];
+    toolName: T_ToolEvent["properties"]["tool"]["name"];
+};
+declare class VercelEventFactory {
+    private readonly carbonObject?;
+    private readonly mode;
+    private readonly sourceFunction;
+    private readonly traceId;
+    constructor(args: {
+        carbonObject?: T_CarbonObject;
+        mode: T_VercelRecordingMode;
+        sourceFunction: string;
+    });
+    createFallbackPendingLlmEvent(args: {
+        startTimeMs?: number;
+    }): T_PendingLlmEvent;
+    createPendingLlmEvent(args: {
+        event: T_LlmInputEvent;
+        startTimeMs?: number;
+    }): T_PendingLlmEvent;
+    createPendingToolEvent(args: {
+        event: OnToolCallStartEvent | OnToolCallFinishEvent;
+        startTimeMs?: number;
+    }): T_PendingToolEvent;
+    createCompletedLlmEvent(args: {
+        endTimeMs: number;
+        event?: OnFinishEvent | OnStepFinishEvent;
+        pendingLlm: T_PendingLlmEvent;
+        status: T_LLMEvent["status"];
+    }): T_LLMEvent;
+    createCompletedToolEvent(args: {
+        endTimeMs: number;
+        output?: unknown;
+        pendingTool: T_PendingToolEvent;
+        status: T_ToolEvent["status"];
+    }): T_ToolEvent;
+}
+
+export { type T_PendingLlmEvent, type T_PendingToolEvent, type T_VercelRecordingMode, VercelEventFactory };

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

@@ -0,0 +1,140 @@
+import { buildLlmEvent, buildToolEvent } from "../../core/utils/build-events.mjs";
+import { EMPTY_AI_USAGE } from "../../core/utils/build-events.mjs";
+import { createSdkInstrumentation } from "../../core/utils/instrumentation.mjs";
+import { generateId } from "../../utils/ids.mjs";
+import { stringify } from "../../utils/stringify.mjs";
+class VercelEventFactory {
+  carbonObject;
+  mode;
+  sourceFunction;
+  traceId;
+  constructor(args) {
+    this.carbonObject = args.carbonObject;
+    this.mode = args.mode;
+    this.sourceFunction = args.sourceFunction;
+    this.traceId = args.carbonObject?.traceId ?? generateId();
+  }
+  createFallbackPendingLlmEvent(args) {
+    return {
+      id: generateId(),
+      input: {
+        prompt: "",
+        system: "",
+        tools: []
+      },
+      gateway: "unknown",
+      model: "unknown",
+      startTimeMs: args.startTimeMs ?? Date.now()
+    };
+  }
+  createPendingLlmEvent(args) {
+    return {
+      id: generateId(),
+      input: {
+        prompt: stringify({
+          value: "messages" in args.event && args.event.messages ? args.event.messages : "prompt" in args.event ? args.event.prompt : void 0
+        }),
+        system: stringify({ value: "system" in args.event ? args.event.system : void 0 }),
+        tools: getToolDescriptions({
+          tools: "tools" in args.event ? args.event.tools : void 0
+        })
+      },
+      gateway: args.event.model?.provider ?? "unknown",
+      model: args.event.model?.modelId ?? "unknown",
+      startTimeMs: args.startTimeMs ?? Date.now()
+    };
+  }
+  createPendingToolEvent(args) {
+    return {
+      args: stringify({ value: args.event.toolCall.input }),
+      id: generateId(),
+      startTimeMs: args.startTimeMs ?? Date.now(),
+      toolName: args.event.toolCall.toolName
+    };
+  }
+  createCompletedLlmEvent(args) {
+    return buildLlmEvent({
+      context: this.carbonObject?.context,
+      additionalProperties: this.carbonObject?.additionalProperties,
+      endTimeMs: args.endTimeMs,
+      id: args.pendingLlm.id,
+      instrumentation: createSdkInstrumentation({
+        sourceFunction: this.sourceFunction,
+        sourcePackage: "ai",
+        sourceProvider: "vercel"
+      }),
+      llm: {
+        gateway: args.pendingLlm.gateway,
+        model: args.pendingLlm.model,
+        input: args.pendingLlm.input,
+        output: {
+          mode: this.mode,
+          reasoning: stringify({ value: args.event?.reasoningText }),
+          response: stringify({ value: args.event?.text }),
+          toolCalls: args.event?.toolCalls.map((toolCall) => ({
+            args: stringify({ value: toolCall.input }),
+            name: toolCall.toolName
+          })) ?? []
+        },
+        usage: toAiUsage({ usage: args.event?.usage })
+      },
+      startTimeMs: args.pendingLlm.startTimeMs,
+      status: args.status,
+      traceId: this.traceId
+    });
+  }
+  createCompletedToolEvent(args) {
+    return buildToolEvent({
+      context: this.carbonObject?.context,
+      additionalProperties: this.carbonObject?.additionalProperties,
+      endTimeMs: args.endTimeMs,
+      id: args.pendingTool.id,
+      instrumentation: createSdkInstrumentation({
+        sourceFunction: this.sourceFunction,
+        sourcePackage: "ai",
+        sourceProvider: "vercel"
+      }),
+      startTimeMs: args.pendingTool.startTimeMs,
+      status: args.status,
+      tool: {
+        args: args.pendingTool.args,
+        name: args.pendingTool.toolName,
+        result: stringify({ value: args.output })
+      },
+      traceId: this.traceId
+    });
+  }
+}
+function getToolDescriptions(args) {
+  if (!args.tools) {
+    return [];
+  }
+  return Object.entries(args.tools).map(([name, tool]) => ({
+    description: typeof tool.description === "string" ? tool.description : void 0,
+    name
+  }));
+}
+const toAiUsage = (args) => {
+  if (!args.usage) {
+    return EMPTY_AI_USAGE;
+  }
+  const inputTokenDetails = args.usage.inputTokenDetails ?? {};
+  const outputTokenDetails = args.usage.outputTokenDetails ?? {};
+  return {
+    inputTokenDetails: {
+      cacheReadTokens: inputTokenDetails.cacheReadTokens ?? 0,
+      cacheWriteTokens: inputTokenDetails.cacheWriteTokens ?? 0,
+      uncachedTokens: inputTokenDetails.noCacheTokens ?? 0
+    },
+    inputTokens: args.usage.inputTokens ?? 0,
+    outputTokenDetails: {
+      reasoningTokens: outputTokenDetails.reasoningTokens ?? 0,
+      responseTokens: outputTokenDetails.textTokens ?? 0
+    },
+    outputTokens: args.usage.outputTokens ?? 0,
+    totalTokens: args.usage.totalTokens ?? 0
+  };
+};
+export {
+  VercelEventFactory
+};

package/dist/ai/vercel/fns/tool-loop-agent.d.mts

@@ -0,0 +1,17 @@
+import { Carbon } from '../../../core/carbon.mjs';
+import { T_WrappedToolLoopAgent } from '../types.mjs';
+import * as vercelSdk from 'ai';
+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';
+
+type T_CreateWrappedToolLoopAgent = {
+    ToolLoopAgent: typeof vercelSdk.ToolLoopAgent;
+    carbon: Carbon;
+};
+declare const createWrappedToolLoopAgent: (args: T_CreateWrappedToolLoopAgent) => T_WrappedToolLoopAgent;
+
+export { createWrappedToolLoopAgent };

package/dist/ai/vercel/fns/tool-loop-agent.mjs

@@ -0,0 +1,117 @@
+import { VercelRecorder } from "../recorder.mjs";
+import { addCarbonTelemetry } from "../utils/telemetry.mjs";
+import * as vercelSdk from "ai";
+const createWrappedToolLoopAgent = (args) => {
+  class WrappedToolLoopAgent {
+    version = "agent-v1";
+    carbonObject;
+    settings;
+    constructor(settings) {
+      const { carbon: carbonObject, ...agentSettings } = settings;
+      this.carbonObject = carbonObject;
+      this.settings = agentSettings;
+    }
+    get id() {
+      return this.settings.id;
+    }
+    get tools() {
+      return this.settings.tools;
+    }
+    generate(callArgs) {
+      return runToolLoopAgentCall({
+        ToolLoopAgent: args.ToolLoopAgent,
+        callArgs,
+        carbon: args.carbon,
+        carbonObject: this.carbonObject,
+        mode: "generate",
+        run: ({ agent, aiArgs }) => agent.generate(aiArgs),
+        settings: this.settings,
+        sourceFunction: "ToolLoopAgent.generate"
+      });
+    }
+    stream(callArgs) {
+      return runToolLoopAgentCall({
+        ToolLoopAgent: args.ToolLoopAgent,
+        callArgs,
+        carbon: args.carbon,
+        carbonObject: this.carbonObject,
+        mode: "stream",
+        run: ({ agent, aiArgs }) => agent.stream(aiArgs),
+        settings: this.settings,
+        sourceFunction: "ToolLoopAgent.stream"
+      });
+    }
+  }
+  return WrappedToolLoopAgent;
+};
+function runToolLoopAgentCall(args) {
+  const { carbon: callCarbonObject, ...aiArgs } = args.callArgs;
+  const carbonObject = mergeCarbonObjects({
+    call: callCarbonObject,
+    defaults: args.carbonObject
+  });
+  const recorder = new VercelRecorder({
+    carbon: args.carbon,
+    carbonObject,
+    mode: args.mode,
+    sourceFunction: args.sourceFunction
+  });
+  try {
+    const agent = new args.ToolLoopAgent(
+      withCarbonTelemetry({
+        recorder,
+        settings: args.settings
+      })
+    );
+    return Promise.resolve(
+      args.run({
+        agent,
+        aiArgs
+      })
+    ).catch((error) => {
+      recorder.recordError({ error });
+      throw error;
+    });
+  } catch (error) {
+    recorder.recordError({ error });
+    throw error;
+  }
+}
+function mergeCarbonObjects(args) {
+  if (!args.call && !args.defaults) {
+    return void 0;
+  }
+  return {
+    context: {
+      ...args.defaults?.context,
+      ...args.call?.context
+    },
+    additionalProperties: {
+      ...args.defaults?.additionalProperties,
+      ...args.call?.additionalProperties
+    },
+    traceId: args.call?.traceId ?? args.defaults?.traceId
+  };
+}
+function withCarbonTelemetry(args) {
+  const settingsWithCarbonTelemetry = addCarbonTelemetry({
+    args: args.settings,
+    recorder: args.recorder
+  });
+  if (!args.settings.prepareCall) {
+    return settingsWithCarbonTelemetry;
+  }
+  return {
+    ...settingsWithCarbonTelemetry,
+    prepareCall: async (options) => {
+      const preparedCallArgs = await args.settings.prepareCall?.(options);
+      return addCarbonTelemetry({
+        args: preparedCallArgs ?? options,
+        recorder: args.recorder
+      });
+    }
+  };
+}
+export {
+  createWrappedToolLoopAgent
+};

package/dist/ai/vercel/recorder.d.mts

@@ -0,0 +1,37 @@
+import { Carbon } from '../../core/carbon.mjs';
+import { T_CarbonObject } from '../../core/schema/carbon-object.mjs';
+import { T_VercelRecordingMode } from './event-factory.mjs';
+import { TelemetryIntegration } from 'ai';
+import '../../core/runtime.mjs';
+import '../../internal/schema/events.mjs';
+import 'zod';
+import '../../core/transport/types.mjs';
+import '../../core/tools/wrap-tool.mjs';
+
+declare class VercelRecorder {
+    private readonly completedEvents;
+    private readonly factory;
+    private readonly llmEventsByStep;
+    private readonly carbon;
+    private readonly toolEventsById;
+    private isRecorded;
+    private startTimeMs;
+    constructor(args: {
+        carbon: Carbon;
+        carbonObject?: T_CarbonObject;
+        mode: T_VercelRecordingMode;
+        sourceFunction: string;
+    });
+    createIntegration(): TelemetryIntegration;
+    recordError(args: {
+        error: unknown;
+    }): void;
+    private onToolCallFinish;
+    private onFinish;
+    private recordEvents;
+    private getPendingLlmEvent;
+    private getPendingToolEvent;
+    private closePendingLlmEvent;
+}
+
+export { VercelRecorder };