@carbon-js/sdk 0.0.1

package/dist/internal/schema/events.d.mts

@@ -0,0 +1,315 @@
+import { z } from 'zod';
+
+declare const Z_EventAiUsage: z.ZodObject<{
+    inputTokens: z.ZodNumber;
+    inputTokenDetails: z.ZodObject<{
+        uncachedTokens: z.ZodNumber;
+        cacheReadTokens: z.ZodNumber;
+        cacheWriteTokens: z.ZodNumber;
+    }, z.core.$strip>;
+    outputTokens: z.ZodNumber;
+    outputTokenDetails: z.ZodObject<{
+        reasoningTokens: z.ZodNumber;
+        responseTokens: z.ZodNumber;
+    }, z.core.$strip>;
+    totalTokens: z.ZodNumber;
+}, z.core.$strip>;
+declare const Z_EventContext: z.ZodObject<{
+    threadId: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+    agentGroupId: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const Z_EventAdditionalProperties: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+declare const Z_EventBase: z.ZodObject<{
+    id: z.ZodUUID;
+    spaceId: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        llm: "llm";
+        tool: "tool";
+    }>;
+    traceId: z.ZodOptional<z.ZodUUID>;
+    startTimeMs: z.ZodNumber;
+    endTimeMs: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    status: z.ZodObject<{
+        state: z.ZodEnum<{
+            ok: "ok";
+            error: "error";
+        }>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodOptional<z.ZodString>;
+            httpStatus: z.ZodOptional<z.ZodNumber>;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    instrumentation: z.ZodObject<{
+        provider: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
+        providerPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
+        sourceProvider: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
+        sourcePackage: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"@anthropic-ai/sdk">, z.ZodLiteral<"ai">]>;
+        sourceFunction: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    context: z.ZodObject<{
+        threadId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        agentGroupId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    additionalProperties: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+}, z.core.$strip>;
+declare const Z_LLMEvent: z.ZodObject<{
+    id: z.ZodUUID;
+    spaceId: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodOptional<z.ZodUUID>;
+    startTimeMs: z.ZodNumber;
+    endTimeMs: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    status: z.ZodObject<{
+        state: z.ZodEnum<{
+            ok: "ok";
+            error: "error";
+        }>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodOptional<z.ZodString>;
+            httpStatus: z.ZodOptional<z.ZodNumber>;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    instrumentation: z.ZodObject<{
+        provider: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
+        providerPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
+        sourceProvider: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
+        sourcePackage: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"@anthropic-ai/sdk">, z.ZodLiteral<"ai">]>;
+        sourceFunction: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    context: z.ZodObject<{
+        threadId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        agentGroupId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    additionalProperties: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    type: z.ZodLiteral<"llm">;
+    properties: z.ZodObject<{
+        llm: z.ZodObject<{
+            gateway: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodString>;
+            model: z.ZodString;
+            input: z.ZodObject<{
+                system: z.ZodString;
+                prompt: z.ZodString;
+                tools: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            output: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    generate: "generate";
+                    stream: "stream";
+                }>;
+                reasoning: z.ZodOptional<z.ZodString>;
+                response: z.ZodOptional<z.ZodString>;
+                toolCalls: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    args: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            usage: z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                inputTokenDetails: z.ZodObject<{
+                    uncachedTokens: z.ZodNumber;
+                    cacheReadTokens: z.ZodNumber;
+                    cacheWriteTokens: z.ZodNumber;
+                }, z.core.$strip>;
+                outputTokens: z.ZodNumber;
+                outputTokenDetails: z.ZodObject<{
+                    reasoningTokens: z.ZodNumber;
+                    responseTokens: z.ZodNumber;
+                }, z.core.$strip>;
+                totalTokens: z.ZodNumber;
+            }, z.core.$strip>;
+            cost: z.ZodOptional<z.ZodObject<{
+                inputUncachedUsd: z.ZodNumber;
+                inputCacheReadUsd: z.ZodNumber;
+                inputCacheWriteUsd: z.ZodNumber;
+                outputUsd: z.ZodNumber;
+                totalUsd: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const Z_ToolEvent: z.ZodObject<{
+    id: z.ZodUUID;
+    spaceId: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodOptional<z.ZodUUID>;
+    startTimeMs: z.ZodNumber;
+    endTimeMs: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    status: z.ZodObject<{
+        state: z.ZodEnum<{
+            ok: "ok";
+            error: "error";
+        }>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodOptional<z.ZodString>;
+            httpStatus: z.ZodOptional<z.ZodNumber>;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    instrumentation: z.ZodObject<{
+        provider: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
+        providerPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
+        sourceProvider: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
+        sourcePackage: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"@anthropic-ai/sdk">, z.ZodLiteral<"ai">]>;
+        sourceFunction: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    context: z.ZodObject<{
+        threadId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        agentGroupId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    additionalProperties: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    type: z.ZodLiteral<"tool">;
+    properties: z.ZodObject<{
+        tool: z.ZodObject<{
+            name: z.ZodString;
+            args: z.ZodOptional<z.ZodString>;
+            result: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const Z_Event: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodUUID;
+    spaceId: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodOptional<z.ZodUUID>;
+    startTimeMs: z.ZodNumber;
+    endTimeMs: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    status: z.ZodObject<{
+        state: z.ZodEnum<{
+            ok: "ok";
+            error: "error";
+        }>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodOptional<z.ZodString>;
+            httpStatus: z.ZodOptional<z.ZodNumber>;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    instrumentation: z.ZodObject<{
+        provider: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
+        providerPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
+        sourceProvider: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
+        sourcePackage: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"@anthropic-ai/sdk">, z.ZodLiteral<"ai">]>;
+        sourceFunction: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    context: z.ZodObject<{
+        threadId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        agentGroupId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    additionalProperties: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    type: z.ZodLiteral<"llm">;
+    properties: z.ZodObject<{
+        llm: z.ZodObject<{
+            gateway: z.ZodOptional<z.ZodString>;
+            provider: z.ZodOptional<z.ZodString>;
+            model: z.ZodString;
+            input: z.ZodObject<{
+                system: z.ZodString;
+                prompt: z.ZodString;
+                tools: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            output: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    generate: "generate";
+                    stream: "stream";
+                }>;
+                reasoning: z.ZodOptional<z.ZodString>;
+                response: z.ZodOptional<z.ZodString>;
+                toolCalls: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    args: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            usage: z.ZodObject<{
+                inputTokens: z.ZodNumber;
+                inputTokenDetails: z.ZodObject<{
+                    uncachedTokens: z.ZodNumber;
+                    cacheReadTokens: z.ZodNumber;
+                    cacheWriteTokens: z.ZodNumber;
+                }, z.core.$strip>;
+                outputTokens: z.ZodNumber;
+                outputTokenDetails: z.ZodObject<{
+                    reasoningTokens: z.ZodNumber;
+                    responseTokens: z.ZodNumber;
+                }, z.core.$strip>;
+                totalTokens: z.ZodNumber;
+            }, z.core.$strip>;
+            cost: z.ZodOptional<z.ZodObject<{
+                inputUncachedUsd: z.ZodNumber;
+                inputCacheReadUsd: z.ZodNumber;
+                inputCacheWriteUsd: z.ZodNumber;
+                outputUsd: z.ZodNumber;
+                totalUsd: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    id: z.ZodUUID;
+    spaceId: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodOptional<z.ZodUUID>;
+    startTimeMs: z.ZodNumber;
+    endTimeMs: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    status: z.ZodObject<{
+        state: z.ZodEnum<{
+            ok: "ok";
+            error: "error";
+        }>;
+        error: z.ZodOptional<z.ZodObject<{
+            code: z.ZodOptional<z.ZodString>;
+            httpStatus: z.ZodOptional<z.ZodNumber>;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    instrumentation: z.ZodObject<{
+        provider: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
+        providerPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
+        sourceProvider: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
+        sourcePackage: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"@anthropic-ai/sdk">, z.ZodLiteral<"ai">]>;
+        sourceFunction: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    context: z.ZodObject<{
+        threadId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        agentGroupId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    additionalProperties: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    type: z.ZodLiteral<"tool">;
+    properties: z.ZodObject<{
+        tool: z.ZodObject<{
+            name: z.ZodString;
+            args: z.ZodOptional<z.ZodString>;
+            result: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+type T_EventAiUsage = z.infer<typeof Z_EventAiUsage>;
+type T_EventContext = z.infer<typeof Z_EventContext>;
+type T_EventAdditionalProperties = z.infer<typeof Z_EventAdditionalProperties>;
+type T_EventBase = z.infer<typeof Z_EventBase>;
+type T_EventStatus = T_EventBase["status"];
+type T_LLMEvent = z.infer<typeof Z_LLMEvent>;
+type T_ToolEvent = z.infer<typeof Z_ToolEvent>;
+type T_Event = z.infer<typeof Z_Event>;
+
+export type { T_LLMEvent as T, T_Event as a, T_ToolEvent as b, T_EventAiUsage as c, T_EventAdditionalProperties as d, T_EventContext as e, T_EventBase as f, T_EventStatus as g };

package/dist/internal/schema/events.mjs

@@ -0,0 +1,111 @@
+import { z } from "zod";
+const Z_EventAiUsage = z.object({
+  inputTokens: z.number(),
+  inputTokenDetails: z.object({
+    uncachedTokens: z.number(),
+    cacheReadTokens: z.number(),
+    cacheWriteTokens: z.number()
+  }),
+  outputTokens: z.number(),
+  outputTokenDetails: z.object({
+    reasoningTokens: z.number(),
+    responseTokens: z.number()
+  }),
+  totalTokens: z.number()
+});
+const Z_EventLlmCost = z.object({
+  inputUncachedUsd: z.number(),
+  inputCacheReadUsd: z.number(),
+  inputCacheWriteUsd: z.number(),
+  outputUsd: z.number(),
+  totalUsd: z.number()
+});
+const Z_EventContext = z.object({
+  threadId: z.string().optional(),
+  agentId: z.string().optional(),
+  agentGroupId: z.string().optional(),
+  userId: z.string().optional()
+});
+const Z_EventInstrumentation = z.object({
+  provider: z.union([z.literal("carbon")]),
+  providerPackage: z.union([z.literal("sdk")]).optional(),
+  sourceProvider: z.union([z.literal("openai"), z.literal("anthropic"), z.literal("vercel")]),
+  sourcePackage: z.union([z.literal("openai"), z.literal("@anthropic-ai/sdk"), z.literal("ai")]),
+  sourceFunction: z.string().optional()
+});
+const Z_EventAdditionalProperties = z.record(z.string(), z.union([z.string(), z.number()]));
+const Z_EventBase = z.object({
+  id: z.uuidv4(),
+  spaceId: z.string().optional(),
+  type: z.enum(["llm", "tool"]),
+  traceId: z.uuidv4().optional(),
+  startTimeMs: z.number(),
+  endTimeMs: z.number(),
+  durationMs: z.number(),
+  status: z.object({
+    state: z.enum(["ok", "error"]),
+    error: z.object({
+      code: z.string().optional(),
+      httpStatus: z.number().optional(),
+      message: z.string().optional()
+    }).optional()
+  }),
+  instrumentation: Z_EventInstrumentation,
+  context: Z_EventContext,
+  additionalProperties: Z_EventAdditionalProperties
+});
+const Z_LLMEvent = Z_EventBase.extend({
+  type: z.literal("llm"),
+  properties: z.object({
+    llm: z.object({
+      gateway: z.string().optional(),
+      provider: z.string().optional(),
+      model: z.string(),
+      input: z.object({
+        system: z.string(),
+        prompt: z.string(),
+        tools: z.array(
+          z.object({
+            name: z.string(),
+            description: z.string().optional()
+          })
+        )
+      }),
+      output: z.object({
+        mode: z.enum(["generate", "stream"]),
+        reasoning: z.string().optional(),
+        response: z.string().optional(),
+        toolCalls: z.array(
+          z.object({
+            name: z.string(),
+            args: z.string().optional()
+          })
+        )
+      }),
+      usage: Z_EventAiUsage,
+      cost: Z_EventLlmCost.optional()
+    })
+  })
+});
+const Z_ToolEvent = Z_EventBase.extend({
+  type: z.literal("tool"),
+  properties: z.object({
+    tool: z.object({
+      name: z.string(),
+      args: z.string().optional(),
+      result: z.string().optional()
+    })
+  })
+});
+const Z_Event = z.discriminatedUnion("type", [Z_LLMEvent, Z_ToolEvent]);
+export {
+  Z_Event,
+  Z_EventAdditionalProperties,
+  Z_EventAiUsage,
+  Z_EventBase,
+  Z_EventContext,
+  Z_EventInstrumentation,
+  Z_EventLlmCost,
+  Z_LLMEvent,
+  Z_ToolEvent
+};

package/dist/internal/schema/index.mjs

@@ -0,0 +1 @@
+export * from "./events.mjs";

package/dist/lib/constants.d.mts

@@ -0,0 +1,16 @@
+type T_Constants = {
+    api: {
+        baseUrl: string;
+        ingestPath: string;
+        retryMaxAttempts: number;
+        retryMaxElapsedMs: number;
+        timeoutMs: number;
+    };
+    buffer: {
+        batchSize: number;
+        maxTimeMs: number;
+    };
+};
+declare const CONSTANTS: T_Constants;
+
+export { CONSTANTS };

package/dist/lib/constants.mjs

@@ -0,0 +1,16 @@
+const CONSTANTS = {
+  api: {
+    baseUrl: "https://api.carbonrow.com",
+    ingestPath: "/v1/ingest-events",
+    retryMaxAttempts: 2,
+    retryMaxElapsedMs: 3e4,
+    timeoutMs: 15e3
+  },
+  buffer: {
+    batchSize: 50,
+    maxTimeMs: 5e3
+  }
+};
+export {
+  CONSTANTS
+};

package/dist/utils/ids.d.mts

@@ -0,0 +1,3 @@
+declare const generateId: () => `${string}-${string}-${string}-${string}-${string}`;
+
+export { generateId };

package/dist/utils/ids.mjs

@@ -0,0 +1,4 @@
+const generateId = () => crypto.randomUUID();
+export {
+  generateId
+};

package/dist/utils/promise.d.mts

@@ -0,0 +1,8 @@
+type T_IsPromiseLike = {
+    value: unknown;
+};
+declare const isPromiseLike: (args: T_IsPromiseLike) => args is T_IsPromiseLike & {
+    value: PromiseLike<unknown>;
+};
+
+export { isPromiseLike };

package/dist/utils/promise.mjs

@@ -0,0 +1,6 @@
+const isPromiseLike = (args) => {
+  return typeof args.value === "object" && args.value !== null && "then" in args.value && typeof args.value.then === "function";
+};
+export {
+  isPromiseLike
+};

package/dist/utils/retry.d.mts

@@ -0,0 +1,16 @@
+type T_Retry<T_Result> = {
+    initialDelayMs?: number;
+    jitterRatio?: number;
+    maxAttempts?: number;
+    maxDelayMs?: number;
+    maxElapsedMs?: number;
+    run: () => Promise<T_Result>;
+    shouldRetry?: (args: {
+        attempt: number;
+        error: unknown;
+    }) => boolean;
+    unrefDelay?: boolean;
+};
+declare const retry: <T_Result>(args: T_Retry<T_Result>) => Promise<T_Result>;
+
+export { retry };

package/dist/utils/retry.mjs

@@ -0,0 +1,47 @@
+const RETRY_DEFAULTS = {
+  initialDelayMs: 500,
+  jitterRatio: 0.2,
+  maxAttempts: 3,
+  maxDelayMs: 5e3,
+  maxElapsedMs: 15e3
+};
+const retry = async (args) => {
+  let attempt = 1;
+  const startedAtMs = Date.now();
+  while (true) {
+    try {
+      return await args.run();
+    } catch (error) {
+      const canRetry = args.shouldRetry?.({ attempt, error }) ?? true;
+      if (attempt >= (args.maxAttempts ?? RETRY_DEFAULTS.maxAttempts) || !canRetry) {
+        throw error;
+      }
+      const remainingMs = getRemainingElapsedBudgetMs({
+        maxElapsedMs: args.maxElapsedMs ?? RETRY_DEFAULTS.maxElapsedMs,
+        startedAtMs
+      });
+      if (remainingMs <= 0) {
+        throw error;
+      }
+      const initialDelayMs = args.initialDelayMs ?? RETRY_DEFAULTS.initialDelayMs;
+      const jitterRatio = args.jitterRatio ?? RETRY_DEFAULTS.jitterRatio;
+      const maxDelayMs = args.maxDelayMs ?? RETRY_DEFAULTS.maxDelayMs;
+      const baseDelayMs = Math.min(initialDelayMs * 2 ** (attempt - 1), maxDelayMs);
+      const jitterMs = baseDelayMs * jitterRatio;
+      const delayMs = jitterRatio <= 0 ? baseDelayMs : Math.round(baseDelayMs - jitterMs + Math.random() * jitterMs * 2);
+      await new Promise((resolve) => {
+        const timeout = setTimeout(resolve, Math.min(delayMs, remainingMs));
+        if (args.unrefDelay) {
+          timeout.unref?.();
+        }
+      });
+      attempt += 1;
+    }
+  }
+};
+function getRemainingElapsedBudgetMs(args) {
+  return args.maxElapsedMs - (Date.now() - args.startedAtMs);
+}
+export {
+  retry
+};

package/dist/utils/stringify.d.mts

@@ -0,0 +1,6 @@
+type T_Stringify = {
+    value: unknown;
+};
+declare const stringify: (args: T_Stringify) => string;
+
+export { stringify };

package/dist/utils/stringify.mjs

@@ -0,0 +1,16 @@
+const stringify = (args) => {
+  if (args.value === null || args.value === void 0) {
+    return "";
+  }
+  if (typeof args.value === "string") {
+    return args.value;
+  }
+  try {
+    return JSON.stringify(args.value);
+  } catch {
+    return String(args.value);
+  }
+};
+export {
+  stringify
+};

package/dist/utils/timeout.d.mts

@@ -0,0 +1,9 @@
+type T_RunWithTimeout<T_Result> = {
+    run: (args: {
+        signal: AbortSignal;
+    }) => Promise<T_Result>;
+    timeoutMs: number;
+};
+declare const runWithTimeout: <T_Result>(args: T_RunWithTimeout<T_Result>) => Promise<T_Result>;
+
+export { runWithTimeout };

package/dist/utils/timeout.mjs

@@ -0,0 +1,27 @@
+const runWithTimeout = async (args) => {
+  if (!Number.isInteger(args.timeoutMs) || args.timeoutMs <= 0) {
+    throw new Error("timeoutMs must be a positive integer.");
+  }
+  const controller = new AbortController();
+  let timeout;
+  const timeoutPromise = new Promise((_, reject) => {
+    timeout = setTimeout(() => {
+      controller.abort();
+      reject(new Error(`Operation timed out after ${args.timeoutMs}ms.`));
+    }, args.timeoutMs);
+    timeout.unref?.();
+  });
+  try {
+    return await Promise.race([
+      args.run({
+        signal: controller.signal
+      }),
+      timeoutPromise
+    ]);
+  } finally {
+    clearTimeout(timeout);
+  }
+};
+export {
+  runWithTimeout
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@carbon-js/sdk",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./ai": {
+      "types": "./dist/ai.d.mts",
+      "default": "./dist/ai.mjs"
+    }
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "README.md",
+    "dist"
+  ],
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.79",
+    "@ai-sdk/openai": "^3.0.65",
+    "@anthropic-ai/sdk": "^0.96.0",
+    "ai": "^6.0.177",
+    "openai": "^6.37.0",
+    "zod": "^4.4.3"
+  }
+}