trodo-node 1.1.0 → 2.1.0

package/README.md

@@ -1,6 +1,6 @@
 # trodo-node
 
-Server-side Node.js SDK for [Trodo Analytics](https://trodo.ai). Track backend events, identify users, and manage people/groups — all merging seamlessly with your frontend Trodo data under the same `siteId`.
+Server-side Node.js SDK for [Trodo Analytics](https://trodo.ai). Track backend events, identify users, manage people/groups, and instrument AI agents — all unified with your frontend data under the same `siteId`.
 
 ## Installation
 
@@ -19,117 +19,81 @@ npm install trodo-node node-fetch
 ```javascript
 const trodo = require('trodo-node');
 
-// Initialize once at app startup
-trodo.init({
-  siteId: 'your-site-id',
-  debug: false,           // optional: log API calls
-  autoEvents: true,       // optional: capture uncaughtException / unhandledRejection
-});
-
-// For identified users — one call creates the session AND fires identify
-const user = await trodo.identify('user@example.com');
-// distinctId is now id_user@example.com; subsequent calls return cached context
-
-// For anonymous/backend-only users
-const anonUser = trodo.forUser('user-123');
+trodo.init({ siteId: 'your-site-id' });
 
-// Track a custom event
+// User-bound context (recommended)
+const user = trodo.forUser('user-123');
 await user.track('purchase_completed', { amount: 99.99, plan: 'pro' });
-
-// Update people profile
 await user.people.set({ plan: 'pro', company: 'Acme' });
 
-// Track a server-side error
-await user.captureError(new Error('payment failed'));
-
-// Flush queued events before process exit
+// Flush before process exit if using batching
 await trodo.shutdown();
 ```
 
-## ESM
-
 ```javascript
+// ESM
 import trodo from 'trodo-node';
 trodo.init({ siteId: 'your-site-id' });
 ```
 
-## Cross-SDK Identity Merging
-
-Frontend and backend events merge when both sides call `identify()` with the same value:
-
-```javascript
-// Browser SDK
-Trodo.identify('user@example.com');    // → id_user@example.com
-
-// Node.js SDK (same value)
-await user.identify('user@example.com'); // → id_user@example.com
-
-// Both event streams now appear together in the Trodo dashboard
-```
-
-## API Reference
+## Core API
 
 ### `trodo.init(config)`
 
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `siteId` | `string` | required | Your Trodo site ID |
-| `apiBase` | `string` | `https://sdkapi.trodo.ai` | API base URL |
-| `debug` | `boolean` | `false` | Log API requests/responses |
-| `autoEvents` | `boolean` | `false` | Hook `uncaughtException` + `unhandledRejection` |
-| `retries` | `number` | `3` | HTTP retry attempts on 5xx errors |
-| `timeout` | `number` | `10000` | HTTP timeout in milliseconds |
-| `batchEnabled` | `boolean` | `false` | Queue events and flush in bulk |
-| `batchSize` | `number` | `50` | Max events per batch flush |
-| `batchFlushIntervalMs` | `number` | `5000` | Flush interval in milliseconds |
-| `onError` | `function` | `undefined` | Callback for SDK errors |
-
-### `trodo.identify(identifyId, options?)` ← primary entry point
+Call once at app startup.
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `siteId` | required | Your Trodo site ID |
+| `apiBase` | `https://sdkapi.trodo.ai` | API base URL |
+| `timeout` | `10000` ms | HTTP request timeout |
+| `retries` | `2` | Retries on network/5xx errors |
+| `autoEvents` | `false` | Hook `uncaughtException` / `unhandledRejection` as `server_error` events |
+| `batchEnabled` | `false` | Queue events and flush in batches |
+| `batchSize` | `50` | Flush when this many events are queued |
+| `batchFlushIntervalMs` | `5000` | Also flush every N milliseconds |
+| `onError` | — | Callback for SDK errors (silent by default) |
+| `debug` | `false` | Log API calls to stderr |
 
-Creates a session, fires `POST /api/sdk/identify` (first call only), caches the context, and returns it. Subsequent calls with the same `identifyId` return the cached context instantly with no API call.
-
-```javascript
-const user = await trodo.identify('user@example.com');
-// distinctId = id_user@example.com — merges with frontend events
-await user.track('purchase_completed', { amount: 99.99 });
-```
+### `trodo.forUser(distinctId, options?)`
 
-Pass `sessionId` to correlate with an active browser session:
+Returns a user-bound context. No API call is made until you track an event.
 
 ```javascript
-const user = await trodo.identify('user@example.com', {
-  sessionId: req.cookies.trodo_session,
+const user = trodo.forUser('user-123', {
+  sessionId: req.cookies.trodo_session,  // optional: correlate with browser session
 });
 ```
 
-### `trodo.forUser(distinctId, options?)`
+### `trodo.identify(identifyId, options?)`
 
-Returns a user-bound context synchronously with no API call. Use this for pure backend tracking where identity is already known and you don't need to merge with frontend events.
+Creates the session and fires `POST /api/sdk/identify`. Use to link a `distinctId` to an external identifier (email, DB id). Returns the user context.
 
 ```javascript
-const user = trodo.forUser('internal-worker-id', {
-  sessionId: req.cookies.trodo_session,  // optional: correlate with browser session
+const user = await trodo.identify('user@example.com', {
+  sessionId: req.cookies.trodo_session,
 });
+// distinctId is now id_user@example.com — merges with browser events
+await user.track('login');
 ```
 
-### User Context Methods
+### User context methods
 
 ```javascript
-await user.track(eventName, properties?)         // Track custom event
-await user.trackEvent(eventName, properties?)    // Alias for track()
-await user.identify(identifyId)                  // Merge identity
-await user.walletAddress(address)                // Set crypto wallet address
-await user.reset()                               // Clear session context
-await user.captureError(error)                   // Track server_error event
+await user.track(eventName, properties?)          // Custom event
+await user.identify(identifyId)                   // Merge identity
+await user.walletAddress(address)                 // Set wallet address
+await user.reset()                                // Clear session
+await user.captureError(err, severity?)           // Track server_error ('critical' | 'error' | 'warning')
 
 // People profile
 await user.people.set(properties)
 await user.people.setOnce(properties)
 await user.people.unset(keys)
-await user.people.increment(properties)
-await user.people.append(properties)
-await user.people.union(properties)
-await user.people.remove(properties)
+await user.people.increment(key, amount?)
+await user.people.append(key, values)
+await user.people.union(key, values)
+await user.people.remove(key, values)
 await user.people.trackCharge(amount, properties?)
 await user.people.clearCharges()
 await user.people.deleteUser()
@@ -141,15 +105,15 @@ await user.remove_group(groupKey, groupId)
 const group = user.get_group(groupKey, groupId)
 await group.set(properties)
 await group.set_once(properties)
-await group.union(properties)
-await group.remove(properties)
+await group.increment(key, amount?)
+await group.append(key, values)
+await group.union(key, values)
+await group.remove(key, values)
 await group.unset(keys)
-await group.increment(properties)
-await group.append(properties)
 await group.delete()
 ```
 
-### Direct Call Pattern (for pipelines)
+### Direct call pattern
 
 ```javascript
 await trodo.track('user-123', 'event_name', { key: 'value' })
@@ -157,25 +121,284 @@ await trodo.people.set('user-123', { plan: 'pro' })
 await trodo.set_group('user-123', 'company', 'acme')
 ```
 
-### Global Methods
+---
+
+## AI Agent Tracing (recommended)
+
+One wrap around your agent captures every LLM call, tool call, and
+nested step as a tree of spans — token counts, costs, inputs, outputs,
+errors. Works with any stack: OpenAI, Anthropic, LangChain, Vercel AI
+SDK, raw HTTP, custom tools. Cost is derived server-side from
+`(provider, model)` — the SDK only sends tokens.
+
+### 30-second quickstart
+
+```typescript
+import trodo from 'trodo-node';
+trodo.init({ siteId: 'your-site-id' });   // autoInstrument on by default
+
+const { result, runId } = await trodo.wrapAgent(
+  'customer-support',
+  async (run) => {
+    run.setInput({ query });
+    const answer = await agent.run(query);  // OpenAI/Anthropic/LangChain auto-captured
+    run.setOutput(answer);
+    return answer;
+  },
+  { distinctId: userId, conversationId: sessionId },
+);
+```
+
+Open the Agent Runs dashboard — the row shows tokens in/out, cost,
+span count, tool count, error count, plus the full trace tree.
+
+### Auto-instrumentation
+
+`trodo.init()` calls `enableAutoInstrument()` which registers every
+installed OpenTelemetry instrumentor — no extra wiring.
+
+| Framework | Install |
+|-----------|---------|
+| OpenAI | `npm i @opentelemetry/instrumentation-openai` |
+| Anthropic | `npm i @opentelemetry/instrumentation-anthropic` |
+| LangChain | `npm i @opentelemetry/instrumentation-langchain` |
+| LlamaIndex | `npm i @opentelemetry/instrumentation-llamaindex` |
+| Google Gemini | `npm i @opentelemetry/instrumentation-google-generativeai` |
+| Vertex AI | `npm i @opentelemetry/instrumentation-vertexai` |
+| Bedrock | `npm i @opentelemetry/instrumentation-bedrock` |
+| Cohere | `npm i @opentelemetry/instrumentation-cohere` |
+| Vercel AI SDK | emits OTel via `experimental_telemetry: { isEnabled: true }` |
+| http / fetch | bundled — generic HTTP spans for raw-HTTP callers |
+
+Opt out with `trodo.init({ siteId, autoInstrument: false })`.
+
+### Span helpers
+
+Typed function wrappers for custom code — every call becomes a span
+with args auto-captured as `input`, return value as `output`,
+exception as `error`.
+
+```typescript
+// trace — generic span
+const prepared = trodo.trace('prepare', async (payload) => normalize(payload));
+await prepared({ raw: true });
+
+// tool — tool span (name-first OR fn-first)
+const runFunnel = trodo.tool('run_funnel_query', async (teamId, preset) => {
+  return await db.funnel(teamId, preset);
+});
+await runFunnel(1, 'day7');
+
+// llm — LLM span, auto-extracts OpenAI / Anthropic / Gemini usage
+const answer = trodo.llm('answer', async (messages) => callOpenAI(messages), {
+  model: 'gpt-4o-mini',
+  provider: 'openai',
+});
+await answer([{ role: 'user', content: 'ping' }]);
+// Records inputTokens / outputTokens from response.usage.
+
+// retrieval — vector search / RAG retriever span
+const search = trodo.retrieval('vector_search', async (q) => vecDb.query(q));
+const docs = await search('users dropping off');
+```
+
+### Raw-HTTP escape hatches
+
+If your LLM client isn't OTel-instrumented and you can't wrap it as a
+function, record a span post-hoc:
+
+```typescript
+const resp = await fetch(url, { body: JSON.stringify(body) }).then(r => r.json());
+await trodo.trackLlmCall({
+  model: 'gemini-2.5-flash',
+  provider: 'google',
+  inputTokens: resp.usageMetadata.promptTokenCount,
+  outputTokens: resp.usageMetadata.candidatesTokenCount,
+  prompt: body,
+  completion: resp,
+});
+```
+
+For advanced cases, get a raw OTel tracer — the Trodo processor is
+already subscribed:
+
+```typescript
+const tracer = trodo.getTracer('my.module');
+tracer.startActiveSpan('custom', (span) => {
+  span.setAttribute('gen_ai.system', 'my-llm');
+  span.end();
+});
+```
+
+### Cross-service runs
+
+When one service calls another, the downstream service **joins** the
+caller's run instead of creating its own — all spans nest under a
+single timeline.
+
+```typescript
+// Caller — outbound:
+await fetch(url, {
+  method: 'POST',
+  headers: { ...trodo.propagationHeaders(), 'content-type': 'application/json' },
+  body: JSON.stringify(payload),
+});
+
+// Downstream (Express):
+import express from 'express';
+const app = express();
+app.use(trodo.expressMiddleware());
+// Every LLM call / tool / trace helper inside handlers now nests under
+// the caller's run.
+
+// Or manually:
+await trodo.joinRun(
+  req.headers['x-trodo-run-id'] as string,
+  req.headers['x-trodo-parent-span-id'] as string,
+  async () => { /* ... */ },
+);
+```
+
+### Conversation binding & feedback
+
+```typescript
+const { runId } = await trodo.wrapAgent(
+  'chat',
+  async (run) => { /* ... */ },
+  { distinctId: userId, conversationId: sessionId },
+);
+await trodo.feedback(runId, { satisfaction: 'positive', rating: 5 });
+```
+
+---
+
+## Agent Analytics (legacy event-based API)
+
+The older per-event API below is still supported but superseded by
+`wrapAgent` + span helpers above. Use it only if you're already wired
+into it; new integrations should prefer the tracing API.
+
+**Before you start:** register your agent in **Integrations → AI Agents** in the dashboard to get an `agent_id` (`agt_xxxxxxxx`).
+
+### `track_agent_call` — inbound message / LLM invocation
 
 ```javascript
-trodo.enableAutoEvents()          // Enable uncaughtException hooks
-trodo.disableAutoEvents()         // Disable hooks
-await trodo.flush()               // Flush pending batch queue
-await trodo.shutdown()            // Flush + stop background timers
+await trodo.track_agent_call({
+  agentId: 'agt_abc12345',
+  conversationId: 'conv_xyz',
+  messageId: 'msg_001',
+  prompt: userMessage,
+  model: 'gpt-4o',
+  provider: 'openai',
+  systemPromptVersion: 'v2',   // optional — track prompt iterations
+  distinctId: userId,           // optional — link to a Trodo user
+  metadata: { threadSource: 'slack', locale: 'en' }, // optional — stored in agent_calls.metadata (JSONB)
+});
 ```
 
-## Auto Events
+### `track_tool_use` — tool/function call within a turn
 
-When `autoEvents: true`, the SDK hooks Node.js process error events and sends `server_error` events to Trodo:
+```javascript
+await trodo.track_tool_use({
+  agentId: 'agt_abc12345',
+  conversationId: 'conv_xyz',
+  messageId: 'msg_001',
+  toolName: 'fetch_billing_info',
+  latencyMs: 143,
+  status: 'success',            // 'success' | 'failure'
+  input: { userId: '123' },     // optional
+  output: { plan: 'pro' },      // optional
+});
+```
 
-- `process.on('uncaughtException')` 
-- `process.on('unhandledRejection')`
+### `track_agent_response` — LLM output and token usage
 
-These events use `distinct_id: 'server_global'` in the dashboard.
+```javascript
+await trodo.track_agent_response({
+  agentId: 'agt_abc12345',
+  conversationId: 'conv_xyz',
+  messageId: 'msg_001',
+  model: 'gpt-4o',
+  completionTokens: response.usage.completion_tokens,
+  promptTokens: response.usage.prompt_tokens,
+  totalTokens: response.usage.total_tokens,
+  finishReason: response.choices[0].finish_reason,
+  distinctId: userId,
+});
+```
 
-Per-user error capture: `user.captureError(error)` uses the user's own `distinctId`.
+### `track_agent_error` — errors and failures
+
+```javascript
+await trodo.track_agent_error({
+  agentId: 'agt_abc12345',
+  conversationId: 'conv_xyz',
+  messageId: 'msg_001',
+  errorType: 'rate_limit',       // 'timeout' | 'rate_limit' | 'guardrail_block' | ...
+  errorMessage: err.message,
+  failedTool: 'fetch_billing_info',  // optional
+});
+```
+
+### `track_feedback` — user thumbs up/down
+
+```javascript
+await trodo.track_feedback({
+  agentId: 'agt_abc12345',
+  conversationId: 'conv_xyz',
+  messageId: 'msg_001',          // same messageId as the response it refers to
+  feedback: 'positive',          // 'positive' | 'negative' | 'unreact'
+  distinctId: userId,
+});
+```
+
+### Full turn example
+
+```javascript
+async function runAgentTurn(userId, conversationId, userMessage) {
+  const agentId = 'agt_abc12345';
+  const messageId = `msg_${Date.now()}`;
+
+  await trodo.track_agent_call({ agentId, conversationId, messageId, prompt: userMessage, distinctId: userId });
+
+  try {
+    await trodo.track_tool_use({ agentId, conversationId, messageId, toolName: 'search', status: 'success', latencyMs: 80 });
+
+    const response = await llm.complete(userMessage);
+
+    await trodo.track_agent_response({
+      agentId, conversationId, messageId,
+      model: response.model,
+      completionTokens: response.usage.completion_tokens,
+      promptTokens: response.usage.prompt_tokens,
+      totalTokens: response.usage.total_tokens,
+      distinctId: userId,
+    });
+
+    return response.text;
+  } catch (err) {
+    await trodo.track_agent_error({ agentId, conversationId, messageId, errorType: err.type, errorMessage: err.message, distinctId: userId });
+    throw err;
+  }
+}
+```
+
+---
+
+## Identity Merging (Cross-SDK)
+
+Call `identify()` with the **same value** on the browser and server to merge all events under one user profile:
+
+```javascript
+// Browser
+Trodo.identify('user@example.com');   // → id_user@example.com
+
+// Node.js (same value)
+await user.identify('user@example.com');  // → id_user@example.com
+// Events from both sides now appear together in the dashboard
+```
+
+---
 
 ## Batching
 
@@ -183,26 +406,40 @@ Per-user error capture: `user.captureError(error)` uses the user's own `distinct
 trodo.init({
   siteId: 'your-site-id',
   batchEnabled: true,
-  batchSize: 100,
-  batchFlushIntervalMs: 3000,
+  batchSize: 50,
+  batchFlushIntervalMs: 5000,
 });
 
-// Events are queued and flushed every 3s or when 100 events accumulate
-await user.track('page_view');
-
 // Always flush before process exit
-process.on('SIGTERM', () => trodo.shutdown());
+process.on('SIGTERM', async () => { await trodo.shutdown(); process.exit(0); });
+```
+
+---
+
+## Auto Events
+
+```javascript
+trodo.init({ siteId: 'your-site-id', autoEvents: true });
+// Hooks process.on('uncaughtException') and process.on('unhandledRejection')
+// Sends server_error events with distinct_id: 'server_global'
+
+// Toggle at runtime
+trodo.enableAutoEvents();
+trodo.disableAutoEvents();
 ```
 
+---
+
 ## TypeScript
 
-Full TypeScript support with bundled type declarations:
+Full type declarations bundled:
 
 ```typescript
-import trodo, { TrodoConfig, ForUserOptions } from 'trodo-node';
+import trodo, { TrodoClient, UserContext } from 'trodo-node';
+import type { AgentCallProps, ToolUseProps, AgentResponseProps, AgentErrorProps, FeedbackProps } from 'trodo-node';
 
-const config: TrodoConfig = { siteId: 'your-site-id' };
-trodo.init(config);
+// Multi-tenant
+const client = new TrodoClient({ siteId: 'your-site-id' });
 ```
 
 ## License

package/dist/cjs/TrodoClient.js

@@ -7,6 +7,10 @@ const EventQueue_js_1 = require("./queue/EventQueue.js");
 const BatchFlusher_js_1 = require("./queue/BatchFlusher.js");
 const AutoEventManager_js_1 = require("./auto/AutoEventManager.js");
 const UserContext_js_1 = require("./UserContext.js");
+const processor_js_1 = require("./otel/processor.js");
+const wrapAgent_js_1 = require("./otel/wrapAgent.js");
+const helpers_js_1 = require("./otel/helpers.js");
+const autoInstrument_js_1 = require("./otel/autoInstrument.js");
 const DEFAULT_API_BASE = 'https://sdkapi.trodo.ai';
 class TrodoClient {
     constructor(config) {
@@ -30,7 +34,11 @@ class TrodoClient {
         if (config.autoEvents) {
             this.autoEventManager.enable();
         }
-        // Wire up direct-call-pattern people helpers
+        this.spanProcessor = new processor_js_1.TrodoSpanProcessor({ apiClient: this.apiClient });
+        // Default ON — matches Python SDK. Opt out with autoInstrument: false.
+        if (config.autoInstrument !== false) {
+            (0, autoInstrument_js_1.enableAutoInstrument)({ processor: this.spanProcessor });
+        }
         const client = this;
         this.people = {
             set: (d, p) => client.forUser(d).people.set(p),
@@ -49,17 +57,13 @@ class TrodoClient {
     // Primary pattern: forUser()
     // --------------------------------------------------------------------------
     forUser(distinctId, options) {
-        const key = distinctId;
-        const cached = this.userContextCache.get(key);
+        const cached = this.userContextCache.get(distinctId);
         if (cached)
             return cached;
         const ctx = new UserContext_js_1.UserContext(distinctId, this.siteId, this.apiClient, this.sessionManager, this.eventQueue, this.batchFlusher, this.autoEventManager, options);
-        this.userContextCache.set(key, ctx);
+        this.userContextCache.set(distinctId, ctx);
         return ctx;
     }
-    // --------------------------------------------------------------------------
-    // Direct-call pattern (distinctId as first param)
-    // --------------------------------------------------------------------------
     async track(distinctId, eventName, properties, options) {
         return this.forUser(distinctId).track(eventName, properties, options);
     }
@@ -90,21 +94,12 @@ class TrodoClient {
     get_group(distinctId, groupKey, groupId) {
         return this.forUser(distinctId).get_group(groupKey, groupId);
     }
-    // --------------------------------------------------------------------------
-    // Auto events
-    // --------------------------------------------------------------------------
-    enableAutoEvents() {
-        this.autoEventManager.enable();
-    }
-    disableAutoEvents() {
-        this.autoEventManager.disable();
-    }
-    // --------------------------------------------------------------------------
-    // Lifecycle
-    // --------------------------------------------------------------------------
+    enableAutoEvents() { this.autoEventManager.enable(); }
+    disableAutoEvents() { this.autoEventManager.disable(); }
     async flush() {
         if (this.batchFlusher)
             await this.batchFlusher.flush();
+        await this.spanProcessor.forceFlush();
     }
     async shutdown() {
         this.autoEventManager.disable();
@@ -112,6 +107,69 @@ class TrodoClient {
             this.batchFlusher.stop();
             await this.batchFlusher.flush();
         }
+        await this.spanProcessor.shutdown();
+    }
+    // --------------------------------------------------------------------------
+    // Agent Runs — unified surface
+    // --------------------------------------------------------------------------
+    /**
+     * Wrap an async function as an agent run. Callback receives a RunHandle
+     * — call `handle.setInput(...)` / `handle.setOutput(...)` to populate the
+     * run's input/output fields. Every OTel-auto-instrumented LLM call or
+     * nested `withSpan` inside `fn` is captured as a child span.
+     * Returns { result, runId } — runId is used to attach feedback later.
+     */
+    wrapAgent(agentName, fn, options = {}) {
+        return (0, wrapAgent_js_1.wrapAgent)(this.spanProcessor, this.siteId, agentName, fn, options);
+    }
+    /** Create a nested span inside the current run. */
+    withSpan(name, fn, options = {}) {
+        return (0, wrapAgent_js_1.withSpan)(this.spanProcessor, name, fn, options);
+    }
+    /**
+     * Join an existing run owned by a remote service — opens a span (not a new
+     * run) in that run's context. Spans inside `fn` are streamed to the backend
+     * via append_spans. Used by the express middleware and for manual cross-
+     * service join on any request shape.
+     */
+    joinRun(runId, parentSpanId, fn, options = {}) {
+        return (0, wrapAgent_js_1.joinRun)(this.spanProcessor, this.siteId, runId, parentSpanId, fn, options);
+    }
+    /** Higher-order wrapper: decorate a tool-like function so each call becomes a span. */
+    tool(fn, options = {}) {
+        return (0, helpers_js_1.tool)(fn, options);
+    }
+    /** Record a one-shot LLM span for a raw-HTTP caller. */
+    trackLlmCall(params) {
+        return (0, helpers_js_1.trackLlmCall)(params);
+    }
+    /** Return an Express/Connect middleware that auto-joins inbound runs. */
+    expressMiddleware() {
+        return (0, helpers_js_1.expressMiddleware)({
+            processor: this.spanProcessor,
+            teamSiteId: this.siteId,
+        });
+    }
+    /** Outbound HTTP headers carrying the current run/span context. */
+    propagationHeaders() {
+        return (0, helpers_js_1.propagationHeaders)();
+    }
+    /** Expose current run/span ids for bespoke propagation needs. */
+    currentRunId() {
+        return (0, wrapAgent_js_1.currentRunId)();
+    }
+    currentSpanId() {
+        return (0, wrapAgent_js_1.currentSpanId)();
+    }
+    /** Attach feedback to a completed run. Call with the runId returned from wrapAgent. */
+    async feedback(runId, props) {
+        return this.apiClient.postRunFeedback(runId, {
+            satisfaction: props.satisfaction ?? null,
+            rating: props.rating ?? null,
+            comment: props.comment ?? props.feedback ?? null,
+            distinct_id: props.distinctId ?? null,
+            attributes: props.metadata ?? {},
+        });
     }
 }
 exports.TrodoClient = TrodoClient;