@amplitude/ai 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,384 @@
+//#region src/types.d.ts
+/**
+ * Shared type definitions for the Amplitude AI SDK.
+ *
+ * Structural interfaces for provider request/response shapes,
+ * events, and the core AmplitudeLike contract. These are
+ * "duck-typed" interfaces — they describe the subset of each
+ * provider SDK's shape that we actually use, without importing
+ * the real SDK types.
+ */
+/**
+ * Event payload shape for Amplitude tracking.
+ * Used when passing events to `AmplitudeLike.track()`.
+ */
+interface AmplitudeEvent {
+  event_type: string;
+  user_id?: string;
+  device_id?: string;
+  session_id?: number;
+  event_properties?: Record<string, unknown>;
+  user_properties?: Record<string, unknown>;
+  groups?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+/**
+ * Contract for Amplitude analytics clients.
+ * Any object with a `track(event)` method satisfies this interface.
+ */
+interface AmplitudeLike {
+  track: (event: AmplitudeEvent) => void;
+}
+/**
+ * Extended Amplitude client with flush, shutdown, and optional init.
+ * Used by the SDK when it owns or receives an Amplitude instance.
+ */
+interface AmplitudeClientLike extends AmplitudeLike {
+  flush: () => unknown;
+  shutdown?: () => void;
+  init?: (apiKey: string) => unknown;
+  configuration?: Record<string, unknown>;
+}
+/**
+ * Structural type matching AmplitudeAI instances.
+ * Allows providers to accept either an AmplitudeLike (raw analytics client)
+ * or an AmplitudeAI instance (which exposes `.amplitude` getter).
+ * This avoids circular imports while enabling the convenience pattern:
+ *   new OpenAI({ amplitude: ai })  // AmplitudeAI
+ *   new OpenAI({ amplitude: amp }) // raw Amplitude client
+ */
+interface AmplitudeAILike {
+  readonly amplitude: AmplitudeClientLike;
+}
+/**
+ * Union type accepted by provider constructors.
+ * Providers call `resolveAmplitude()` to normalize to `AmplitudeLike`.
+ */
+type AmplitudeOrAI = AmplitudeLike | AmplitudeAILike;
+/**
+ * Resolve an `AmplitudeOrAI` value to a plain `AmplitudeLike`.
+ */
+declare function resolveAmplitude(input: AmplitudeOrAI): AmplitudeLike;
+/**
+ * Single message in a chat completion request.
+ * Supports role, content, optional name, and tool calls.
+ */
+interface ChatMessage {
+  role: string;
+  content?: string | null;
+  name?: string;
+  tool_calls?: ToolCallShape[];
+}
+/**
+ * Structural interface for OpenAI-compatible chat completion parameters.
+ * Used by the OpenAI and Azure OpenAI provider wrappers.
+ */
+interface ChatCompletionParams {
+  model: string;
+  messages: ChatMessage[];
+  temperature?: number;
+  top_p?: number;
+  max_tokens?: number;
+  stream?: boolean;
+  [key: string]: unknown;
+}
+/**
+ * Structural interface for OpenAI-compatible chat completion responses.
+ * Describes the subset of the OpenAI SDK's response shape that the SDK tracks.
+ */
+interface ChatCompletionResponse {
+  model: string;
+  choices: ChatChoice[];
+  usage?: OpenAITokenUsage;
+}
+/**
+ * Single choice in a chat completion response.
+ */
+interface ChatChoice {
+  message: {
+    content?: string | null;
+    tool_calls?: ToolCallShape[];
+  };
+  finish_reason?: string;
+}
+/**
+ * Token usage metadata for OpenAI/Azure OpenAI responses.
+ */
+interface OpenAITokenUsage {
+  prompt_tokens?: number;
+  completion_tokens?: number;
+  total_tokens?: number;
+}
+/**
+ * Structural interface for OpenAI Responses API request input items.
+ */
+interface OpenAIResponseInput {
+  role?: string;
+  content?: string | Array<{
+    text?: string;
+    [key: string]: unknown;
+  }>;
+  [key: string]: unknown;
+}
+/**
+ * Structural interface for OpenAI Responses API output content blocks.
+ */
+interface OpenAIResponseOutputContentItem {
+  type?: string;
+  text?: string;
+  [key: string]: unknown;
+}
+/**
+ * Structural interface for OpenAI Responses API output items.
+ */
+interface OpenAIResponseOutputItem {
+  type?: string;
+  status?: string;
+  content?: OpenAIResponseOutputContentItem[];
+  [key: string]: unknown;
+}
+/**
+ * Structural interface for OpenAI Responses API usage metadata.
+ */
+interface OpenAIResponseUsage {
+  input_tokens?: number;
+  output_tokens?: number;
+  total_tokens?: number;
+  output_tokens_details?: {
+    reasoning_tokens?: number;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+/**
+ * Structural interface for OpenAI Responses API responses.
+ */
+interface OpenAIResponse {
+  model?: string;
+  status?: string;
+  output_text?: string;
+  output?: OpenAIResponseOutputItem[];
+  usage?: OpenAIResponseUsage;
+  [key: string]: unknown;
+}
+/**
+ * Structural interface for Anthropic chat completion request parameters.
+ */
+interface AnthropicParams {
+  model: string;
+  system?: string;
+  messages: unknown[];
+  max_tokens?: number;
+  temperature?: number;
+  top_p?: number;
+  [key: string]: unknown;
+}
+/**
+ * Structural interface for Anthropic chat completion responses.
+ */
+interface AnthropicResponse {
+  model: string;
+  content: ContentBlock[];
+  usage: AnthropicTokenUsage;
+  stop_reason?: string;
+}
+/**
+ * Content block in an Anthropic response (text, thinking, or tool_use).
+ */
+interface ContentBlock {
+  type: 'text' | 'thinking' | 'tool_use';
+  text?: string;
+  thinking?: string;
+  name?: string;
+  input?: unknown;
+  id?: string;
+}
+/**
+ * Token usage metadata for Anthropic responses.
+ */
+interface AnthropicTokenUsage {
+  input_tokens: number;
+  output_tokens: number;
+  cache_read_input_tokens?: number;
+  cache_creation_input_tokens?: number;
+}
+/**
+ * Structural interface for Google Gemini API responses.
+ * Supports both response object and legacy text/usageMetadata shape.
+ */
+interface GeminiResponse {
+  response?: GeminiResponseObject;
+  text?: (() => string) | string;
+  usageMetadata?: GeminiUsageMetadata;
+  candidates?: GeminiCandidate[];
+}
+/**
+ * Wrapper object for Gemini response (response.text, usageMetadata, candidates).
+ */
+interface GeminiResponseObject {
+  text?: () => string;
+  usageMetadata?: GeminiUsageMetadata;
+  candidates?: GeminiCandidate[];
+}
+/**
+ * Token usage metadata for Gemini responses.
+ */
+interface GeminiUsageMetadata {
+  promptTokenCount?: number;
+  candidatesTokenCount?: number;
+  totalTokenCount?: number;
+}
+/**
+ * Single candidate in a Gemini response.
+ */
+interface GeminiCandidate {
+  finishReason?: string;
+  content?: {
+    parts?: GeminiPart[];
+  };
+}
+/**
+ * Part of a Gemini candidate (text or functionCall).
+ */
+interface GeminiPart {
+  text?: string;
+  functionCall?: {
+    name: string;
+    args: Record<string, unknown>;
+  };
+}
+/**
+ * Structural interface for AWS Bedrock Converse API request parameters.
+ */
+interface BedrockConverseParams {
+  modelId: string;
+  messages?: unknown[];
+  [key: string]: unknown;
+}
+/**
+ * Structural interface for AWS Bedrock Converse API responses.
+ */
+interface BedrockConverseResponse {
+  output?: {
+    message?: {
+      content?: Array<{
+        text?: string;
+      }>;
+    };
+  };
+  usage?: {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+  };
+  stopReason?: string;
+}
+/**
+ * Structural interface for Mistral chat completion request parameters.
+ */
+interface MistralChatParams {
+  model: string;
+  messages: unknown[];
+  temperature?: number;
+  top_p?: number;
+  max_tokens?: number;
+  [key: string]: unknown;
+}
+/**
+ * Structural interface for Mistral chat completion responses.
+ */
+interface MistralChatResponse {
+  model?: string;
+  choices?: MistralChoice[];
+  usage?: MistralTokenUsage;
+}
+/**
+ * Single choice in a Mistral chat response.
+ */
+interface MistralChoice {
+  message?: {
+    content?: string | unknown[] | null;
+  };
+  finish_reason?: string;
+}
+/**
+ * Token usage metadata for Mistral responses.
+ */
+interface MistralTokenUsage {
+  prompt_tokens?: number;
+  completion_tokens?: number;
+  total_tokens?: number;
+}
+/**
+ * Shape of a tool/function call across provider SDKs.
+ */
+interface ToolCallShape {
+  name: string;
+  arguments?: unknown;
+  id?: string;
+}
+/**
+ * File or URL attachment for messages (e.g., image, document).
+ */
+interface Attachment {
+  type: string;
+  name?: string;
+  content?: string;
+  url?: string;
+  size_bytes?: number;
+}
+/**
+ * Callback used by provider wrappers to emit an AI response tracking event.
+ *
+ * Provider wrappers (OpenAI, Anthropic, etc.) receive a `TrackFn` via
+ * `BaseAIProvider.trackFn()` and call it after each completion or stream
+ * finishes. The function serializes the options into an Amplitude event
+ * and sends it via the underlying Amplitude client.
+ *
+ * @returns The generated message ID for the tracked event.
+ */
+type TrackFn = (opts: TrackCallOptions) => string;
+/**
+ * Options passed to the internal track function for LLM completion events.
+ *
+ * This is the unified shape used by all provider wrappers to report a
+ * single AI completion (streaming or non-streaming). Fields like
+ * `reasoningTokens`, `cacheReadInputTokens`, and `totalCostUsd` are
+ * optional and populated when the provider returns that data.
+ */
+interface TrackCallOptions {
+  userId: string;
+  modelName: string;
+  provider: string;
+  responseContent: string;
+  latencyMs: number;
+  sessionId?: string | null;
+  traceId?: string | null;
+  turnId?: number;
+  agentId?: string | null;
+  parentAgentId?: string | null;
+  customerOrgId?: string | null;
+  env?: string | null;
+  groups?: Record<string, unknown> | null;
+  inputTokens?: number | null;
+  outputTokens?: number | null;
+  totalTokens?: number | null;
+  reasoningTokens?: number | null;
+  cacheReadInputTokens?: number | null;
+  cacheCreationInputTokens?: number | null;
+  totalCostUsd?: number | null;
+  providerTtfbMs?: number | null;
+  isError?: boolean;
+  errorMessage?: string | null;
+  finishReason?: string | null;
+  toolCalls?: Array<ToolCallShape | Record<string, unknown>> | null;
+  reasoningContent?: string | null;
+  systemPrompt?: string | null;
+  temperature?: number | null;
+  maxOutputTokens?: number | null;
+  topP?: number | null;
+  isStreaming?: boolean;
+}
+//#endregion
+export { AmplitudeAILike, AmplitudeClientLike, AmplitudeEvent, AmplitudeLike, AmplitudeOrAI, AnthropicParams, AnthropicResponse, AnthropicTokenUsage, Attachment, BedrockConverseParams, BedrockConverseResponse, ChatChoice, ChatCompletionParams, ChatCompletionResponse, ChatMessage, ContentBlock, GeminiCandidate, GeminiPart, GeminiResponse, GeminiResponseObject, GeminiUsageMetadata, MistralChatParams, MistralChatResponse, MistralChoice, MistralTokenUsage, OpenAIResponse, OpenAIResponseInput, OpenAIResponseOutputContentItem, OpenAIResponseOutputItem, OpenAIResponseUsage, OpenAITokenUsage, ToolCallShape, TrackCallOptions, TrackFn, resolveAmplitude };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;AAkBA;;;;;AAeA;AAQA;AAeA;AAQA;AAKA;AA0BA;AAWA;AAciB,UAtGA,cAAA,CAsGsB;EAStB,UAAA,EAAA,MAAU;EAQV,OAAA,CAAA,EAAA,MAAA;EASA,SAAA,CAAA,EAAA,MAAA;EASA,UAAA,CAAA,EAAA,MAAA;EASA,gBAAA,CAAA,EA7II,MA6IJ,CAAA,MAAwB,EAAA,OAG7B,CAAA;EAOK,eAAA,CAAA,EAtJG,MAsJgB,CAAA,MAAA,EAAA,OAAA,CAAA;EAcnB,MAAA,CAAA,EAnKN,MAmKM,CAAA,MAAc,EAAA,OAIpB,CAAA;EAYM,CAAA,GAAA,EAAA,MAAA,CAAA,EAAA,OAAe;AAahC;AAUA;AAYA;AAeA;;AAGkB,UAhOD,aAAA,CAgOC;EACH,KAAA,EAAA,CAAA,KAAA,EAhOE,cAgOF,EAAA,GAAA,IAAA;;AAMf;AASA;AASA;AAQA;AAYiB,UArQA,mBAAA,SAA4B,aAqQP,CAAA;EASrB,KAAA,EAAA,GAAA,GAAA,OAAA;EAqBA,QAAA,CAAA,EAAA,GAAA,GAAA,IAAiB;EAYjB,IAAA,CAAA,EAAA,CAAA,MAAA,EAAA,MAAmB,EAAA,GAAA,OAAA;EASnB,aAAA,CAAA,EApTC,MAoTY,CAAA,MAAA,EAAA,OAAA,CAAA;AAQ9B;AAaA;AASA;AAkBA;AAUA;;;;;AAyBmB,UA5XF,eAAA,CA4XE;sBA3XG;;;;;;KAOV,aAAA,GAAgB,gBAAgB;;;;iBAK5B,gBAAA,QAAwB,gBAAgB;;;;;UA0BvC,WAAA;;;;eAIF;;;;;;UAOE,oBAAA;;YAEL;;;;;;;;;;;UAYK,sBAAA;;WAEN;UACD;;;;;UAMO,UAAA;;;iBACkC;;;;;;;UAOlC,gBAAA;;;;;;;;UASA,mBAAA;;qBAEI;;;;;;;;;UAOJ,+BAAA;;;;;;;;UASA,wBAAA;;;YAGL;;;;;;UAOK,mBAAA;;;;;;;;;;;;;UAcA,cAAA;;;;WAIN;UACD;;;;;;UAWO,eAAA;;;;;;;;;;;;UAaA,iBAAA;;WAEN;SACF;;;;;;UAOQ,YAAA;;;;;;;;;;;UAYA,mBAAA;;;;;;;;;;UAeA,cAAA;aACJ;;kBAEK;eACH;;;;;UAME,oBAAA;;kBAEC;eACH;;;;;UAME,mBAAA;;;;;;;;UASA,eAAA;;;YAEK;;;;;;UAML,UAAA;;;;UAEsB;;;;;;UAUtB,qBAAA;;;;;;;;UASA,uBAAA;;;gBAGD;;;;;;;;;;;;;;;UAkBC,iBAAA;;;;;;;;;;;UAYA,mBAAA;;YAEL;UACF;;;;;UAMO,aAAA;;;;;;;;;UAQA,iBAAA;;;;;;;;UAaA,aAAA;;;;;;;;UASA,UAAA;;;;;;;;;;;;;;;;;KAkBL,OAAA,UAAiB;;;;;;;;;UAUZ,gBAAA;;;;;;;;;;;;;WAaN;;;;;;;;;;;;cAYG,MAAM,gBAAgB"}

package/dist/types.js

@@ -0,0 +1,13 @@
+//#region src/types.ts
+/**
+* Resolve an `AmplitudeOrAI` value to a plain `AmplitudeLike`.
+*/
+function resolveAmplitude(input) {
+	if ("amplitude" in input && typeof input.amplitude === "object" && input.amplitude !== null && "track" in input.amplitude) return input.amplitude;
+	if ("track" in input && typeof input.track === "function") return input;
+	throw new Error("Expected an AmplitudeLike (with .track()) or AmplitudeAI (with .amplitude) instance. Pass either your AmplitudeAI instance or ai.amplitude.");
+}
+
+//#endregion
+export { resolveAmplitude };
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["/**\n * Shared type definitions for the Amplitude AI SDK.\n *\n * Structural interfaces for provider request/response shapes,\n * events, and the core AmplitudeLike contract. These are\n * \"duck-typed\" interfaces — they describe the subset of each\n * provider SDK's shape that we actually use, without importing\n * the real SDK types.\n */\n\n// ---------------------------------------------------------------------------\n// Amplitude client contract\n// ---------------------------------------------------------------------------\n\n/**\n * Event payload shape for Amplitude tracking.\n * Used when passing events to `AmplitudeLike.track()`.\n */\nexport interface AmplitudeEvent {\n  event_type: string;\n  user_id?: string;\n  device_id?: string;\n  session_id?: number;\n  event_properties?: Record<string, unknown>;\n  user_properties?: Record<string, unknown>;\n  groups?: Record<string, unknown>;\n  [key: string]: unknown;\n}\n\n/**\n * Contract for Amplitude analytics clients.\n * Any object with a `track(event)` method satisfies this interface.\n */\nexport interface AmplitudeLike {\n  track: (event: AmplitudeEvent) => void;\n}\n\n/**\n * Extended Amplitude client with flush, shutdown, and optional init.\n * Used by the SDK when it owns or receives an Amplitude instance.\n */\nexport interface AmplitudeClientLike extends AmplitudeLike {\n  flush: () => unknown;\n  shutdown?: () => void;\n  init?: (apiKey: string) => unknown;\n  configuration?: Record<string, unknown>;\n}\n\n/**\n * Structural type matching AmplitudeAI instances.\n * Allows providers to accept either an AmplitudeLike (raw analytics client)\n * or an AmplitudeAI instance (which exposes `.amplitude` getter).\n * This avoids circular imports while enabling the convenience pattern:\n *   new OpenAI({ amplitude: ai })  // AmplitudeAI\n *   new OpenAI({ amplitude: amp }) // raw Amplitude client\n */\nexport interface AmplitudeAILike {\n  readonly amplitude: AmplitudeClientLike;\n}\n\n/**\n * Union type accepted by provider constructors.\n * Providers call `resolveAmplitude()` to normalize to `AmplitudeLike`.\n */\nexport type AmplitudeOrAI = AmplitudeLike | AmplitudeAILike;\n\n/**\n * Resolve an `AmplitudeOrAI` value to a plain `AmplitudeLike`.\n */\nexport function resolveAmplitude(input: AmplitudeOrAI): AmplitudeLike {\n  if (\n    'amplitude' in input &&\n    typeof input.amplitude === 'object' &&\n    input.amplitude !== null &&\n    'track' in input.amplitude\n  ) {\n    return input.amplitude;\n  }\n  if ('track' in input && typeof input.track === 'function') {\n    return input as AmplitudeLike;\n  }\n  throw new Error(\n    'Expected an AmplitudeLike (with .track()) or AmplitudeAI (with .amplitude) instance. ' +\n      'Pass either your AmplitudeAI instance or ai.amplitude.',\n  );\n}\n\n// ---------------------------------------------------------------------------\n// OpenAI-compatible shapes (also used by Azure OpenAI)\n// ---------------------------------------------------------------------------\n\n/**\n * Single message in a chat completion request.\n * Supports role, content, optional name, and tool calls.\n */\nexport interface ChatMessage {\n  role: string;\n  content?: string | null;\n  name?: string;\n  tool_calls?: ToolCallShape[];\n}\n\n/**\n * Structural interface for OpenAI-compatible chat completion parameters.\n * Used by the OpenAI and Azure OpenAI provider wrappers.\n */\nexport interface ChatCompletionParams {\n  model: string;\n  messages: ChatMessage[];\n  temperature?: number;\n  top_p?: number;\n  max_tokens?: number;\n  stream?: boolean;\n  [key: string]: unknown;\n}\n\n/**\n * Structural interface for OpenAI-compatible chat completion responses.\n * Describes the subset of the OpenAI SDK's response shape that the SDK tracks.\n */\nexport interface ChatCompletionResponse {\n  model: string;\n  choices: ChatChoice[];\n  usage?: OpenAITokenUsage;\n}\n\n/**\n * Single choice in a chat completion response.\n */\nexport interface ChatChoice {\n  message: { content?: string | null; tool_calls?: ToolCallShape[] };\n  finish_reason?: string;\n}\n\n/**\n * Token usage metadata for OpenAI/Azure OpenAI responses.\n */\nexport interface OpenAITokenUsage {\n  prompt_tokens?: number;\n  completion_tokens?: number;\n  total_tokens?: number;\n}\n\n/**\n * Structural interface for OpenAI Responses API request input items.\n */\nexport interface OpenAIResponseInput {\n  role?: string;\n  content?: string | Array<{ text?: string; [key: string]: unknown }>;\n  [key: string]: unknown;\n}\n\n/**\n * Structural interface for OpenAI Responses API output content blocks.\n */\nexport interface OpenAIResponseOutputContentItem {\n  type?: string;\n  text?: string;\n  [key: string]: unknown;\n}\n\n/**\n * Structural interface for OpenAI Responses API output items.\n */\nexport interface OpenAIResponseOutputItem {\n  type?: string;\n  status?: string;\n  content?: OpenAIResponseOutputContentItem[];\n  [key: string]: unknown;\n}\n\n/**\n * Structural interface for OpenAI Responses API usage metadata.\n */\nexport interface OpenAIResponseUsage {\n  input_tokens?: number;\n  output_tokens?: number;\n  total_tokens?: number;\n  output_tokens_details?: {\n    reasoning_tokens?: number;\n    [key: string]: unknown;\n  };\n  [key: string]: unknown;\n}\n\n/**\n * Structural interface for OpenAI Responses API responses.\n */\nexport interface OpenAIResponse {\n  model?: string;\n  status?: string;\n  output_text?: string;\n  output?: OpenAIResponseOutputItem[];\n  usage?: OpenAIResponseUsage;\n  [key: string]: unknown;\n}\n\n// ---------------------------------------------------------------------------\n// Anthropic shapes\n// ---------------------------------------------------------------------------\n\n/**\n * Structural interface for Anthropic chat completion request parameters.\n */\nexport interface AnthropicParams {\n  model: string;\n  system?: string;\n  messages: unknown[];\n  max_tokens?: number;\n  temperature?: number;\n  top_p?: number;\n  [key: string]: unknown;\n}\n\n/**\n * Structural interface for Anthropic chat completion responses.\n */\nexport interface AnthropicResponse {\n  model: string;\n  content: ContentBlock[];\n  usage: AnthropicTokenUsage;\n  stop_reason?: string;\n}\n\n/**\n * Content block in an Anthropic response (text, thinking, or tool_use).\n */\nexport interface ContentBlock {\n  type: 'text' | 'thinking' | 'tool_use';\n  text?: string;\n  thinking?: string;\n  name?: string;\n  input?: unknown;\n  id?: string;\n}\n\n/**\n * Token usage metadata for Anthropic responses.\n */\nexport interface AnthropicTokenUsage {\n  input_tokens: number;\n  output_tokens: number;\n  cache_read_input_tokens?: number;\n  cache_creation_input_tokens?: number;\n}\n\n// ---------------------------------------------------------------------------\n// Gemini shapes\n// ---------------------------------------------------------------------------\n\n/**\n * Structural interface for Google Gemini API responses.\n * Supports both response object and legacy text/usageMetadata shape.\n */\nexport interface GeminiResponse {\n  response?: GeminiResponseObject;\n  text?: (() => string) | string;\n  usageMetadata?: GeminiUsageMetadata;\n  candidates?: GeminiCandidate[];\n}\n\n/**\n * Wrapper object for Gemini response (response.text, usageMetadata, candidates).\n */\nexport interface GeminiResponseObject {\n  text?: () => string;\n  usageMetadata?: GeminiUsageMetadata;\n  candidates?: GeminiCandidate[];\n}\n\n/**\n * Token usage metadata for Gemini responses.\n */\nexport interface GeminiUsageMetadata {\n  promptTokenCount?: number;\n  candidatesTokenCount?: number;\n  totalTokenCount?: number;\n}\n\n/**\n * Single candidate in a Gemini response.\n */\nexport interface GeminiCandidate {\n  finishReason?: string;\n  content?: { parts?: GeminiPart[] };\n}\n\n/**\n * Part of a Gemini candidate (text or functionCall).\n */\nexport interface GeminiPart {\n  text?: string;\n  functionCall?: { name: string; args: Record<string, unknown> };\n}\n\n// ---------------------------------------------------------------------------\n// Bedrock shapes\n// ---------------------------------------------------------------------------\n\n/**\n * Structural interface for AWS Bedrock Converse API request parameters.\n */\nexport interface BedrockConverseParams {\n  modelId: string;\n  messages?: unknown[];\n  [key: string]: unknown;\n}\n\n/**\n * Structural interface for AWS Bedrock Converse API responses.\n */\nexport interface BedrockConverseResponse {\n  output?: {\n    message?: {\n      content?: Array<{ text?: string }>;\n    };\n  };\n  usage?: {\n    inputTokens?: number;\n    outputTokens?: number;\n    totalTokens?: number;\n  };\n  stopReason?: string;\n}\n\n// ---------------------------------------------------------------------------\n// Mistral shapes\n// ---------------------------------------------------------------------------\n\n/**\n * Structural interface for Mistral chat completion request parameters.\n */\nexport interface MistralChatParams {\n  model: string;\n  messages: unknown[];\n  temperature?: number;\n  top_p?: number;\n  max_tokens?: number;\n  [key: string]: unknown;\n}\n\n/**\n * Structural interface for Mistral chat completion responses.\n */\nexport interface MistralChatResponse {\n  model?: string;\n  choices?: MistralChoice[];\n  usage?: MistralTokenUsage;\n}\n\n/**\n * Single choice in a Mistral chat response.\n */\nexport interface MistralChoice {\n  message?: { content?: string | unknown[] | null };\n  finish_reason?: string;\n}\n\n/**\n * Token usage metadata for Mistral responses.\n */\nexport interface MistralTokenUsage {\n  prompt_tokens?: number;\n  completion_tokens?: number;\n  total_tokens?: number;\n}\n\n// ---------------------------------------------------------------------------\n// Common shapes\n// ---------------------------------------------------------------------------\n\n/**\n * Shape of a tool/function call across provider SDKs.\n */\nexport interface ToolCallShape {\n  name: string;\n  arguments?: unknown;\n  id?: string;\n}\n\n/**\n * File or URL attachment for messages (e.g., image, document).\n */\nexport interface Attachment {\n  type: string;\n  name?: string;\n  content?: string;\n  url?: string;\n  size_bytes?: number;\n}\n\n/**\n * Callback used by provider wrappers to emit an AI response tracking event.\n *\n * Provider wrappers (OpenAI, Anthropic, etc.) receive a `TrackFn` via\n * `BaseAIProvider.trackFn()` and call it after each completion or stream\n * finishes. The function serializes the options into an Amplitude event\n * and sends it via the underlying Amplitude client.\n *\n * @returns The generated message ID for the tracked event.\n */\nexport type TrackFn = (opts: TrackCallOptions) => string;\n\n/**\n * Options passed to the internal track function for LLM completion events.\n *\n * This is the unified shape used by all provider wrappers to report a\n * single AI completion (streaming or non-streaming). Fields like\n * `reasoningTokens`, `cacheReadInputTokens`, and `totalCostUsd` are\n * optional and populated when the provider returns that data.\n */\nexport interface TrackCallOptions {\n  userId: string;\n  modelName: string;\n  provider: string;\n  responseContent: string;\n  latencyMs: number;\n  sessionId?: string | null;\n  traceId?: string | null;\n  turnId?: number;\n  agentId?: string | null;\n  parentAgentId?: string | null;\n  customerOrgId?: string | null;\n  env?: string | null;\n  groups?: Record<string, unknown> | null;\n  inputTokens?: number | null;\n  outputTokens?: number | null;\n  totalTokens?: number | null;\n  reasoningTokens?: number | null;\n  cacheReadInputTokens?: number | null;\n  cacheCreationInputTokens?: number | null;\n  totalCostUsd?: number | null;\n  providerTtfbMs?: number | null;\n  isError?: boolean;\n  errorMessage?: string | null;\n  finishReason?: string | null;\n  toolCalls?: Array<ToolCallShape | Record<string, unknown>> | null;\n  reasoningContent?: string | null;\n  systemPrompt?: string | null;\n  temperature?: number | null;\n  maxOutputTokens?: number | null;\n  topP?: number | null;\n  isStreaming?: boolean;\n}\n"],"mappings":";;;;AAqEA,SAAgB,iBAAiB,OAAqC;AACpE,KACE,eAAe,SACf,OAAO,MAAM,cAAc,YAC3B,MAAM,cAAc,QACpB,WAAW,MAAM,UAEjB,QAAO,MAAM;AAEf,KAAI,WAAW,SAAS,OAAO,MAAM,UAAU,WAC7C,QAAO;AAET,OAAM,IAAI,MACR,8IAED"}

package/dist/utils/costs.d.ts

@@ -0,0 +1,27 @@
+import { inferProviderFromModel } from "./providers.js";
+
+//#region src/utils/costs.d.ts
+
+declare function stripProviderPrefix(modelName: string): string;
+/**
+ * Infer the provider name from a model name.
+ * Delegates to the canonical implementation in utils/providers.ts.
+ */
+declare const inferProvider: typeof inferProviderFromModel;
+/**
+ * Generate candidate model names for price lookup, mirroring Python's
+ * get_genai_price_lookup_candidates(). Tries progressively stripped names
+ * so the caller can attempt each until a match is found.
+ */
+declare function getGenaiPriceLookupCandidates(modelName: string): string[];
+declare function calculateCost(options: {
+  modelName: string;
+  inputTokens: number;
+  outputTokens: number;
+  reasoningTokens?: number;
+  cacheReadInputTokens?: number;
+  cacheCreationInputTokens?: number;
+}): number;
+//#endregion
+export { calculateCost, getGenaiPriceLookupCandidates, inferProvider, stripProviderPrefix };
+//# sourceMappingURL=costs.d.ts.map

package/dist/utils/costs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"costs.d.ts","names":[],"sources":["../../src/utils/costs.ts"],"sourcesContent":[],"mappings":";;;;iBAYgB,mBAAA;;;;;cAgBH,sBAAa;;;;;;iBAOV,6BAAA;iBAmBA,aAAA"}

package/dist/utils/costs.js

@@ -0,0 +1,63 @@
+import { inferProviderFromModel } from "./providers.js";
+import { tryRequire } from "./resolve-module.js";
+
+//#region src/utils/costs.ts
+/**
+* Cost calculation utilities.
+*
+* Uses the genai-prices package when available (npm: @pydantic/genai-prices).
+* Falls back to returning 0 when not installed.
+*/
+const genaiPrices = tryRequire("@pydantic/genai-prices");
+function stripProviderPrefix(modelName) {
+	const colonIdx = modelName.indexOf(":");
+	return colonIdx >= 0 ? modelName.slice(colonIdx + 1) : modelName;
+}
+function normalizeBedrockModel(modelName) {
+	return modelName.match(/(?:us\.|eu\.|ap\.)?(?:anthropic|meta|mistral|amazon|cohere)\.(.*)/)?.[1] ?? modelName;
+}
+/**
+* Infer the provider name from a model name.
+* Delegates to the canonical implementation in utils/providers.ts.
+*/
+const inferProvider = inferProviderFromModel;
+/**
+* Generate candidate model names for price lookup, mirroring Python's
+* get_genai_price_lookup_candidates(). Tries progressively stripped names
+* so the caller can attempt each until a match is found.
+*/
+function getGenaiPriceLookupCandidates(modelName) {
+	const candidates = [];
+	const stripped = stripProviderPrefix(modelName);
+	const normalized = normalizeBedrockModel(stripped);
+	if (normalized !== modelName) candidates.push(normalized);
+	if (stripped !== modelName && stripped !== normalized) candidates.push(stripped);
+	candidates.push(modelName);
+	return [...new Set(candidates)];
+}
+function safeInt(value) {
+	if (typeof value === "number" && !Number.isNaN(value)) return Math.round(value);
+	return 0;
+}
+function calculateCost(options) {
+	const { modelName, inputTokens, outputTokens, reasoningTokens = 0, cacheReadInputTokens = 0, cacheCreationInputTokens = 0 } = options;
+	if (genaiPrices != null) try {
+		const prices = genaiPrices;
+		if (typeof prices.calculateCost === "function") {
+			const normalized = normalizeBedrockModel(stripProviderPrefix(modelName));
+			return prices.calculateCost({
+				model: normalized,
+				inputTokens: safeInt(inputTokens),
+				outputTokens: safeInt(outputTokens),
+				reasoningTokens: safeInt(reasoningTokens),
+				cacheReadInputTokens: safeInt(cacheReadInputTokens),
+				cacheCreationInputTokens: safeInt(cacheCreationInputTokens)
+			}) ?? 0;
+		}
+	} catch {}
+	return 0;
+}
+
+//#endregion
+export { calculateCost, getGenaiPriceLookupCandidates, inferProvider, stripProviderPrefix };
+//# sourceMappingURL=costs.js.map

package/dist/utils/costs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"costs.js","names":["candidates: string[]"],"sources":["../../src/utils/costs.ts"],"sourcesContent":["/**\n * Cost calculation utilities.\n *\n * Uses the genai-prices package when available (npm: @pydantic/genai-prices).\n * Falls back to returning 0 when not installed.\n */\n\nimport { inferProviderFromModel } from './providers.js';\nimport { tryRequire } from './resolve-module.js';\n\nconst genaiPrices = tryRequire('@pydantic/genai-prices');\n\nexport function stripProviderPrefix(modelName: string): string {\n  const colonIdx = modelName.indexOf(':');\n  return colonIdx >= 0 ? modelName.slice(colonIdx + 1) : modelName;\n}\n\nfunction normalizeBedrockModel(modelName: string): string {\n  const match = modelName.match(\n    /(?:us\\.|eu\\.|ap\\.)?(?:anthropic|meta|mistral|amazon|cohere)\\.(.*)/,\n  );\n  return match?.[1] ?? modelName;\n}\n\n/**\n * Infer the provider name from a model name.\n * Delegates to the canonical implementation in utils/providers.ts.\n */\nexport const inferProvider = inferProviderFromModel;\n\n/**\n * Generate candidate model names for price lookup, mirroring Python's\n * get_genai_price_lookup_candidates(). Tries progressively stripped names\n * so the caller can attempt each until a match is found.\n */\nexport function getGenaiPriceLookupCandidates(modelName: string): string[] {\n  const candidates: string[] = [];\n  const stripped = stripProviderPrefix(modelName);\n  const normalized = normalizeBedrockModel(stripped);\n\n  if (normalized !== modelName) candidates.push(normalized);\n  if (stripped !== modelName && stripped !== normalized)\n    candidates.push(stripped);\n  candidates.push(modelName);\n\n  return [...new Set(candidates)];\n}\n\nfunction safeInt(value: unknown): number {\n  if (typeof value === 'number' && !Number.isNaN(value))\n    return Math.round(value);\n  return 0;\n}\n\nexport function calculateCost(options: {\n  modelName: string;\n  inputTokens: number;\n  outputTokens: number;\n  reasoningTokens?: number;\n  cacheReadInputTokens?: number;\n  cacheCreationInputTokens?: number;\n}): number {\n  const {\n    modelName,\n    inputTokens,\n    outputTokens,\n    reasoningTokens = 0,\n    cacheReadInputTokens = 0,\n    cacheCreationInputTokens = 0,\n  } = options;\n\n  if (genaiPrices != null) {\n    try {\n      const prices = genaiPrices as Record<string, unknown>;\n      if (typeof prices.calculateCost === 'function') {\n        const stripped = stripProviderPrefix(modelName);\n        const normalized = normalizeBedrockModel(stripped);\n        const cost = prices.calculateCost({\n          model: normalized,\n          inputTokens: safeInt(inputTokens),\n          outputTokens: safeInt(outputTokens),\n          reasoningTokens: safeInt(reasoningTokens),\n          cacheReadInputTokens: safeInt(cacheReadInputTokens),\n          cacheCreationInputTokens: safeInt(cacheCreationInputTokens),\n        }) as number | null;\n        return cost ?? 0;\n      }\n    } catch {\n      // Fall through to 0\n    }\n  }\n\n  return 0;\n}\n"],"mappings":";;;;;;;;;;AAUA,MAAM,cAAc,WAAW,yBAAyB;AAExD,SAAgB,oBAAoB,WAA2B;CAC7D,MAAM,WAAW,UAAU,QAAQ,IAAI;AACvC,QAAO,YAAY,IAAI,UAAU,MAAM,WAAW,EAAE,GAAG;;AAGzD,SAAS,sBAAsB,WAA2B;AAIxD,QAHc,UAAU,MACtB,oEACD,GACc,MAAM;;;;;;AAOvB,MAAa,gBAAgB;;;;;;AAO7B,SAAgB,8BAA8B,WAA6B;CACzE,MAAMA,aAAuB,EAAE;CAC/B,MAAM,WAAW,oBAAoB,UAAU;CAC/C,MAAM,aAAa,sBAAsB,SAAS;AAElD,KAAI,eAAe,UAAW,YAAW,KAAK,WAAW;AACzD,KAAI,aAAa,aAAa,aAAa,WACzC,YAAW,KAAK,SAAS;AAC3B,YAAW,KAAK,UAAU;AAE1B,QAAO,CAAC,GAAG,IAAI,IAAI,WAAW,CAAC;;AAGjC,SAAS,QAAQ,OAAwB;AACvC,KAAI,OAAO,UAAU,YAAY,CAAC,OAAO,MAAM,MAAM,CACnD,QAAO,KAAK,MAAM,MAAM;AAC1B,QAAO;;AAGT,SAAgB,cAAc,SAOnB;CACT,MAAM,EACJ,WACA,aACA,cACA,kBAAkB,GAClB,uBAAuB,GACvB,2BAA2B,MACzB;AAEJ,KAAI,eAAe,KACjB,KAAI;EACF,MAAM,SAAS;AACf,MAAI,OAAO,OAAO,kBAAkB,YAAY;GAE9C,MAAM,aAAa,sBADF,oBAAoB,UAAU,CACG;AASlD,UARa,OAAO,cAAc;IAChC,OAAO;IACP,aAAa,QAAQ,YAAY;IACjC,cAAc,QAAQ,aAAa;IACnC,iBAAiB,QAAQ,gBAAgB;IACzC,sBAAsB,QAAQ,qBAAqB;IACnD,0BAA0B,QAAQ,yBAAyB;IAC5D,CAAC,IACa;;SAEX;AAKV,QAAO"}

package/dist/utils/debug.d.ts

@@ -0,0 +1,6 @@
+//#region src/utils/debug.d.ts
+declare function formatDebugLine(event: unknown): string;
+declare function formatDryRunLine(event: unknown): string;
+//#endregion
+export { formatDebugLine, formatDryRunLine };
+//# sourceMappingURL=debug.d.ts.map

package/dist/utils/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","names":[],"sources":["../../src/utils/debug.ts"],"sourcesContent":[],"mappings":";iBAyCgB,eAAA;AAAA,iBAuEA,gBAAA,CAvEe,KAAA,EAAA,OAAA,CAAA,EAAA,MAAA"}

package/dist/utils/debug.js

@@ -0,0 +1,73 @@
+import { EVENT_AI_RESPONSE, EVENT_EMBEDDING, EVENT_SCORE, EVENT_SESSION_END, EVENT_SESSION_ENRICHMENT, EVENT_SPAN, EVENT_TOOL_CALL, EVENT_USER_MESSAGE, PROP_AGENT_ID, PROP_COST_USD, PROP_EMBEDDING_DIMENSIONS, PROP_ENRICHMENTS, PROP_INPUT_TOKENS, PROP_IS_ERROR, PROP_LATENCY_MS, PROP_MODEL_NAME, PROP_OUTPUT_TOKENS, PROP_PROVIDER, PROP_SCORE_NAME, PROP_SCORE_VALUE, PROP_SESSION_ID, PROP_SPAN_NAME, PROP_TARGET_ID, PROP_TOOL_NAME, PROP_TOOL_SUCCESS } from "../core/constants.js";
+
+//#region src/utils/debug.ts
+const CYAN = "\x1B[36m";
+const GREEN = "\x1B[32m";
+const RED = "\x1B[31m";
+const YELLOW = "\x1B[33m";
+const DIM = "\x1B[2m";
+const RESET = "\x1B[0m";
+function formatDebugLine(event) {
+	const e = event;
+	const eventType = e.event_type ?? "unknown";
+	const userId = e.user_id ?? "?";
+	const props = e.event_properties ?? {};
+	let line = `${CYAN}[amplitude-ai]${RESET} ${eventType} ${DIM}|${RESET} user=${userId}`;
+	const sessionId = props[PROP_SESSION_ID];
+	if (sessionId) line += ` session=${sessionId}`;
+	const agentId = props[PROP_AGENT_ID];
+	if (agentId) line += ` agent=${agentId}`;
+	if (eventType === EVENT_AI_RESPONSE) {
+		const model = props[PROP_MODEL_NAME] ?? "?";
+		const latency = props[PROP_LATENCY_MS] ?? "?";
+		const inputTokens = props[PROP_INPUT_TOKENS] ?? "?";
+		const outputTokens = props[PROP_OUTPUT_TOKENS] ?? "?";
+		const cost = props[PROP_COST_USD];
+		line += ` ${GREEN}model=${model}${RESET} latency=${latency}ms tokens=${inputTokens}→${outputTokens}`;
+		if (cost != null) line += ` cost=$${cost}`;
+		if (props[PROP_IS_ERROR]) line += ` ${RED}ERROR${RESET}`;
+	} else if (eventType === EVENT_TOOL_CALL) {
+		line += ` ${YELLOW}tool=${props[PROP_TOOL_NAME] ?? "?"}${RESET}`;
+		line += ` success=${props[PROP_TOOL_SUCCESS] ?? "?"}`;
+		line += ` latency=${props[PROP_LATENCY_MS] ?? "?"}ms`;
+	} else if (eventType === EVENT_USER_MESSAGE) {
+		const latency = props[PROP_LATENCY_MS];
+		if (latency != null) line += ` latency=${latency}ms`;
+	} else if (eventType === EVENT_SCORE) {
+		line += ` ${GREEN}score=${props[PROP_SCORE_NAME] ?? "?"}${RESET}`;
+		line += ` value=${props[PROP_SCORE_VALUE] ?? "?"}`;
+		line += ` target=${props[PROP_TARGET_ID] ?? "?"}`;
+	} else if (eventType === EVENT_EMBEDDING) {
+		line += ` ${GREEN}model=${props[PROP_MODEL_NAME] ?? "?"}${RESET}`;
+		line += ` provider=${props[PROP_PROVIDER] ?? "?"}`;
+		const dims = props[PROP_EMBEDDING_DIMENSIONS];
+		if (dims != null) line += ` dims=${dims}`;
+		line += ` latency=${props[PROP_LATENCY_MS] ?? "?"}ms`;
+	} else if (eventType === EVENT_SPAN) {
+		line += ` ${YELLOW}span=${props[PROP_SPAN_NAME] ?? "?"}${RESET}`;
+		line += ` latency=${props[PROP_LATENCY_MS] ?? "?"}ms`;
+		if (props[PROP_IS_ERROR]) line += ` ${RED}ERROR${RESET}`;
+	} else if (eventType === EVENT_SESSION_END) line += ` ${DIM}session-end${RESET}`;
+	else if (eventType === EVENT_SESSION_ENRICHMENT) {
+		const enrichments = props[PROP_ENRICHMENTS];
+		let count = 0;
+		if (enrichments != null && typeof enrichments === "object") count = Object.keys(enrichments).length;
+		else if (typeof enrichments === "string") try {
+			const parsed = JSON.parse(enrichments);
+			if (parsed != null && typeof parsed === "object" && !Array.isArray(parsed)) count = Object.keys(parsed).length;
+		} catch {}
+		line += ` ${DIM}enrichment keys=${count}${RESET}`;
+	}
+	return line;
+}
+function formatDryRunLine(event) {
+	try {
+		return JSON.stringify(event);
+	} catch {
+		return String(event);
+	}
+}
+
+//#endregion
+export { formatDebugLine, formatDryRunLine };
+//# sourceMappingURL=debug.js.map

package/dist/utils/debug.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.js","names":[],"sources":["../../src/utils/debug.ts"],"sourcesContent":["import {\n  EVENT_AI_RESPONSE,\n  EVENT_EMBEDDING,\n  EVENT_SCORE,\n  EVENT_SESSION_END,\n  EVENT_SESSION_ENRICHMENT,\n  EVENT_SPAN,\n  EVENT_TOOL_CALL,\n  EVENT_USER_MESSAGE,\n  PROP_AGENT_ID,\n  PROP_COST_USD,\n  PROP_EMBEDDING_DIMENSIONS,\n  PROP_ENRICHMENTS,\n  PROP_INPUT_TOKENS,\n  PROP_IS_ERROR,\n  PROP_LATENCY_MS,\n  PROP_MODEL_NAME,\n  PROP_OUTPUT_TOKENS,\n  PROP_PROVIDER,\n  PROP_SCORE_NAME,\n  PROP_SCORE_VALUE,\n  PROP_SESSION_ID,\n  PROP_SPAN_NAME,\n  PROP_TARGET_ID,\n  PROP_TOOL_NAME,\n  PROP_TOOL_SUCCESS,\n} from '../core/constants.js';\n\nconst CYAN = '\\x1b[36m';\nconst GREEN = '\\x1b[32m';\nconst RED = '\\x1b[31m';\nconst YELLOW = '\\x1b[33m';\nconst DIM = '\\x1b[2m';\nconst RESET = '\\x1b[0m';\n\ninterface EventLike {\n  event_type?: string;\n  user_id?: string;\n  event_properties?: Record<string, unknown>;\n}\n\nexport function formatDebugLine(event: unknown): string {\n  const e = event as EventLike;\n  const eventType = e.event_type ?? 'unknown';\n  const userId = e.user_id ?? '?';\n  const props = e.event_properties ?? {};\n\n  let line = `${CYAN}[amplitude-ai]${RESET} ${eventType} ${DIM}|${RESET} user=${userId}`;\n\n  const sessionId = props[PROP_SESSION_ID];\n  if (sessionId) line += ` session=${sessionId}`;\n\n  const agentId = props[PROP_AGENT_ID];\n  if (agentId) line += ` agent=${agentId}`;\n\n  if (eventType === EVENT_AI_RESPONSE) {\n    const model = props[PROP_MODEL_NAME] ?? '?';\n    const latency = props[PROP_LATENCY_MS] ?? '?';\n    const inputTokens = props[PROP_INPUT_TOKENS] ?? '?';\n    const outputTokens = props[PROP_OUTPUT_TOKENS] ?? '?';\n    const cost = props[PROP_COST_USD];\n    line += ` ${GREEN}model=${model}${RESET} latency=${latency}ms tokens=${inputTokens}→${outputTokens}`;\n    if (cost != null) line += ` cost=$${cost}`;\n    if (props[PROP_IS_ERROR]) line += ` ${RED}ERROR${RESET}`;\n  } else if (eventType === EVENT_TOOL_CALL) {\n    line += ` ${YELLOW}tool=${props[PROP_TOOL_NAME] ?? '?'}${RESET}`;\n    line += ` success=${props[PROP_TOOL_SUCCESS] ?? '?'}`;\n    line += ` latency=${props[PROP_LATENCY_MS] ?? '?'}ms`;\n  } else if (eventType === EVENT_USER_MESSAGE) {\n    const latency = props[PROP_LATENCY_MS];\n    if (latency != null) line += ` latency=${latency}ms`;\n  } else if (eventType === EVENT_SCORE) {\n    line += ` ${GREEN}score=${props[PROP_SCORE_NAME] ?? '?'}${RESET}`;\n    line += ` value=${props[PROP_SCORE_VALUE] ?? '?'}`;\n    line += ` target=${props[PROP_TARGET_ID] ?? '?'}`;\n  } else if (eventType === EVENT_EMBEDDING) {\n    line += ` ${GREEN}model=${props[PROP_MODEL_NAME] ?? '?'}${RESET}`;\n    line += ` provider=${props[PROP_PROVIDER] ?? '?'}`;\n    const dims = props[PROP_EMBEDDING_DIMENSIONS];\n    if (dims != null) line += ` dims=${dims}`;\n    line += ` latency=${props[PROP_LATENCY_MS] ?? '?'}ms`;\n  } else if (eventType === EVENT_SPAN) {\n    line += ` ${YELLOW}span=${props[PROP_SPAN_NAME] ?? '?'}${RESET}`;\n    line += ` latency=${props[PROP_LATENCY_MS] ?? '?'}ms`;\n    if (props[PROP_IS_ERROR]) line += ` ${RED}ERROR${RESET}`;\n  } else if (eventType === EVENT_SESSION_END) {\n    line += ` ${DIM}session-end${RESET}`;\n  } else if (eventType === EVENT_SESSION_ENRICHMENT) {\n    const enrichments = props[PROP_ENRICHMENTS];\n    let count = 0;\n    if (enrichments != null && typeof enrichments === 'object') {\n      count = Object.keys(enrichments).length;\n    } else if (typeof enrichments === 'string') {\n      try {\n        const parsed = JSON.parse(enrichments) as unknown;\n        if (\n          parsed != null &&\n          typeof parsed === 'object' &&\n          !Array.isArray(parsed)\n        ) {\n          count = Object.keys(parsed).length;\n        }\n      } catch {\n        // keep count at 0 when enrichments is non-JSON text\n      }\n    }\n    line += ` ${DIM}enrichment keys=${count}${RESET}`;\n  }\n\n  return line;\n}\n\nexport function formatDryRunLine(event: unknown): string {\n  try {\n    return JSON.stringify(event);\n  } catch {\n    return String(event);\n  }\n}\n"],"mappings":";;;AA4BA,MAAM,OAAO;AACb,MAAM,QAAQ;AACd,MAAM,MAAM;AACZ,MAAM,SAAS;AACf,MAAM,MAAM;AACZ,MAAM,QAAQ;AAQd,SAAgB,gBAAgB,OAAwB;CACtD,MAAM,IAAI;CACV,MAAM,YAAY,EAAE,cAAc;CAClC,MAAM,SAAS,EAAE,WAAW;CAC5B,MAAM,QAAQ,EAAE,oBAAoB,EAAE;CAEtC,IAAI,OAAO,GAAG,KAAK,gBAAgB,MAAM,GAAG,UAAU,GAAG,IAAI,GAAG,MAAM,QAAQ;CAE9E,MAAM,YAAY,MAAM;AACxB,KAAI,UAAW,SAAQ,YAAY;CAEnC,MAAM,UAAU,MAAM;AACtB,KAAI,QAAS,SAAQ,UAAU;AAE/B,KAAI,cAAc,mBAAmB;EACnC,MAAM,QAAQ,MAAM,oBAAoB;EACxC,MAAM,UAAU,MAAM,oBAAoB;EAC1C,MAAM,cAAc,MAAM,sBAAsB;EAChD,MAAM,eAAe,MAAM,uBAAuB;EAClD,MAAM,OAAO,MAAM;AACnB,UAAQ,IAAI,MAAM,QAAQ,QAAQ,MAAM,WAAW,QAAQ,YAAY,YAAY,GAAG;AACtF,MAAI,QAAQ,KAAM,SAAQ,UAAU;AACpC,MAAI,MAAM,eAAgB,SAAQ,IAAI,IAAI,OAAO;YACxC,cAAc,iBAAiB;AACxC,UAAQ,IAAI,OAAO,OAAO,MAAM,mBAAmB,MAAM;AACzD,UAAQ,YAAY,MAAM,sBAAsB;AAChD,UAAQ,YAAY,MAAM,oBAAoB,IAAI;YACzC,cAAc,oBAAoB;EAC3C,MAAM,UAAU,MAAM;AACtB,MAAI,WAAW,KAAM,SAAQ,YAAY,QAAQ;YACxC,cAAc,aAAa;AACpC,UAAQ,IAAI,MAAM,QAAQ,MAAM,oBAAoB,MAAM;AAC1D,UAAQ,UAAU,MAAM,qBAAqB;AAC7C,UAAQ,WAAW,MAAM,mBAAmB;YACnC,cAAc,iBAAiB;AACxC,UAAQ,IAAI,MAAM,QAAQ,MAAM,oBAAoB,MAAM;AAC1D,UAAQ,aAAa,MAAM,kBAAkB;EAC7C,MAAM,OAAO,MAAM;AACnB,MAAI,QAAQ,KAAM,SAAQ,SAAS;AACnC,UAAQ,YAAY,MAAM,oBAAoB,IAAI;YACzC,cAAc,YAAY;AACnC,UAAQ,IAAI,OAAO,OAAO,MAAM,mBAAmB,MAAM;AACzD,UAAQ,YAAY,MAAM,oBAAoB,IAAI;AAClD,MAAI,MAAM,eAAgB,SAAQ,IAAI,IAAI,OAAO;YACxC,cAAc,kBACvB,SAAQ,IAAI,IAAI,aAAa;UACpB,cAAc,0BAA0B;EACjD,MAAM,cAAc,MAAM;EAC1B,IAAI,QAAQ;AACZ,MAAI,eAAe,QAAQ,OAAO,gBAAgB,SAChD,SAAQ,OAAO,KAAK,YAAY,CAAC;WACxB,OAAO,gBAAgB,SAChC,KAAI;GACF,MAAM,SAAS,KAAK,MAAM,YAAY;AACtC,OACE,UAAU,QACV,OAAO,WAAW,YAClB,CAAC,MAAM,QAAQ,OAAO,CAEtB,SAAQ,OAAO,KAAK,OAAO,CAAC;UAExB;AAIV,UAAQ,IAAI,IAAI,kBAAkB,QAAQ;;AAG5C,QAAO;;AAGT,SAAgB,iBAAiB,OAAwB;AACvD,KAAI;AACF,SAAO,KAAK,UAAU,MAAM;SACtB;AACN,SAAO,OAAO,MAAM"}

package/dist/utils/logger.d.ts

@@ -0,0 +1,11 @@
+//#region src/utils/logger.d.ts
+interface Logger {
+  debug(message: string): void;
+  error(message: string): void;
+  warn(message: string): void;
+  info(message: string): void;
+}
+declare function getLogger(amplitude?: unknown): Logger;
+//#endregion
+export { Logger, getLogger };
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","names":[],"sources":["../../src/utils/logger.ts"],"sourcesContent":[],"mappings":";UAAiB,MAAA;EAAA,KAAA,CAAA,OAAM,EAAA,MAAA,CAAA,EAAA,IAAA;EAcP,KAAA,CAAA,OAAS,EAAA,MAAA,CAAA,EAAA,IAAuB;;;;iBAAhC,SAAA,uBAAgC"}

package/dist/utils/logger.js

@@ -0,0 +1,18 @@
+//#region src/utils/logger.ts
+const defaultLogger = {
+	debug: () => {},
+	error: (msg) => console.error(`[amplitude-ai] ${msg}`),
+	warn: (msg) => console.warn(`[amplitude-ai] ${msg}`),
+	info: () => {}
+};
+function getLogger(amplitude) {
+	if (amplitude && typeof amplitude === "object") {
+		const config = amplitude.configuration;
+		if (config?.loggerProvider && typeof config.loggerProvider === "object") return config.loggerProvider;
+	}
+	return defaultLogger;
+}
+
+//#endregion
+export { getLogger };
+//# sourceMappingURL=logger.js.map