@carbon-js/sdk 0.0.1

package/dist/ai/vercel/recorder.mjs

@@ -0,0 +1,194 @@
+import { createErrorStatus, createOkStatus } from "../../core/utils/build-events.mjs";
+import {
+  VercelEventFactory
+} from "./event-factory.mjs";
+import { bindTelemetryIntegration } from "ai";
+class VercelRecorder {
+  completedEvents = [];
+  factory;
+  llmEventsByStep = /* @__PURE__ */ new Map();
+  carbon;
+  toolEventsById = /* @__PURE__ */ new Map();
+  isRecorded = false;
+  startTimeMs = Date.now();
+  constructor(args) {
+    this.factory = new VercelEventFactory({
+      carbonObject: args.carbonObject,
+      mode: args.mode,
+      sourceFunction: args.sourceFunction
+    });
+    this.carbon = args.carbon;
+  }
+  createIntegration() {
+    return bindTelemetryIntegration({
+      onStart: () => {
+        this.startTimeMs = Date.now();
+      },
+      onStepStart: (event) => {
+        this.getPendingLlmEvent({ event });
+      },
+      onToolCallStart: (event) => {
+        this.getPendingToolEvent({ event });
+      },
+      onToolCallFinish: (event) => {
+        this.onToolCallFinish(event);
+      },
+      onStepFinish: (event) => {
+        this.closePendingLlmEvent({
+          endTimeMs: Date.now(),
+          event,
+          status: createOkStatus()
+        });
+      },
+      onFinish: (event) => {
+        this.onFinish(event);
+      }
+    });
+  }
+  recordError(args) {
+    if (this.isRecorded) {
+      return;
+    }
+    const endTimeMs = Date.now();
+    const status = createErrorStatus({ error: args.error });
+    for (const pendingTool of this.toolEventsById.values()) {
+      this.completedEvents.push(
+        this.factory.createCompletedToolEvent({
+          endTimeMs,
+          output: args.error,
+          pendingTool,
+          status
+        })
+      );
+    }
+    this.toolEventsById.clear();
+    for (const pendingLlm of this.llmEventsByStep.values()) {
+      this.completedEvents.push(
+        this.factory.createCompletedLlmEvent({
+          endTimeMs,
+          pendingLlm,
+          status
+        })
+      );
+    }
+    this.llmEventsByStep.clear();
+    if (this.completedEvents.length === 0) {
+      this.completedEvents.push(
+        this.factory.createCompletedLlmEvent({
+          endTimeMs,
+          pendingLlm: this.factory.createFallbackPendingLlmEvent({
+            startTimeMs: this.startTimeMs
+          }),
+          status
+        })
+      );
+    }
+    this.recordEvents();
+  }
+  onToolCallFinish(event) {
+    const pendingTool = this.getPendingToolEvent({
+      event,
+      startTimeMs: Date.now() - event.durationMs
+    });
+    this.completedEvents.push(
+      this.factory.createCompletedToolEvent({
+        endTimeMs: Date.now(),
+        output: event.success ? event.output : event.error,
+        pendingTool,
+        status: event.success ? createOkStatus() : createErrorStatus({ error: event.error })
+      })
+    );
+    this.toolEventsById.delete(event.toolCall.toolCallId);
+  }
+  onFinish(event) {
+    if (this.isRecorded) {
+      return;
+    }
+    const endTimeMs = Date.now();
+    for (const [stepNumber, pendingLlm] of this.llmEventsByStep) {
+      this.completedEvents.push(
+        this.factory.createCompletedLlmEvent({
+          endTimeMs,
+          event: event.steps.find((step) => step.stepNumber === stepNumber) ?? event,
+          pendingLlm,
+          status: createOkStatus()
+        })
+      );
+    }
+    this.llmEventsByStep.clear();
+    if (!this.completedEvents.some((completedEvent) => completedEvent.type === "llm")) {
+      this.completedEvents.push(
+        this.factory.createCompletedLlmEvent({
+          endTimeMs,
+          event,
+          pendingLlm: this.factory.createPendingLlmEvent({
+            event,
+            startTimeMs: this.startTimeMs
+          }),
+          status: createOkStatus()
+        })
+      );
+    }
+    this.recordEvents();
+  }
+  recordEvents() {
+    this.isRecorded = true;
+    this.carbon.captureEvents({
+      events: [...this.completedEvents].sort((a, b) => {
+        if (a.startTimeMs !== b.startTimeMs) {
+          return a.startTimeMs - b.startTimeMs;
+        }
+        const aPriority = a.type === "llm" ? 0 : 1;
+        const bPriority = b.type === "llm" ? 0 : 1;
+        return aPriority - bPriority;
+      })
+    });
+  }
+  getPendingLlmEvent(args) {
+    const stepNumber = args.event.stepNumber ?? 0;
+    const existing = this.llmEventsByStep.get(stepNumber);
+    if (existing) {
+      return existing;
+    }
+    const pendingLlm = this.factory.createPendingLlmEvent({
+      event: args.event,
+      startTimeMs: args.startTimeMs
+    });
+    this.llmEventsByStep.set(stepNumber, pendingLlm);
+    return pendingLlm;
+  }
+  getPendingToolEvent(args) {
+    const existing = this.toolEventsById.get(args.event.toolCall.toolCallId);
+    if (existing) {
+      return existing;
+    }
+    this.getPendingLlmEvent({
+      event: args.event,
+      startTimeMs: args.startTimeMs
+    });
+    const pendingTool = this.factory.createPendingToolEvent({
+      event: args.event,
+      startTimeMs: args.startTimeMs
+    });
+    this.toolEventsById.set(args.event.toolCall.toolCallId, pendingTool);
+    return pendingTool;
+  }
+  closePendingLlmEvent(args) {
+    const stepNumber = args.event.stepNumber;
+    const pendingLlm = this.llmEventsByStep.get(stepNumber) ?? this.getPendingLlmEvent({
+      event: args.event
+    });
+    this.completedEvents.push(
+      this.factory.createCompletedLlmEvent({
+        endTimeMs: args.endTimeMs,
+        event: args.event,
+        pendingLlm,
+        status: args.status
+      })
+    );
+    this.llmEventsByStep.delete(stepNumber);
+  }
+}
+export {
+  VercelRecorder
+};

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

@@ -0,0 +1,40 @@
+import { T_CarbonObject } from '../../core/schema/carbon-object.mjs';
+import * as vercelSdk from 'ai';
+import '../../internal/schema/events.mjs';
+import 'zod';
+
+type T_GenerateTextArgs = Parameters<typeof vercelSdk.generateText>[0];
+type T_GenerateTextArgsWithCarbon = Parameters<typeof vercelSdk.generateText>[0] & {
+    carbon?: T_CarbonObject;
+};
+type T_GenerateTextResult = Promise<Awaited<ReturnType<typeof vercelSdk.generateText>>>;
+type T_StreamTextArgs = Parameters<typeof vercelSdk.streamText>[0];
+type T_StreamTextArgsWithCarbon = Parameters<typeof vercelSdk.streamText>[0] & {
+    carbon?: T_CarbonObject;
+};
+type T_StreamTextResult = ReturnType<typeof vercelSdk.streamText>;
+type T_ToolLoopAgent = InstanceType<typeof vercelSdk.ToolLoopAgent>;
+type T_ToolLoopAgentGenerateArgsWithCarbon = Omit<Parameters<T_ToolLoopAgent["generate"]>[0], "options"> & {
+    carbon?: T_CarbonObject;
+    options?: unknown;
+};
+type T_ToolLoopAgentStreamArgsWithCarbon = Omit<Parameters<T_ToolLoopAgent["stream"]>[0], "options"> & {
+    carbon?: T_CarbonObject;
+    options?: unknown;
+};
+type T_ToolLoopAgentSettingsWithCarbon = ConstructorParameters<typeof vercelSdk.ToolLoopAgent>[0] & {
+    carbon?: T_CarbonObject;
+};
+type T_WrappedToolLoopAgent = {
+    new (settings: T_ToolLoopAgentSettingsWithCarbon): Omit<T_ToolLoopAgent, "generate" | "stream"> & {
+        generate: (args: T_ToolLoopAgentGenerateArgsWithCarbon) => ReturnType<T_ToolLoopAgent["generate"]>;
+        stream: (args: T_ToolLoopAgentStreamArgsWithCarbon) => ReturnType<T_ToolLoopAgent["stream"]>;
+    };
+};
+type T_WrappedVercelSdk = Omit<typeof vercelSdk, "ToolLoopAgent" | "generateText" | "streamText"> & {
+    ToolLoopAgent: T_WrappedToolLoopAgent;
+    generateText: (args: T_GenerateTextArgsWithCarbon) => T_GenerateTextResult;
+    streamText: (args: T_StreamTextArgsWithCarbon) => T_StreamTextResult;
+};
+
+export type { T_GenerateTextArgs, T_GenerateTextArgsWithCarbon, T_GenerateTextResult, T_StreamTextArgs, T_StreamTextArgsWithCarbon, T_StreamTextResult, T_ToolLoopAgent, T_ToolLoopAgentGenerateArgsWithCarbon, T_ToolLoopAgentSettingsWithCarbon, T_ToolLoopAgentStreamArgsWithCarbon, T_WrappedToolLoopAgent, T_WrappedVercelSdk };

package/dist/ai/vercel/types.mjs

@@ -0,0 +1 @@
+import * as vercelSdk from "ai";

package/dist/ai/vercel/utils/telemetry.d.mts

@@ -0,0 +1,31 @@
+import { Carbon } from '../../../core/carbon.mjs';
+import { T_CarbonObject } from '../../../core/schema/carbon-object.mjs';
+import { VercelRecorder } from '../recorder.mjs';
+import '../../../core/runtime.mjs';
+import '../../../internal/schema/events.mjs';
+import 'zod';
+import '../../../core/transport/types.mjs';
+import '../../../core/tools/wrap-tool.mjs';
+import '../event-factory.mjs';
+import 'ai';
+
+type T_VercelTelemetryArgs = {
+    carbon?: T_CarbonObject;
+    experimental_telemetry?: {
+        integrations?: unknown;
+    };
+};
+type T_RunWithCarbonTelemetry<T_Args extends T_VercelTelemetryArgs, T_Result> = {
+    args: T_Args;
+    carbon: Carbon;
+    mode: "generate" | "stream";
+    run: (args: Omit<T_Args, "carbon">) => T_Result;
+    sourceFunction: string;
+};
+declare const runWithCarbonTelemetry: <T_Args extends T_VercelTelemetryArgs, T_Result>(args: T_RunWithCarbonTelemetry<T_Args, T_Result>) => T_Result;
+declare const addCarbonTelemetry: <T_Args extends T_VercelTelemetryArgs>(args: {
+    args: T_Args;
+    recorder: VercelRecorder;
+}) => T_Args;
+
+export { type T_VercelTelemetryArgs, addCarbonTelemetry, runWithCarbonTelemetry };

package/dist/ai/vercel/utils/telemetry.mjs

@@ -0,0 +1,46 @@
+import { isPromiseLike } from "../../../utils/promise.mjs";
+import { VercelRecorder } from "../recorder.mjs";
+const runWithCarbonTelemetry = (args) => {
+  const { carbon: carbonObject, ...aiArgs } = args.args;
+  const recorder = new VercelRecorder({
+    carbon: args.carbon,
+    carbonObject,
+    mode: args.mode,
+    sourceFunction: args.sourceFunction
+  });
+  const aiArgsWithCarbonTelemetry = addCarbonTelemetry({
+    args: aiArgs,
+    recorder
+  });
+  try {
+    const result = args.run(aiArgsWithCarbonTelemetry);
+    if (isPromiseLike({ value: result })) {
+      return Promise.resolve(result).catch(async (error) => {
+        recorder.recordError({ error });
+        throw error;
+      });
+    }
+    return result;
+  } catch (error) {
+    recorder.recordError({ error });
+    throw error;
+  }
+};
+const addCarbonTelemetry = (args) => {
+  const telemetry = args.args.experimental_telemetry;
+  const carbonIntegration = args.recorder.createIntegration();
+  const existingIntegrations = telemetry?.integrations ? Array.isArray(telemetry.integrations) ? telemetry.integrations : [telemetry.integrations] : [];
+  const integrations = [...existingIntegrations, carbonIntegration];
+  return {
+    ...args.args,
+    experimental_telemetry: {
+      ...telemetry,
+      isEnabled: true,
+      integrations
+    }
+  };
+};
+export {
+  addCarbonTelemetry,
+  runWithCarbonTelemetry
+};

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

@@ -0,0 +1,13 @@
+import { Carbon } from '../../core/carbon.mjs';
+import { T_WrappedVercelSdk } 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';
+
+declare const wrapVercelSdk: (ai: typeof vercelSdk, carbon: Carbon) => T_WrappedVercelSdk;
+
+export { wrapVercelSdk };

package/dist/ai/vercel/wrap.mjs

@@ -0,0 +1,29 @@
+import { createWrappedToolLoopAgent } from "./fns/tool-loop-agent.mjs";
+import { runWithCarbonTelemetry } from "./utils/telemetry.mjs";
+import * as vercelSdk from "ai";
+const wrapVercelSdk = (ai, carbon) => {
+  return {
+    ...ai,
+    ToolLoopAgent: createWrappedToolLoopAgent({
+      ToolLoopAgent: ai.ToolLoopAgent,
+      carbon
+    }),
+    generateText: async (args) => runWithCarbonTelemetry({
+      args,
+      carbon,
+      mode: "generate",
+      run: (aiArgs) => ai.generateText(aiArgs),
+      sourceFunction: "generateText"
+    }),
+    streamText: (args) => runWithCarbonTelemetry({
+      args,
+      carbon,
+      mode: "stream",
+      run: (aiArgs) => ai.streamText(aiArgs),
+      sourceFunction: "streamText"
+    })
+  };
+};
+export {
+  wrapVercelSdk
+};

package/dist/ai.d.mts

@@ -0,0 +1,16 @@
+export { wrapAnthropicSdk } from './ai/anthropic/wrap.mjs';
+export { wrapOpenAISdk } from './ai/openai/wrap.mjs';
+export { wrapVercelSdk } from './ai/vercel/wrap.mjs';
+import './core/carbon.mjs';
+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';
+import './ai/anthropic/types.mjs';
+import '@anthropic-ai/sdk';
+import './ai/openai/types.mjs';
+import 'openai';
+import './ai/vercel/types.mjs';
+import 'ai';

package/dist/ai.mjs

@@ -0,0 +1,8 @@
+import { wrapAnthropicSdk } from "./ai/anthropic/wrap.mjs";
+import { wrapOpenAISdk } from "./ai/openai/wrap.mjs";
+import { wrapVercelSdk } from "./ai/vercel/wrap.mjs";
+export {
+  wrapAnthropicSdk,
+  wrapOpenAISdk,
+  wrapVercelSdk
+};

package/dist/core/carbon.d.mts

@@ -0,0 +1,27 @@
+import { T_CarbonObject } from './schema/carbon-object.mjs';
+import { T_CarbonRuntimeOptions } from './runtime.mjs';
+import { T_WrapToolArgs } from './tools/wrap-tool.mjs';
+import { T as T_LLMEvent, b as T_ToolEvent, a as T_Event } from '../internal/schema/events.mjs';
+import './transport/types.mjs';
+import 'zod';
+
+type T_CarbonOptions = T_CarbonRuntimeOptions;
+
+declare class Carbon {
+    private readonly runtime;
+    constructor(args?: T_CarbonOptions);
+    captureLlmCall(args: {
+        event: T_LLMEvent;
+    }): void;
+    captureToolCall(args: {
+        event: T_ToolEvent;
+    }): void;
+    captureEvents(args: {
+        events: T_Event[];
+    }): 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>;
+}
+
+export { Carbon, type T_CarbonOptions, T_WrapToolArgs };

package/dist/core/carbon.mjs

@@ -0,0 +1,35 @@
+import { CarbonRuntime } from "./runtime.mjs";
+import { createWrappedTool } from "./tools/wrap-tool.mjs";
+import { generateId } from "../utils/ids.mjs";
+class Carbon {
+  runtime;
+  constructor(args = {}) {
+    this.runtime = new CarbonRuntime(args);
+  }
+  captureLlmCall(args) {
+    this.captureEvents({ events: [args.event] });
+  }
+  captureToolCall(args) {
+    this.captureEvents({ events: [args.event] });
+  }
+  captureEvents(args) {
+    this.runtime.recordEvents({ events: args.events });
+  }
+  createTraceId() {
+    return generateId();
+  }
+  wrapTool(args) {
+    return createWrappedTool({
+      ...args,
+      captureToolCall: (captureArgs) => {
+        this.captureToolCall(captureArgs);
+      }
+    });
+  }
+  flushPendingTraces() {
+    return this.runtime.shutdown();
+  }
+}
+export {
+  Carbon
+};

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

@@ -0,0 +1,19 @@
+import { a as T_Event } from '../../internal/schema/events.mjs';
+import 'zod';
+
+declare class EventBuffer {
+    private readonly pendingEvents;
+    add(args: {
+        events: T_Event[];
+    }): void;
+    drain(args?: {
+        count?: number;
+    }): T_Event[];
+    prepend(args: {
+        events: T_Event[];
+    }): void;
+    get length(): number;
+    get earliestStartTimeMs(): number | null;
+}
+
+export { EventBuffer };

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

@@ -0,0 +1,26 @@
+class EventBuffer {
+  pendingEvents = [];
+  add(args) {
+    this.pendingEvents.push(...args.events);
+  }
+  drain(args = {}) {
+    return this.pendingEvents.splice(0, args.count ?? this.pendingEvents.length);
+  }
+  prepend(args) {
+    this.pendingEvents.unshift(...args.events);
+  }
+  get length() {
+    return this.pendingEvents.length;
+  }
+  get earliestStartTimeMs() {
+    return this.pendingEvents.reduce((earliestStartTimeMs, event) => {
+      if (earliestStartTimeMs === null) {
+        return event.startTimeMs;
+      }
+      return Math.min(earliestStartTimeMs, event.startTimeMs);
+    }, null);
+  }
+}
+export {
+  EventBuffer
+};

package/dist/core/runtime.d.mts

@@ -0,0 +1,34 @@
+import { a as T_Event } from '../internal/schema/events.mjs';
+import { T_EventTransport } from './transport/types.mjs';
+import 'zod';
+
+type T_CarbonRuntimeOptions = {
+    baseUrl?: string;
+    apiKey?: string;
+    bufferBatchSize?: number;
+    bufferMaxTimeMs?: number;
+    transport?: T_EventTransport;
+};
+type T_RecordEvents = {
+    events: T_Event[];
+};
+declare class CarbonRuntime {
+    private readonly buffer;
+    private readonly bufferBatchSize;
+    private readonly bufferMaxTimeMs;
+    private readonly transport;
+    private flushPromise;
+    private flushTimer;
+    private isShuttingDown;
+    constructor(args: T_CarbonRuntimeOptions);
+    recordEvents(args: T_RecordEvents): void;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    private flushNextBatch;
+    private sendDrainedEvents;
+    private flushOrSchedule;
+    private scheduleFlush;
+    private clearFlushTimer;
+}
+
+export { CarbonRuntime, type T_CarbonRuntimeOptions };

package/dist/core/runtime.mjs

@@ -0,0 +1,119 @@
+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";
+class CarbonRuntime {
+  buffer = new EventBuffer();
+  bufferBatchSize;
+  bufferMaxTimeMs;
+  transport;
+  flushPromise = null;
+  flushTimer = null;
+  isShuttingDown = false;
+  constructor(args) {
+    this.bufferBatchSize = args.bufferBatchSize ?? CONSTANTS.buffer.batchSize;
+    this.bufferMaxTimeMs = args.bufferMaxTimeMs ?? CONSTANTS.buffer.maxTimeMs;
+    if (!Number.isInteger(this.bufferBatchSize) || this.bufferBatchSize <= 0) {
+      throw new Error("batchSize must be a positive integer.");
+    }
+    if (!Number.isFinite(this.bufferMaxTimeMs) || this.bufferMaxTimeMs < 0) {
+      throw new Error("maxBufferTimeMs must be greater than or equal to 0.");
+    }
+    this.transport = args.transport ?? new HttpTransport({
+      apiKey: args.apiKey,
+      baseUrl: args.baseUrl
+    });
+  }
+  recordEvents(args) {
+    const events = args.events.map((event) => Z_Event.parse(event));
+    this.buffer.add({ events });
+    this.flushOrSchedule();
+  }
+  async flush() {
+    if (this.flushPromise) {
+      return this.flushPromise;
+    }
+    return this.flushNextBatch({ allowBackgroundScheduling: true });
+  }
+  async shutdown() {
+    this.isShuttingDown = true;
+    try {
+      while (this.buffer.length > 0 || this.flushPromise) {
+        if (this.flushPromise) {
+          await this.flushPromise;
+          continue;
+        }
+        await this.flushNextBatch({ allowBackgroundScheduling: false });
+      }
+    } finally {
+      this.isShuttingDown = false;
+    }
+  }
+  flushNextBatch(args) {
+    this.clearFlushTimer();
+    if (this.buffer.length === 0) {
+      return;
+    }
+    const events = this.buffer.drain({ count: this.bufferBatchSize });
+    this.flushPromise = this.sendDrainedEvents({
+      allowBackgroundScheduling: args.allowBackgroundScheduling,
+      events
+    });
+    return this.flushPromise;
+  }
+  async sendDrainedEvents(args) {
+    let didSend = false;
+    let shouldRetry = false;
+    try {
+      await this.transport.sendBatch({
+        batch: {
+          events: args.events
+        }
+      });
+      didSend = true;
+    } catch (error) {
+      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;
+      throw error;
+    } finally {
+      this.flushPromise = null;
+      const canScheduleBackgroundFlush = args.allowBackgroundScheduling && !this.isShuttingDown;
+      if (shouldRetry && canScheduleBackgroundFlush) {
+        this.scheduleFlush({ delayMs: this.bufferMaxTimeMs });
+      } else if (didSend && canScheduleBackgroundFlush) {
+        this.flushOrSchedule();
+      }
+    }
+  }
+  flushOrSchedule() {
+    if (this.buffer.length >= this.bufferBatchSize) {
+      void this.flush().catch(() => void 0);
+      return;
+    }
+    this.scheduleFlush({
+      delayMs: Math.max((this.buffer.earliestStartTimeMs ?? Date.now()) + this.bufferMaxTimeMs - Date.now(), 0)
+    });
+  }
+  scheduleFlush(args) {
+    this.clearFlushTimer();
+    if (this.buffer.length === 0) {
+      return;
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      void this.flush().catch(() => void 0);
+    }, args.delayMs);
+    this.flushTimer.unref?.();
+  }
+  clearFlushTimer() {
+    if (!this.flushTimer) {
+      return;
+    }
+    clearTimeout(this.flushTimer);
+    this.flushTimer = null;
+  }
+}
+export {
+  CarbonRuntime
+};

package/dist/core/schema/carbon-object.d.mts

@@ -0,0 +1,11 @@
+import { e as T_EventContext, d as T_EventAdditionalProperties } from '../../internal/schema/events.mjs';
+import 'zod';
+
+type T_CarbonContext = Partial<Record<keyof T_EventContext, string>>;
+type T_CarbonObject = {
+    traceId?: string;
+    context?: T_CarbonContext;
+    additionalProperties?: T_EventAdditionalProperties;
+};
+
+export type { T_CarbonContext, T_CarbonObject };

package/dist/core/tools/wrap-tool.d.mts

@@ -0,0 +1,16 @@
+import { T_CarbonObject } from '../schema/carbon-object.mjs';
+import { b as T_ToolEvent } from '../../internal/schema/events.mjs';
+import 'zod';
+
+type T_WrapToolArgs<T_Args extends unknown[], T_Result> = {
+    name: string;
+    run: (...args: T_Args) => T_Result;
+};
+type T_CreateWrappedToolArgs<T_Args extends unknown[], T_Result> = T_WrapToolArgs<T_Args, T_Result> & {
+    captureToolCall: (args: {
+        event: T_ToolEvent;
+    }) => void;
+};
+declare function createWrappedTool<T_Args extends unknown[], T_Result>(args: T_CreateWrappedToolArgs<T_Args, T_Result>): (...callArgs: [...T_Args, T_CarbonObject?]) => T_Result;
+
+export { type T_WrapToolArgs, createWrappedTool };