@carbon-js/sdk 0.0.2 → 0.0.4

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

@@ -3,6 +3,7 @@ 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';
 
+type T_LlmOutput = NonNullable<T_LLMEvent["properties"]["llm"]["output"]>;
 declare class AnthropicEventFactory {
     private readonly carbonObject?;
     constructor(args: {
@@ -12,7 +13,7 @@ declare class AnthropicEventFactory {
         body: MessageCreateParamsBase;
         endTimeMs: number;
         message?: Message;
-        mode?: T_LLMEvent["properties"]["llm"]["output"]["mode"];
+        mode?: T_LlmOutput["mode"];
         sourceFunction?: string;
         startTimeMs: number;
         status: T_LLMEvent["status"];

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

@@ -75,7 +75,9 @@ function getToolDescriptions(args) {
 }
 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 });
+  return stringify({
+    value: thinking && thinking.length > 0 ? thinking : void 0
+  });
 }
 function getResponseText(args) {
   if (!args.content) {
@@ -88,7 +90,7 @@ function getToolCalls(args) {
     return [];
   }
   return args.content.filter((block) => block.type === "tool_use" || block.type === "server_tool_use").map((block) => ({
-    args: stringify({ value: block.input }),
+    input: stringify({ value: block.input }),
     name: block.name
   }));
 }

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

@@ -4,6 +4,7 @@ import { ChatCompletionCreateParamsBase, ChatCompletion } from 'openai/resources
 import { ResponseCreateParamsBase, Response } from 'openai/resources/responses/responses';
 import 'zod';
 
+type T_LlmOutput = NonNullable<T_LLMEvent["properties"]["llm"]["output"]>;
 declare class OpenAIEventFactory {
     private readonly carbonObject?;
     constructor(args: {
@@ -12,7 +13,7 @@ declare class OpenAIEventFactory {
     createResponseEvents(args: {
         body: Partial<ResponseCreateParamsBase>;
         endTimeMs: number;
-        mode?: T_LLMEvent["properties"]["llm"]["output"]["mode"];
+        mode?: T_LlmOutput["mode"];
         response?: Response;
         sourceFunction?: string;
         startTimeMs: number;
@@ -22,7 +23,7 @@ declare class OpenAIEventFactory {
         body: ChatCompletionCreateParamsBase;
         completion?: ChatCompletion;
         endTimeMs: number;
-        mode?: T_LLMEvent["properties"]["llm"]["output"]["mode"];
+        mode?: T_LlmOutput["mode"];
         sourceFunction?: string;
         startTimeMs: number;
         status: T_LLMEvent["status"];

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

@@ -25,7 +25,9 @@ class OpenAIEventFactory {
           input: this.createResponseLlmInput({ body: args.body }),
           output: {
             mode: args.mode ?? "generate",
-            reasoning: stringify({ value: getResponseReasoning({ response: args.response }) }),
+            reasoning: stringify({
+              value: getResponseReasoning({ response: args.response })
+            }),
             response: getResponseOutputText({ response: args.response }),
             toolCalls: getResponseToolCalls({ response: args.response })
           },
@@ -56,9 +58,13 @@ class OpenAIEventFactory {
           output: {
             mode: args.mode ?? "generate",
             reasoning: "",
-            response: stringify({ value: args.completion?.choices[0]?.message.content }),
+            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 }),
+              input: stringify({
+                value: toolCall.type === "function" ? toolCall.function.arguments : toolCall.custom.input
+              }),
               name: toolCall.type === "function" ? toolCall.function.name : toolCall.custom.name
             })) ?? []
           },
@@ -83,7 +89,9 @@ class OpenAIEventFactory {
     );
     return {
       prompt: stringify({ value: args.body.messages }),
-      system: stringify({ value: systemMessages.length > 0 ? systemMessages : void 0 }),
+      system: stringify({
+        value: systemMessages.length > 0 ? systemMessages : void 0
+      }),
       tools: getChatCompletionToolDescriptions({ tools: args.body.tools })
     };
   }
@@ -168,7 +176,7 @@ function getResponseToolCalls(args) {
     if (output.type === "function_call") {
       return [
         {
-          args: output.arguments,
+          input: output.arguments,
           name: output.name
         }
       ];
@@ -176,7 +184,7 @@ function getResponseToolCalls(args) {
     if (output.type === "custom_tool_call") {
       return [
         {
-          args: output.input,
+          input: output.input,
           name: output.name
         }
       ];

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

@@ -18,7 +18,10 @@ function createWrappedChatCompletionRunTools(args) {
     const startTimeMs = Date.now();
     let runner;
     try {
-      runner = runTools(bodyWithInternalCapture, requestOptions);
+      runner = runTools(
+        bodyWithInternalCapture,
+        requestOptions
+      );
     } catch (error) {
       args.carbon.captureEvents({
         events: factory.createChatCompletionEvents({
@@ -85,9 +88,9 @@ function attachRunToolsCapture(args) {
           startTimeMs: toolCall?.startTimeMs ?? endTimeMs,
           status: createOkStatus(),
           tool: {
-            args: toolCall?.args ?? "",
+            input: toolCall?.args ?? "",
             name: toolCall?.name ?? "unknown",
-            result: stringify({ value: result })
+            output: stringify({ value: result })
           },
           traceId: args.carbonObject?.traceId
         })

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

@@ -7,11 +7,11 @@ 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"];
+    input: NonNullable<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"];
+    input: T_ToolEvent["properties"]["tool"]["input"];
     toolName: T_ToolEvent["properties"]["tool"]["name"];
 };
 declare class VercelEventFactory {

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

@@ -34,7 +34,9 @@ class VercelEventFactory {
         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 }),
+        system: stringify({
+          value: "system" in args.event ? args.event.system : void 0
+        }),
         tools: getToolDescriptions({
           tools: "tools" in args.event ? args.event.tools : void 0
         })
@@ -46,8 +48,8 @@ class VercelEventFactory {
   }
   createPendingToolEvent(args) {
     return {
-      args: stringify({ value: args.event.toolCall.input }),
       id: generateId(),
+      input: stringify({ value: args.event.toolCall.input }),
       startTimeMs: args.startTimeMs ?? Date.now(),
       toolName: args.event.toolCall.toolName
     };
@@ -72,7 +74,7 @@ class VercelEventFactory {
           reasoning: stringify({ value: args.event?.reasoningText }),
           response: stringify({ value: args.event?.text }),
           toolCalls: args.event?.toolCalls.map((toolCall) => ({
-            args: stringify({ value: toolCall.input }),
+            input: stringify({ value: toolCall.input }),
             name: toolCall.toolName
           })) ?? []
         },
@@ -97,9 +99,9 @@ class VercelEventFactory {
       startTimeMs: args.pendingTool.startTimeMs,
       status: args.status,
       tool: {
-        args: args.pendingTool.args,
+        input: args.pendingTool.input,
         name: args.pendingTool.toolName,
-        result: stringify({ value: args.output })
+        output: stringify({ value: args.output })
       },
       traceId: this.traceId
     });

package/dist/core/carbon.d.mts

@@ -21,7 +21,7 @@ declare class Carbon {
     }): void;
     createTraceId(): `${string}-${string}-${string}-${string}-${string}`;
     wrapTool<T_Args extends unknown[], T_Result>(args: T_WrapToolArgs<T_Args, T_Result>): (...callArgs: [...T_Args, (T_CarbonObject | undefined)?]) => T_Result;
-    flushPendingTraces(): Promise<void>;
+    flushPendingEvents(): Promise<void>;
 }
 
 export { Carbon, type T_CarbonOptions, T_WrapToolArgs };

package/dist/core/carbon.mjs

@@ -26,7 +26,7 @@ class Carbon {
       }
     });
   }
-  flushPendingTraces() {
+  flushPendingEvents() {
     return this.runtime.shutdown();
   }
 }

package/dist/core/events/event-buffer.d.mts

@@ -9,6 +9,9 @@ declare class EventBuffer {
     drain(args?: {
         count?: number;
     }): T_Event[];
+    peek(args?: {
+        count?: number;
+    }): T_Event[];
     prepend(args: {
         events: T_Event[];
     }): void;

package/dist/core/events/event-buffer.mjs

@@ -6,6 +6,9 @@ class EventBuffer {
   drain(args = {}) {
     return this.pendingEvents.splice(0, args.count ?? this.pendingEvents.length);
   }
+  peek(args = {}) {
+    return this.pendingEvents.slice(0, args.count ?? this.pendingEvents.length);
+  }
   prepend(args) {
     this.pendingEvents.unshift(...args.events);
   }

package/dist/core/runtime.d.mts

@@ -2,33 +2,51 @@ import { a as T_Event } from '../internal/schema/events.mjs';
 import { T_EventTransport } from './transport/types.mjs';
 import 'zod';
 
+type T_CarbonErrorContext = {
+    disposition: "dropped" | "retained";
+    error: unknown;
+    events: T_Event[];
+};
 type T_CarbonRuntimeOptions = {
     baseUrl?: string;
     apiKey?: string;
     bufferBatchSize?: number;
+    bufferMaxBatchBytes?: number;
     bufferMaxTimeMs?: number;
+    maxBufferedEvents?: number;
+    onError?: (args: T_CarbonErrorContext) => void;
     transport?: T_EventTransport;
 };
-type T_RecordEvents = {
-    events: T_Event[];
-};
 declare class CarbonRuntime {
     private readonly buffer;
     private readonly bufferBatchSize;
+    private readonly bufferMaxBatchBytes;
     private readonly bufferMaxTimeMs;
+    private readonly maxBufferedEvents;
+    private readonly onError?;
     private readonly transport;
+    private readonly warnedAtMsByKey;
     private flushPromise;
     private flushTimer;
     private isShuttingDown;
     constructor(args: T_CarbonRuntimeOptions);
-    recordEvents(args: T_RecordEvents): void;
+    recordEvents(args: {
+        events: T_Event[];
+    }): void;
     flush(): Promise<void>;
     shutdown(): Promise<void>;
     private flushNextBatch;
     private sendDrainedEvents;
+    private enforceBufferCap;
+    private reportError;
     private flushOrSchedule;
     private scheduleFlush;
     private clearFlushTimer;
+    private shouldFlushBeforeAdding;
+    private assertEventFitsBatch;
+    private drainNextTransportBatch;
+    private peekNextTransportBatch;
+    private getBatchBytes;
 }
 
-export { CarbonRuntime, type T_CarbonRuntimeOptions };
+export { CarbonRuntime, type T_CarbonErrorContext, type T_CarbonRuntimeOptions };

package/dist/core/runtime.mjs

@@ -1,24 +1,40 @@
 import { EventBuffer } from "./events/event-buffer.mjs";
 import { CONSTANTS } from "../lib/constants.mjs";
-import { HttpTransport } from "./transport/http-transport.mjs";
-import { Z_Event } from "../internal/schema/index.mjs";
+import { CarbonIngestError, HttpTransport } from "./transport/http-transport.mjs";
+import { Z_Event } from "../internal/schema/events.mjs";
 class CarbonRuntime {
   buffer = new EventBuffer();
   bufferBatchSize;
+  bufferMaxBatchBytes;
   bufferMaxTimeMs;
+  maxBufferedEvents;
+  onError;
   transport;
+  warnedAtMsByKey = /* @__PURE__ */ new Map();
   flushPromise = null;
   flushTimer = null;
   isShuttingDown = false;
   constructor(args) {
     this.bufferBatchSize = args.bufferBatchSize ?? CONSTANTS.buffer.batchSize;
+    this.bufferMaxBatchBytes = args.bufferMaxBatchBytes ?? CONSTANTS.buffer.maxBatchBytes;
     this.bufferMaxTimeMs = args.bufferMaxTimeMs ?? CONSTANTS.buffer.maxTimeMs;
+    this.maxBufferedEvents = args.maxBufferedEvents ?? CONSTANTS.buffer.maxBufferedEvents;
+    this.onError = args.onError;
     if (!Number.isInteger(this.bufferBatchSize) || this.bufferBatchSize <= 0) {
       throw new Error("batchSize must be a positive integer.");
     }
+    if (!Number.isFinite(this.bufferMaxBatchBytes) || this.bufferMaxBatchBytes <= 0) {
+      throw new Error("maxBatchBytes must be greater than 0.");
+    }
+    if (this.bufferMaxBatchBytes > CONSTANTS.buffer.maxBatchBytes) {
+      throw new Error("maxBatchBytes must not exceed the SDK batch limit.");
+    }
     if (!Number.isFinite(this.bufferMaxTimeMs) || this.bufferMaxTimeMs < 0) {
       throw new Error("maxBufferTimeMs must be greater than or equal to 0.");
     }
+    if (!Number.isInteger(this.maxBufferedEvents) || this.maxBufferedEvents <= 0) {
+      throw new Error("maxBufferedEvents must be a positive integer.");
+    }
     this.transport = args.transport ?? new HttpTransport({
       apiKey: args.apiKey,
       baseUrl: args.baseUrl
@@ -26,7 +42,14 @@ class CarbonRuntime {
   }
   recordEvents(args) {
     const events = args.events.map((event) => Z_Event.parse(event));
-    this.buffer.add({ events });
+    events.forEach((event) => this.assertEventFitsBatch({ event }));
+    for (const event of events) {
+      if (this.shouldFlushBeforeAdding({ event })) {
+        void this.flush().catch(() => void 0);
+      }
+      this.buffer.add({ events: [event] });
+    }
+    this.enforceBufferCap();
     this.flushOrSchedule();
   }
   async flush() {
@@ -54,7 +77,7 @@ class CarbonRuntime {
     if (this.buffer.length === 0) {
       return;
     }
-    const events = this.buffer.drain({ count: this.bufferBatchSize });
+    const events = this.drainNextTransportBatch();
     this.flushPromise = this.sendDrainedEvents({
       allowBackgroundScheduling: args.allowBackgroundScheduling,
       events
@@ -62,7 +85,7 @@ class CarbonRuntime {
     return this.flushPromise;
   }
   async sendDrainedEvents(args) {
-    let didSend = false;
+    let didSettleBatch = false;
     let shouldRetry = false;
     try {
       await this.transport.sendBatch({
@@ -70,24 +93,59 @@ class CarbonRuntime {
           events: args.events
         }
       });
-      didSend = true;
+      didSettleBatch = true;
     } catch (error) {
+      shouldRetry = isRetryableTransportError(error);
+      if (!shouldRetry) {
+        didSettleBatch = true;
+        this.reportError({ disposition: "dropped", error, events: args.events });
+        return;
+      }
       this.buffer.prepend({ events: args.events });
-      const retryable = typeof error === "object" && error !== null && "retryable" in error ? error.retryable : true;
-      shouldRetry = typeof retryable === "boolean" ? retryable : true;
+      this.reportError({ disposition: "retained", error, events: args.events });
+      this.enforceBufferCap();
       throw error;
     } finally {
       this.flushPromise = null;
       const canScheduleBackgroundFlush = args.allowBackgroundScheduling && !this.isShuttingDown;
       if (shouldRetry && canScheduleBackgroundFlush) {
         this.scheduleFlush({ delayMs: this.bufferMaxTimeMs });
-      } else if (didSend && canScheduleBackgroundFlush) {
+      } else if (didSettleBatch && canScheduleBackgroundFlush) {
         this.flushOrSchedule();
       }
     }
   }
+  enforceBufferCap() {
+    const overflowCount = this.buffer.length - this.maxBufferedEvents;
+    if (overflowCount <= 0) {
+      return;
+    }
+    const droppedEvents = this.buffer.drain({ count: overflowCount });
+    this.reportError({
+      disposition: "dropped",
+      error: new Error("Carbon event buffer is full. Oldest events were dropped."),
+      events: droppedEvents
+    });
+  }
+  reportError(args) {
+    if (this.onError) {
+      try {
+        this.onError(args);
+      } catch {
+      }
+      return;
+    }
+    const key = getErrorKey(args.error);
+    const lastWarnedAtMs = this.warnedAtMsByKey.get(key);
+    if (lastWarnedAtMs !== void 0 && Date.now() - lastWarnedAtMs < CONSTANTS.errors.warnThrottleMs) {
+      return;
+    }
+    this.warnedAtMsByKey.set(key, Date.now());
+    console.warn(formatErrorWarning(args));
+  }
   flushOrSchedule() {
-    if (this.buffer.length >= this.bufferBatchSize) {
+    const nextTransportBatch = this.peekNextTransportBatch();
+    if (this.buffer.length >= this.bufferBatchSize || nextTransportBatch.length < this.buffer.length || this.getBatchBytes({ events: nextTransportBatch }) >= this.bufferMaxBatchBytes) {
       void this.flush().catch(() => void 0);
       return;
     }
@@ -113,6 +171,68 @@ class CarbonRuntime {
     clearTimeout(this.flushTimer);
     this.flushTimer = null;
   }
+  shouldFlushBeforeAdding(args) {
+    if (this.buffer.length === 0) {
+      return false;
+    }
+    if (this.buffer.length >= this.bufferBatchSize) {
+      return true;
+    }
+    const events = [...this.buffer.peek({ count: this.bufferBatchSize - 1 }), args.event];
+    return events.length > this.bufferBatchSize || this.getBatchBytes({ events }) > this.bufferMaxBatchBytes;
+  }
+  assertEventFitsBatch(args) {
+    if (this.getBatchBytes({ events: [args.event] }) > this.bufferMaxBatchBytes) {
+      throw new Error("Event exceeds maxBatchBytes.");
+    }
+  }
+  drainNextTransportBatch() {
+    for (let count = Math.min(this.bufferBatchSize, this.buffer.length); count > 0; count -= 1) {
+      const events = this.buffer.peek({ count });
+      if (this.getBatchBytes({ events }) <= this.bufferMaxBatchBytes) {
+        return this.buffer.drain({ count });
+      }
+    }
+    throw new Error("Buffered event exceeds maxBatchBytes.");
+  }
+  peekNextTransportBatch() {
+    for (let count = Math.min(this.bufferBatchSize, this.buffer.length); count > 0; count -= 1) {
+      const events = this.buffer.peek({ count });
+      if (this.getBatchBytes({ events }) <= this.bufferMaxBatchBytes) {
+        return events;
+      }
+    }
+    return [];
+  }
+  getBatchBytes(args) {
+    return new TextEncoder().encode(
+      JSON.stringify({
+        events: args.events
+      })
+    ).byteLength;
+  }
+}
+function isRetryableTransportError(error) {
+  if (typeof error === "object" && error !== null && "retryable" in error) {
+    return typeof error.retryable === "boolean" ? error.retryable : true;
+  }
+  return true;
+}
+function getErrorKey(error) {
+  if (error instanceof CarbonIngestError) {
+    return error.errorId ?? String(error.status);
+  }
+  if (error instanceof Error) {
+    return `${error.name}:${error.message}`;
+  }
+  return String(error);
+}
+function formatErrorWarning(args) {
+  const message = args.error instanceof Error ? args.error.message : String(args.error);
+  if (args.disposition === "dropped") {
+    return `Carbon dropped ${args.events.length} event(s): ${message}`;
+  }
+  return `Carbon failed to deliver ${args.events.length} event(s) and will retry: ${message}`;
 }
 export {
   CarbonRuntime

package/dist/core/tools/wrap-tool.mjs

@@ -96,9 +96,9 @@ function captureToolResult(args) {
       status: args.status ?? createOkStatus(),
       traceId: args.carbon?.traceId,
       tool: {
-        args: stringify({ value: serializeToolArgs({ args: args.args }) }),
+        input: stringify({ value: serializeToolArgs({ args: args.args }) }),
         name: args.name,
-        result: stringify({ value: args.result })
+        output: stringify({ value: args.result })
       }
     })
   });

package/dist/core/transport/http-transport.d.mts

@@ -10,9 +10,13 @@ type T_HttpTransport = {
     timeoutMs?: number;
 };
 declare class CarbonIngestError extends Error {
+    readonly details?: string;
+    readonly errorId?: string;
     readonly retryable: boolean;
     readonly status: number;
     constructor(args: {
+        details?: string;
+        errorId?: string;
         status: number;
     });
 }

package/dist/core/transport/http-transport.mjs

@@ -2,11 +2,17 @@ import { CONSTANTS } from "../../lib/constants.mjs";
 import { retry } from "../../utils/retry.mjs";
 import { runWithTimeout } from "../../utils/timeout.mjs";
 class CarbonIngestError extends Error {
+  details;
+  errorId;
   retryable;
   status;
   constructor(args) {
-    super(`Carbon ingest failed with status ${args.status}`);
+    super(
+      args.details ? `Carbon ingest failed with status ${args.status}: ${args.details}` : `Carbon ingest failed with status ${args.status}`
+    );
     this.name = "CarbonIngestError";
+    this.details = args.details;
+    this.errorId = args.errorId;
     this.status = args.status;
     this.retryable = [408, 409, 425, 429].includes(args.status) || args.status >= 500;
   }
@@ -51,7 +57,10 @@ class HttpTransport {
               signal
             });
             if (!response.ok) {
-              throw new CarbonIngestError({ status: response.status });
+              throw new CarbonIngestError({
+                status: response.status,
+                ...await parseIngestErrorBody({ response })
+              });
             }
           }
         });
@@ -60,6 +69,17 @@ class HttpTransport {
     });
   }
 }
+async function parseIngestErrorBody({ response }) {
+  try {
+    const body = await response.json();
+    return {
+      details: typeof body.error?.details === "string" ? body.error.details : void 0,
+      errorId: typeof body.error?.id === "string" ? body.error.id : void 0
+    };
+  } catch {
+    return {};
+  }
+}
 function getApiKey(args) {
   const apiKey = args.apiKey ?? process.env.CARBON_API_KEY;
   if (!apiKey) {

package/dist/core/utils/build-events.mjs

@@ -1,6 +1,6 @@
 import { generateId } from "../../utils/ids.mjs";
 import { createSdkInstrumentation } from "./instrumentation.mjs";
-import { Z_Event } from "../../internal/schema/index.mjs";
+import { Z_Event } from "../../internal/schema/events.mjs";
 const EMPTY_AI_USAGE = {
   inputTokenDetails: {
     cacheReadTokens: 0,

package/dist/index.d.mts

@@ -1,10 +1,10 @@
 export { Carbon, T_CarbonOptions } from './core/carbon.mjs';
+export { T_CarbonErrorContext } from './core/runtime.mjs';
 export { T_CarbonContext, T_CarbonObject } from './core/schema/carbon-object.mjs';
 export { FileTransport } from './core/transport/file-transport.mjs';
 export { CarbonIngestError, HttpTransport } from './core/transport/http-transport.mjs';
 export { MemoryTransport } from './core/transport/memory-transport.mjs';
 export { T_EventBatch, T_EventTransport } from './core/transport/types.mjs';
 export { T_WrapToolArgs } from './core/tools/wrap-tool.mjs';
-import './core/runtime.mjs';
 import './internal/schema/events.mjs';
 import 'zod';

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

@@ -96,15 +96,15 @@ declare const Z_LLMEvent: z.ZodObject<{
             gateway: z.ZodOptional<z.ZodString>;
             provider: z.ZodOptional<z.ZodString>;
             model: z.ZodString;
-            input: z.ZodObject<{
+            input: z.ZodOptional<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<{
+            }, z.core.$strip>>;
+            output: z.ZodOptional<z.ZodObject<{
                 mode: z.ZodEnum<{
                     generate: "generate";
                     stream: "stream";
@@ -113,9 +113,9 @@ declare const Z_LLMEvent: z.ZodObject<{
                 response: z.ZodOptional<z.ZodString>;
                 toolCalls: z.ZodArray<z.ZodObject<{
                     name: z.ZodString;
-                    args: z.ZodOptional<z.ZodString>;
+                    input: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
-            }, z.core.$strip>;
+            }, z.core.$strip>>;
             usage: z.ZodObject<{
                 inputTokens: z.ZodNumber;
                 inputTokenDetails: z.ZodObject<{
@@ -176,8 +176,8 @@ declare const Z_ToolEvent: z.ZodObject<{
     properties: z.ZodObject<{
         tool: z.ZodObject<{
             name: z.ZodString;
-            args: z.ZodOptional<z.ZodString>;
-            result: z.ZodOptional<z.ZodString>;
+            input: z.ZodOptional<z.ZodString>;
+            output: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
     }, z.core.$strip>;
 }, z.core.$strip>;
@@ -219,15 +219,15 @@ declare const Z_Event: z.ZodDiscriminatedUnion<[z.ZodObject<{
             gateway: z.ZodOptional<z.ZodString>;
             provider: z.ZodOptional<z.ZodString>;
             model: z.ZodString;
-            input: z.ZodObject<{
+            input: z.ZodOptional<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<{
+            }, z.core.$strip>>;
+            output: z.ZodOptional<z.ZodObject<{
                 mode: z.ZodEnum<{
                     generate: "generate";
                     stream: "stream";
@@ -236,9 +236,9 @@ declare const Z_Event: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 response: z.ZodOptional<z.ZodString>;
                 toolCalls: z.ZodArray<z.ZodObject<{
                     name: z.ZodString;
-                    args: z.ZodOptional<z.ZodString>;
+                    input: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
-            }, z.core.$strip>;
+            }, z.core.$strip>>;
             usage: z.ZodObject<{
                 inputTokens: z.ZodNumber;
                 inputTokenDetails: z.ZodObject<{
@@ -298,8 +298,8 @@ declare const Z_Event: z.ZodDiscriminatedUnion<[z.ZodObject<{
     properties: z.ZodObject<{
         tool: z.ZodObject<{
             name: z.ZodString;
-            args: z.ZodOptional<z.ZodString>;
-            result: z.ZodOptional<z.ZodString>;
+            input: z.ZodOptional<z.ZodString>;
+            output: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
     }, z.core.$strip>;
 }, z.core.$strip>], "type">;

package/dist/internal/schema/events.mjs

@@ -70,7 +70,7 @@ const Z_LLMEvent = Z_EventBase.extend({
             description: z.string().optional()
           })
         )
-      }),
+      }).optional(),
       output: z.object({
         mode: z.enum(["generate", "stream"]),
         reasoning: z.string().optional(),
@@ -78,10 +78,10 @@ const Z_LLMEvent = Z_EventBase.extend({
         toolCalls: z.array(
           z.object({
             name: z.string(),
-            args: z.string().optional()
+            input: z.string().optional()
           })
         )
-      }),
+      }).optional(),
       usage: Z_EventAiUsage,
       cost: Z_EventLlmCost.optional()
     })
@@ -92,8 +92,8 @@ const Z_ToolEvent = Z_EventBase.extend({
   properties: z.object({
     tool: z.object({
       name: z.string(),
-      args: z.string().optional(),
-      result: z.string().optional()
+      input: z.string().optional(),
+      output: z.string().optional()
     })
   })
 });

package/dist/lib/constants.d.mts

@@ -8,8 +8,13 @@ type T_Constants = {
     };
     buffer: {
         batchSize: number;
+        maxBatchBytes: number;
+        maxBufferedEvents: number;
         maxTimeMs: number;
     };
+    errors: {
+        warnThrottleMs: number;
+    };
 };
 declare const CONSTANTS: T_Constants;
 

package/dist/lib/constants.mjs

@@ -1,6 +1,6 @@
 const CONSTANTS = {
   api: {
-    baseUrl: "https://api.carbonrow.com",
+    baseUrl: "https://ingest.oncarbon.site",
     ingestPath: "/v1/ingest-events",
     retryMaxAttempts: 2,
     retryMaxElapsedMs: 3e4,
@@ -8,7 +8,12 @@ const CONSTANTS = {
   },
   buffer: {
     batchSize: 50,
+    maxBatchBytes: 3.5 * 1024 * 1024,
+    maxBufferedEvents: 5e3,
     maxTimeMs: 5e3
+  },
+  errors: {
+    warnThrottleMs: 6e4
   }
 };
 export {

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@carbon-js/sdk",
-  "version": "0.0.2",
+  "version": "0.0.4",
+  "license": "MIT",
   "type": "module",
   "exports": {
     ".": {
@@ -18,8 +19,6 @@
     "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",

package/dist/internal/schema/index.mjs

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