@runflow-ai/sdk 1.0.32 → 1.0.34

package/README.md

@@ -401,43 +401,83 @@ await agent.process({
 });
 ```
 
-#### Identification Types
+#### Smart Identification (Auto-Detection)
+
+**New in v2.1:** The `identify()` function now auto-detects entity type from value format:
 
 ```typescript
-// WhatsApp/SMS (by phone)
-Runflow.identify({
-  type: 'phone',
-  value: '+5511999999999',
-});
+import { identify } from '@runflow-ai/sdk/observability';
 
-// Email
-Runflow.identify({
-  type: 'email',
-  value: 'user@example.com',
-});
+// Auto-detect email
+identify('user@example.com');
+// → type: 'email', value: 'user@example.com'
+
+// Auto-detect phone (international)
+identify('+5511999999999');
+// → type: 'phone', value: '+5511999999999'
+
+// Auto-detect phone (local with formatting)
+identify('(11) 99999-9999');
+// → type: 'phone', value: '(11) 99999-9999'
+
+// Auto-detect UUID
+identify('550e8400-e29b-41d4-a716-446655440000');
+// → type: 'uuid'
+
+// Auto-detect URL
+identify('https://example.com');
+// → type: 'url'
+```
+
+**Supported patterns:**
+- **Email**: Standard RFC 5322 format
+- **Phone**: E.164 format (with/without +, with/without formatting)
+- **UUID**: Standard UUID v1-v5
+- **URL**: With or without protocol
+- **Fallback**: Generic `id` type for custom identifiers
+
+#### Explicit Identification
+
+For custom entity types or when auto-detection is not desired:
+
+```typescript
+import { identify } from '@runflow-ai/sdk/observability';
 
 // HubSpot Contact
-Runflow.identify({
+identify({
   type: 'hubspot_contact',
   value: 'contact_123',
   userId: 'user@example.com',
 });
 
-// Custom (order, ticket, etc)
-Runflow.identify({
+// Order/Ticket
+identify({
   type: 'order',
-  value: 'order_456',
+  value: 'ORDER-456',
   userId: 'customer_789',
 });
 
-// With custom threadId
-Runflow.identify({
-  type: 'phone',
-  value: '+5511999999999',
+// Custom threadId override
+identify({
+  type: 'document',
+  value: 'doc_456',
   threadId: 'custom_thread_123',
 });
 ```
 
+#### Backward Compatibility
+
+The old API still works:
+
+```typescript
+import { Runflow } from '@runflow-ai/sdk/core';
+
+Runflow.identify({
+  type: 'email',
+  value: 'user@example.com',
+});
+```
+
 #### State Management
 
 ```typescript
@@ -1394,6 +1434,301 @@ The SDK supports various trace types:
 - `memory_operation` - Memory access
 - `connector_call` - Connector execution
 - `streaming_session` - Streaming response
+- `execution_summary` - Custom execution (new)
+- `custom_event` - Custom log event (new)
+- `error_event` - Error logging (new)
+
+#### Custom Executions (Non-Agent Flows)
+
+For scenarios without `agent.process()` (document analysis, batch processing, etc.):
+
+```typescript
+import { identify, startExecution, log } from '@runflow-ai/sdk/observability';
+
+export async function analyzeDocument(docId: string) {
+  // 1. Identify context
+  identify({ type: 'document', value: docId });
+  
+  // 2. Start custom execution
+  const exec = startExecution({
+    name: 'document-analysis',
+    input: { documentId: docId }
+  });
+  
+  try {
+    // 3. Process with LLM calls
+    const llm = LLM.openai('gpt-4o');
+    
+    const text = await llm.chat("Extract text from document...");
+    exec.log('text_extracted', { length: text.length });
+    
+    const category = await llm.chat(`Classify this: ${text}`);
+    exec.log('document_classified', { category });
+    
+    const summary = await llm.chat(`Summarize: ${text}`);
+    
+    // 4. Finish with custom output
+    await exec.end({
+      output: { 
+        summary, 
+        category,
+        documentId: docId 
+      }
+    });
+    
+    return { summary, category };
+    
+  } catch (error) {
+    exec.setError(error);
+    await exec.end();
+    throw error;
+  }
+}
+```
+
+**In the Portal:**
+```
+Thread: document_xxx_doc_456
+└─ Execution: "document-analysis"
+   ├─ llm_call: Extract text
+   ├─ custom_event: text_extracted
+   ├─ llm_call: Classify
+   ├─ custom_event: document_classified
+   └─ llm_call: Summarize
+```
+
+#### Custom Logging
+
+Log custom events within any execution:
+
+```typescript
+import { log, logEvent, logError } from '@runflow-ai/sdk/observability';
+
+// Simple log
+log('cache_hit', { key: 'user_123' });
+
+// Structured log
+logEvent('validation', {
+  input: { orderId: '123', amount: 100 },
+  output: { valid: true, score: 0.95 },
+  metadata: { rule: 'fraud_detection' }
+});
+
+// Error log
+try {
+  await riskyOperation();
+} catch (error) {
+  logError('operation_failed', error);
+  throw error;
+}
+```
+
+Logs are automatically associated with the current execution and flushed with other traces.
+
+#### Exception Safety
+
+The SDK ensures traces are not lost even on crashes:
+
+- **Exit handlers**: Auto-flush on `process.exit()`, `SIGTERM`, `SIGINT`
+- **Exception handlers**: Flush on `uncaughtException` and `unhandledRejection`
+- **Auto-cleanup**: Custom executions auto-flush after 60s if not manually ended
+- **Worker safety**: Execution engine waits 100ms for pending flushes
+
+**Coverage: ~95% trace recovery** even on crashes.
+
+#### Verbose Tracing Mode
+
+**New in v2.1:** Control how much data is saved in traces - from minimal metadata to complete prompts and responses.
+
+**Modes:**
+- **`minimal`**: Only essential metadata (production, minimal storage)
+- **`standard`**: Balanced metadata + sizes (default)
+- **`full`**: Complete data including prompts and responses (debugging)
+
+**Simple API (string preset):**
+```typescript
+const agent = new Agent({
+  name: 'My Agent',
+  model: openai('gpt-4o'),
+  observability: 'full'  // 'minimal', 'standard', or 'full'
+});
+```
+
+**Granular Control (object config):**
+```typescript
+const agent = new Agent({
+  name: 'My Agent',
+  model: openai('gpt-4o'),
+  observability: {
+    mode: 'standard',           // Base mode
+    verboseLLM: true,            // Override: save complete prompts
+    verboseMemory: false,        // Override: keep memory minimal
+    verboseTools: true,          // Override: save tool data (default)
+    maxInputLength: 5000,        // Truncate large inputs
+    maxOutputLength: 5000,       // Truncate large outputs
+  }
+});
+```
+
+**Environment Variable:**
+```bash
+# .env
+RUNFLOW_VERBOSE_TRACING=true  # Auto-sets mode to 'full'
+```
+
+```typescript
+// Auto-detects from environment
+const agent = new Agent({
+  name: 'My Agent',
+  model: openai('gpt-4o'),
+  // observability: 'full' auto-applied if env var set
+});
+```
+
+**What Each Mode Saves:**
+
+| Trace Type | Minimal | Standard | Full |
+|------------|---------|----------|------|
+| **LLM Call** | messagesCount, config | messagesCount, config | Complete messages + responses |
+| **Memory Load** | messagesCount | messagesCount | First 10 messages (truncated) |
+| **Memory Save** | messagesSaved | messagesSaved | User + assistant messages |
+| **Tool Call** | Always full (with truncation) | Always full | Always full |
+| **Agent Execution** | Always full | Always full | Always full |
+
+**Storage Impact:**
+
+- **Minimal**: ~100 bytes/trace
+- **Standard**: ~500 bytes/trace
+- **Full**: ~5KB/trace (with truncation)
+
+**Recommended Usage:**
+
+```typescript
+// Production: minimal storage
+const prodAgent = new Agent({
+  observability: 'minimal'
+});
+
+// Staging: balanced
+const stagingAgent = new Agent({
+  observability: 'standard'
+});
+
+// Development: complete debugging
+const devAgent = new Agent({
+  observability: 'full'
+});
+
+// Or detect automatically
+const agent = new Agent({
+  observability: process.env.NODE_ENV === 'production' ? 'minimal' : 'full'
+});
+```
+
+#### Trace Interceptor (onTrace)
+
+Intercept and modify traces before they are sent, useful for:
+- Sending to external tools (DataDog, Sentry, CloudWatch)
+- Adding custom metadata
+- Filtering specific traces
+- Audit logging
+
+**Example: Send to DataDog**
+```typescript
+const agent = new Agent({
+  observability: {
+    mode: 'full',
+    onTrace: (trace) => {
+      // Send to DataDog
+      datadogTracer.trace({
+        name: trace.operation,
+        resource: trace.type,
+        duration: trace.duration,
+        meta: trace.metadata
+      });
+      
+      // Return trace unchanged to continue normal flow
+      return trace;
+    }
+  }
+});
+```
+
+**Example: Add Custom Metadata**
+```typescript
+const agent = new Agent({
+  observability: {
+    onTrace: (trace) => {
+      // Enrich with custom data
+      trace.metadata.environment = 'production';
+      trace.metadata.version = '1.0.0';
+      trace.metadata.region = 'us-east-1';
+      
+      return trace;
+    }
+  }
+});
+```
+
+**Example: Filter LLM Calls**
+```typescript
+const agent = new Agent({
+  observability: {
+    onTrace: (trace) => {
+      // Only send LLM calls to external tracker
+      if (trace.type === 'llm_call') {
+        externalTracker.send(trace);
+      }
+      
+      return trace;
+    }
+  }
+});
+```
+
+**Example: Cancel Sensitive Traces**
+```typescript
+const agent = new Agent({
+  observability: {
+    onTrace: (trace) => {
+      // Cancel traces with sensitive data
+      if (trace.metadata?.containsSensitiveData) {
+        return null; // ← Cancel trace (won't be sent)
+      }
+      
+      return trace;
+    }
+  }
+});
+```
+
+**Example: Error Tracking with Sentry**
+```typescript
+const agent = new Agent({
+  observability: {
+    onTrace: (trace) => {
+      // Send errors to Sentry
+      if (trace.type === 'error_event' || trace.status === 'error') {
+        Sentry.captureException(new Error(trace.error || 'Unknown error'), {
+          extra: {
+            traceId: trace.traceId,
+            executionId: trace.executionId,
+            operation: trace.operation,
+            metadata: trace.metadata
+          }
+        });
+      }
+      
+      return trace;
+    }
+  }
+});
+```
+
+**Callback Return Values:**
+- `TraceData`: Modified trace (will be sent with changes)
+- `null`: Cancel trace (won't be sent or saved)
+- `void/undefined`: Continue with original trace
 
 ---
 

package/dist/core/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/core/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAsBpG,qBAAa,KAAK;IAChB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,SAAS,CAAC,CAAmB;IACrC,OAAO,CAAC,cAAc,CAAC,CAAM;IAC7B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,kBAAkB,CAAC,CAAS;IACpC,OAAO,CAAC,gBAAgB,CAAC,CAAS;IAClC,OAAO,CAAC,gBAAgB,CAAC,CAAS;gBAEtB,MAAM,EAAE,WAAW;IAsD/B,aAAa,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI;IAa1C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAoD3F,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAgCvF,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,GAAG,CAAA;KAAC,CAAC,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IA0SjG,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,CAAC;YAiUpE,iBAAiB;IAiD/B,OAAO,CAAC,gBAAgB;IAYxB;;OAEG;IACH,OAAO,CAAC,eAAe;IAqBvB,OAAO,CAAC,qBAAqB;IAI7B,OAAO,CAAC,mBAAmB;IAK3B,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,IAAI,KAAK,qCAER;IAED,IAAI,KAAK,mDAER;IAED,IAAI,YAAY,IAAI,OAAO,CAE1B;IAGK,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CA8H5H"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/core/agent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AA4BpG,qBAAa,KAAK;IAChB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,SAAS,CAAC,CAAmB;IACrC,OAAO,CAAC,cAAc,CAAC,CAAM;IAC7B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,kBAAkB,CAAC,CAAS;IACpC,OAAO,CAAC,gBAAgB,CAAC,CAAS;IAClC,OAAO,CAAC,gBAAgB,CAAC,CAAS;gBAEtB,MAAM,EAAE,WAAW;IAsE/B,aAAa,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI;IA2B1C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAoD3F,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAgCvF,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,GAAG,CAAA;KAAC,CAAC,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAkVjG,OAAO,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,WAAW,CAAC;YAyUpE,iBAAiB;IAiD/B,OAAO,CAAC,gBAAgB;IAYxB;;OAEG;IACH,OAAO,CAAC,eAAe;IAqBvB,OAAO,CAAC,qBAAqB;IAI7B,OAAO,CAAC,mBAAmB;IAK3B,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,IAAI,KAAK,qCAER;IAED,IAAI,KAAK,mDAER;IAED,IAAI,YAAY,IAAI,OAAO,CAE1B;IAGK,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,aAAa,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAyI5H"}

package/dist/core/agent.js

@@ -10,11 +10,16 @@ const agent_memory_1 = require("./helpers/agent-memory");
 const agent_rag_1 = require("./helpers/agent-rag");
 const agent_context_1 = require("./helpers/agent-context");
 const agent_utils_1 = require("./helpers/agent-utils");
+const observability_helpers_1 = require("./helpers/observability-helpers");
 // ============================================================================
 // AGENT CLASS
 // ============================================================================
 class Agent {
     constructor(config) {
+        // Merge environment observability config
+        if (!config.observability && process.env.RUNFLOW_VERBOSE_TRACING === 'true') {
+            config.observability = 'full';
+        }
         this.config = config;
         // Configurar logger
         this.logger = (0, logger_1.createLogger)({
@@ -54,10 +59,14 @@ class Agent {
             this.apiClient = (0, api_client_1.createRunflowAPIClient)();
             // Use agentId from environment or config name as fallback
             const projectId = process.env.RUNFLOW_AGENT_ID || this.config.name.toLowerCase().replace(/\s+/g, '-');
+            // Get onTrace callback from observability config
+            const onTraceCallback = typeof this.config.observability === 'object'
+                ? this.config.observability.onTrace
+                : undefined;
             this.traceCollector = (0, trace_collector_1.createTraceCollector)(this.apiClient, projectId, {
                 batchSize: 1, // Flush imediatamente após cada trace
                 flushInterval: 1000,
-            });
+            }, onTraceCallback);
         }
     }
     // Injetar API client (feito pela execution engine)
@@ -65,10 +74,16 @@ class Agent {
         const projectId = process.env.RUNFLOW_AGENT_ID || this.config.name.toLowerCase().replace(/\s+/g, '-');
         this.logger.debug('Setting API client', { projectId });
         this.apiClient = apiClient;
+        // Get onTrace callback from observability config
+        const onTraceCallback = typeof this.config.observability === 'object'
+            ? this.config.observability.onTrace
+            : undefined;
         this.traceCollector = (0, trace_collector_1.createTraceCollector)(apiClient, projectId, {
             batchSize: 1, // Flush imediatamente após cada trace
             flushInterval: 1000,
-        });
+        }, onTraceCallback);
+        // Store in global for standalone functions
+        global.__runflowTraceCollector = this.traceCollector;
     }
     // Geração simples (aceita string ou array de messages)
     async generate(input) {
@@ -184,8 +199,14 @@ class Agent {
             if (llmSpan) {
                 this.currentLLMSpanId = llmSpan.traceId;
             }
-            // 🔍 Input do trace
-            const llmInput = {
+            // 🔍 Input do trace (verbose ou resumido)
+            const obsConfig = (0, observability_helpers_1.normalizeObservabilityConfig)(this.config.observability);
+            const verboseLLM = (0, observability_helpers_1.shouldUseVerbose)(obsConfig, 'llm');
+            const llmInput = verboseLLM ? {
+                messages: (0, observability_helpers_1.truncateMessages)(messages, obsConfig.maxInputLength),
+                temperature: this.config.modelConfig?.temperature,
+                maxTokens: this.config.modelConfig?.maxTokens,
+            } : {
                 messagesCount: messages.length,
                 temperature: this.config.modelConfig?.temperature,
                 maxTokens: this.config.modelConfig?.maxTokens,
@@ -221,8 +242,13 @@ class Agent {
                 toolCallsCount: response.toolCalls?.length || 0,
                 usage: response.usage
             });
-            // 🔍 Output do trace
-            const llmOutput = {
+            // 🔍 Output do trace (verbose ou resumido)
+            const llmOutput = verboseLLM ? {
+                text: (0, observability_helpers_1.truncateData)(response.text, obsConfig.maxOutputLength),
+                hasToolCalls: !!response.toolCalls && response.toolCalls.length > 0,
+                toolCallsCount: response.toolCalls?.length || 0,
+                toolCalls: response.toolCalls,
+            } : {
                 responseLength: response.text?.length || 0,
                 hasToolCalls: !!response.toolCalls && response.toolCalls.length > 0,
                 toolCallsCount: response.toolCalls?.length || 0,
@@ -293,9 +319,12 @@ class Agent {
                     });
                     continue;
                 }
+                // 🔍 Detectar se é RAG tool e usar span type específico
+                const isRAGTool = tool._isRAGTool === true;
+                const spanType = isRAGTool ? 'knowledge_search' : 'tool_call';
                 // 🔍 Iniciar trace da tool execution (ANTES do try/catch, child of current LLM call)
                 const toolStartTime = Date.now();
-                const toolSpan = this.traceCollector?.startSpan('tool_call', {
+                const toolSpan = this.traceCollector?.startSpan(spanType, {
                     toolName,
                     toolId: tool.id,
                     operation: 'execute',
@@ -307,8 +336,25 @@ class Agent {
                     if (typeof args === 'string') {
                         args = JSON.parse(args);
                     }
-                    // 🔍 Input sempre vai completo para o trace
-                    toolSpan?.setInput(args);
+                    // 🔍 Input do trace (com truncation para dados muito grandes)
+                    const obsConfig = (0, observability_helpers_1.normalizeObservabilityConfig)(this.config.observability);
+                    const verboseMode = (0, observability_helpers_1.shouldUseVerbose)(obsConfig, isRAGTool ? 'rag' : 'tool');
+                    // 🔍 Para RAG tools, incluir parâmetros completos no trace
+                    let traceInput;
+                    if (isRAGTool) {
+                        traceInput = {
+                            query: args.query,
+                            vectorStore: tool._vectorStore || 'unknown',
+                            k: tool._k || 5,
+                            threshold: tool._threshold || 0.7,
+                        };
+                    }
+                    else {
+                        traceInput = args;
+                    }
+                    toolSpan?.setInput(verboseMode
+                        ? (0, observability_helpers_1.truncateData)(traceInput, obsConfig.maxInputLength)
+                        : traceInput);
                     // Executar tool com performance tracking
                     // Note: Tools should use createRunflowAPIClient() singleton for API access
                     const state = context_1.Runflow.getState();
@@ -320,7 +366,7 @@ class Agent {
                             sessionId: state.sessionId,
                         });
                     }, { toolId: tool.id, iteration });
-                    // 🔍 Output sempre vai completo para o trace
+                    // 🔍 Output do trace (com truncation para dados muito grandes)
                     const toolEndTime = Date.now();
                     const processingTimeMs = toolEndTime - toolStartTime;
                     this.logger.info('Tool execution completed', {
@@ -329,7 +375,9 @@ class Agent {
                         processingTimeMs,
                         iteration
                     });
-                    toolSpan?.setOutput(toolResult);
+                    toolSpan?.setOutput(verboseMode
+                        ? (0, observability_helpers_1.truncateData)(toolResult, obsConfig.maxOutputLength)
+                        : toolResult);
                     toolSpan?.setMetadata({
                         toolName,
                         toolId: tool.id,
@@ -523,8 +571,11 @@ class Agent {
                     memoryId,
                     memoryType: this.config.memory.type
                 });
+                const obsConfig = (0, observability_helpers_1.normalizeObservabilityConfig)(this.config.observability);
+                const verboseMemory = (0, observability_helpers_1.shouldUseVerbose)(obsConfig, 'memory');
                 const memoryLoadTime = await performance_logger_1.performanceLogger.measure('memory.load', async () => {
-                    return await (0, agent_memory_1.loadMemory)(memoryId, this.apiClient, this.config.memory, this.traceCollector, this.logger, this.currentAgentSpanId // Pass parent for hierarchy
+                    return await (0, agent_memory_1.loadMemory)(memoryId, this.apiClient, this.config.memory, this.traceCollector, this.logger, this.currentAgentSpanId, // Pass parent for hierarchy
+                    verboseMemory // Pass verbose flag
                     );
                 }, { memoryId, memoryType: this.config.memory.type });
                 memoryMessages = memoryLoadTime;
@@ -565,8 +616,11 @@ class Agent {
         let memorySaveTime = 0;
         if (this.config.memory && memoryId) {
             this.logger.debug('Saving to memory', { memoryId });
+            const obsConfig = (0, observability_helpers_1.normalizeObservabilityConfig)(this.config.observability);
+            const verboseMemory = (0, observability_helpers_1.shouldUseVerbose)(obsConfig, 'memory');
             await performance_logger_1.performanceLogger.measure('memory.save', async () => {
-                await (0, agent_memory_1.saveToMemory)(memoryId, input.message, result.text, this.apiClient, this.config.memory, this.config.model, this.traceCollector, this.logger, this.currentAgentSpanId // Pass parent for hierarchy
+                await (0, agent_memory_1.saveToMemory)(memoryId, input.message, result.text, this.apiClient, this.config.memory, this.config.model, this.traceCollector, this.logger, this.currentAgentSpanId, // Pass parent for hierarchy
+                verboseMemory // Pass verbose flag
                 );
             }, { memoryId });
             memorySaveTime = Date.now() - processStartTime - llmProcessingTime;
@@ -757,7 +811,10 @@ Which agent should handle this? Respond with just the agent name.
         let memoryMessages = [];
         if (this.config.memory && memoryId) {
             this.logger.debug('Loading memory for streaming', { memoryId });
-            memoryMessages = await (0, agent_memory_1.loadMemory)(memoryId, this.apiClient, this.config.memory, this.traceCollector, this.logger, this.currentAgentSpanId // Pass parent for hierarchy
+            const obsConfig = (0, observability_helpers_1.normalizeObservabilityConfig)(this.config.observability);
+            const verboseMemory = (0, observability_helpers_1.shouldUseVerbose)(obsConfig, 'memory');
+            memoryMessages = await (0, agent_memory_1.loadMemory)(memoryId, this.apiClient, this.config.memory, this.traceCollector, this.logger, this.currentAgentSpanId, // Pass parent for hierarchy
+            verboseMemory // Pass verbose flag
             );
         }
         // ============================================================================
@@ -798,6 +855,7 @@ Which agent should handle this? Respond with just the agent name.
         const modelConfig = this.config.model;
         const traceCollector = this.traceCollector;
         const agentSpanId = this.currentAgentSpanId;
+        const observabilityConfig = this.config.observability;
         return (async function* () {
             let fullResponse = '';
             for await (const chunk of stream) {
@@ -809,7 +867,10 @@ Which agent should handle this? Respond with just the agent name.
                     // Salvar na memória quando streaming terminar
                     if (memoryConfig && memoryId && apiClient) {
                         logger.debug('Saving stream response to memory', { memoryId });
-                        await (0, agent_memory_1.saveToMemory)(memoryId, input.message, fullResponse, apiClient, memoryConfig, modelConfig, traceCollector, logger, agentSpanId // Pass parent for hierarchy
+                        const obsConfig = (0, observability_helpers_1.normalizeObservabilityConfig)(observabilityConfig);
+                        const verboseMemory = (0, observability_helpers_1.shouldUseVerbose)(obsConfig, 'memory');
+                        await (0, agent_memory_1.saveToMemory)(memoryId, input.message, fullResponse, apiClient, memoryConfig, modelConfig, traceCollector, logger, agentSpanId, // Pass parent for hierarchy
+                        verboseMemory // Pass verbose flag
                         );
                     }
                     logger.info('Stream processing completed', {