newo 3.0.0 → 3.1.0

package/README.md

@@ -20,6 +20,7 @@ Sync NEWO "Project → Agent → Flow → Skills" structure to local files with:
 - 🧠 **AI skill formats** - Support for `.guidance` (AI prompts) and `.jinja` (NSL templates)
 - 📊 **Knowledge base import** - Bulk import AKB articles from structured text files
 - 💬 **Conversation history** - Extract and sync user conversations and personas
+- 🧪 **Sandbox testing** - Interactive agent testing with conversation continuation (NEW v3.1.0)
 - 🔧 **CI/CD ready** - GitHub Actions integration for automated deployments
 
 ---
@@ -142,6 +143,7 @@ NEWO_REFRESH_URL=custom_refresh_endpoint   # Custom refresh endpoint
 | `newo pull` | Download projects + attributes + metadata | • Real-time progress tracking (966+ skills)<br>• IDN-based file naming<br>• Automatic attributes.yaml generation<br>• `--force` for silent overwrite |
 | `newo push` | Upload local changes to NEWO | • Smart file validation<br>• Multiple file detection<br>• Hash-based change detection<br>• Safe error handling |
 | `newo status` | Show modified files with details | • Multiple file warnings<br>• Detailed change analysis<br>• Clean state validation<br>• Per-customer status |
+| `newo sandbox` | Test agents in sandbox chat mode | • Single-command mode for automation<br>• Multi-turn conversation support<br>• Debug info for agent development<br>• Conversation continuation |
 | `newo conversations` | Pull conversation history | • User personas and chat history<br>• YAML format output<br>• Pagination support |
 | `newo list-customers` | List configured customers | • Shows default customer<br>• Multi-customer discovery |
 | `newo import-akb` | Import knowledge base articles | • Structured text parsing<br>• Bulk article import<br>• Validation and error reporting |
@@ -476,6 +478,107 @@ Add these secrets to your repository:
     node ./dist/cli.js push
 ```
 
+## Sandbox Testing (NEW v3.1.0)
+
+Test your NEWO agents in real-time with sandbox chat mode. Perfect for development, debugging, and automated testing workflows.
+
+### Features
+- **Single-command mode** - Send a message and get a response (ideal for automation)
+- **Multi-turn conversations** - Continue chats with conversation context preserved
+- **Debug information** - View flow execution, skill invocation, and session tracking
+- **Unique sessions** - Each test creates a fresh persona for isolation
+
+### Usage
+
+**Start a new conversation:**
+```bash
+newo sandbox "Hello, I want to order a pizza"
+```
+
+**Continue an existing conversation:**
+```bash
+newo sandbox --actor <chat-id> "I want 2 large pepperoni pizzas"
+```
+
+**With verbose debugging:**
+```bash
+newo sandbox "Test message" --verbose
+```
+
+### Example: Multi-Turn Conversation
+
+```bash
+# Turn 1: Start conversation
+$ newo sandbox "I want to order delivery"
+
+📋 Chat Session Created:
+   Chat ID (actor_id): abc123...
+   Persona ID: xyz789...
+   Connector: convo_agent_sandbox
+   External ID: 2f99f7
+
+📤 You: I want to order delivery
+
+🤖 Agent:
+   Awesome! We can definitely get a delivery order started for you! What's your zip code, please?
+
+📊 Debug Summary:
+   Flow: CAMainFlow
+   Skill: _userMessageFastReplySkill
+   Session: 816c769a-8e1c-43e7-b22d-766c7bf63c33
+   Acts Processed: 1 (1 agent, 0 system)
+
+💡 To continue this conversation:
+   npx newo sandbox --actor abc123... "your next message"
+
+
+# Turn 2: Continue conversation
+$ newo sandbox --actor abc123... "90210"
+
+📤 You: 90210
+
+🤖 Agent:
+   Perfect! Now, could you please provide your delivery address?
+
+📊 Debug Summary:
+   Flow: CAMainFlow
+   Skill: CollectAddressSkill
+   Session: 816c769a-8e1c-43e7-b22d-766c7bf63c33
+   Acts Processed: 1 (1 agent, 0 user)
+```
+
+### Debug Information
+
+**Standard Mode** shows:
+- Flow execution path
+- Skill invocation
+- Session ID
+- Act counts (agent vs. system messages)
+
+**Verbose Mode** (`--verbose`) shows:
+- All API requests and responses
+- Complete act structure with arguments
+- Runtime context IDs
+- Detailed polling progress
+
+### Automated Testing Integration
+
+Perfect for CI/CD workflows:
+
+```bash
+# Test agent responses
+RESPONSE=$(newo sandbox "test query" | grep "Agent:" | cut -d: -f2-)
+
+# Validate response contains expected content
+echo "$RESPONSE" | grep -q "expected text" && echo "✓ Test passed"
+
+# Multi-turn testing
+ACTOR_ID=$(newo sandbox "start conversation" | grep "Chat ID" | awk '{print $NF}')
+newo sandbox --actor "$ACTOR_ID" "follow up message"
+```
+
+---
+
 ## AKB Import
 
 Import knowledge base articles from structured text files into NEWO personas:
@@ -1097,6 +1200,14 @@ NEWO CLI integrates with these NEWO platform endpoints:
 - `GET /api/v1/bff/customer/attributes?include_hidden=true` - Get customer attributes
 - `PUT /api/v1/customer/attributes/{attributeId}` - Update customer attribute
 
+### Sandbox Testing (NEW v3.1.0)
+- `GET /api/v1/integrations` - List available integrations
+- `GET /api/v1/integrations/{id}/connectors` - List integration connectors
+- `POST /api/v1/customer/personas` - Create user persona for chat
+- `POST /api/v1/customer/personas/{id}/actors` - Create actor (chat session)
+- `POST /api/v1/chat/user/{actorId}` - Send chat message
+- `GET /api/v1/chat/history` - Poll for agent responses
+
 ### Knowledge Base
 - `POST /api/v1/akb/append-manual` - Import AKB articles to persona
 

package/dist/api.d.ts

@@ -1,5 +1,5 @@
 import { type AxiosInstance } from 'axios';
-import type { ProjectMeta, Agent, Skill, FlowEvent, FlowState, AkbImportArticle, CustomerProfile, CustomerAttribute, CustomerAttributesResponse, UserPersonaResponse, UserPersona, ChatHistoryParams, ChatHistoryResponse, CreateAgentRequest, CreateAgentResponse, CreateFlowRequest, CreateFlowResponse, CreateSkillRequest, CreateSkillResponse, CreateFlowEventRequest, CreateFlowEventResponse, CreateFlowStateRequest, CreateFlowStateResponse, CreateSkillParameterRequest, CreateSkillParameterResponse, CreateCustomerAttributeRequest, CreateCustomerAttributeResponse, CreatePersonaRequest, CreatePersonaResponse, CreateProjectRequest, CreateProjectResponse, PublishFlowRequest, PublishFlowResponse } from './types.js';
+import type { ProjectMeta, Agent, Skill, FlowEvent, FlowState, AkbImportArticle, CustomerProfile, CustomerAttribute, CustomerAttributesResponse, UserPersonaResponse, UserPersona, ChatHistoryParams, ChatHistoryResponse, CreateAgentRequest, CreateAgentResponse, CreateFlowRequest, CreateFlowResponse, CreateSkillRequest, CreateSkillResponse, CreateFlowEventRequest, CreateFlowEventResponse, CreateFlowStateRequest, CreateFlowStateResponse, CreateSkillParameterRequest, CreateSkillParameterResponse, CreateCustomerAttributeRequest, CreateCustomerAttributeResponse, CreatePersonaRequest, CreatePersonaResponse, CreateProjectRequest, CreateProjectResponse, PublishFlowRequest, PublishFlowResponse, Integration, Connector, CreateSandboxPersonaRequest, CreateSandboxPersonaResponse, CreateActorRequest, CreateActorResponse, SendChatMessageRequest, ConversationActsParams, ConversationActsResponse } from './types.js';
 export declare function makeClient(verbose?: boolean, token?: string): Promise<AxiosInstance>;
 export declare function listProjects(client: AxiosInstance): Promise<ProjectMeta[]>;
 export declare function listAgents(client: AxiosInstance, projectId: string): Promise<Agent[]>;
@@ -36,4 +36,10 @@ export declare function createProject(client: AxiosInstance, projectData: Create
 export declare function deleteProject(client: AxiosInstance, projectId: string): Promise<void>;
 export declare function createPersona(client: AxiosInstance, personaData: CreatePersonaRequest): Promise<CreatePersonaResponse>;
 export declare function publishFlow(client: AxiosInstance, flowId: string, publishData: PublishFlowRequest): Promise<PublishFlowResponse>;
+export declare function listIntegrations(client: AxiosInstance): Promise<Integration[]>;
+export declare function listConnectors(client: AxiosInstance, integrationId: string): Promise<Connector[]>;
+export declare function createSandboxPersona(client: AxiosInstance, personaData: CreateSandboxPersonaRequest): Promise<CreateSandboxPersonaResponse>;
+export declare function createActor(client: AxiosInstance, personaId: string, actorData: CreateActorRequest): Promise<CreateActorResponse>;
+export declare function sendChatMessage(client: AxiosInstance, actorId: string, messageData: SendChatMessageRequest): Promise<void>;
+export declare function getConversationActs(client: AxiosInstance, params: ConversationActsParams): Promise<ConversationActsResponse>;
 //# sourceMappingURL=api.d.ts.map

package/dist/api.js

@@ -229,4 +229,40 @@ export async function publishFlow(client, flowId, publishData) {
     const response = await client.post(`/api/v1/designer/flows/${flowId}/publish`, publishData);
     return response.data;
 }
+// Sandbox Chat API Functions
+export async function listIntegrations(client) {
+    const response = await client.get('/api/v1/integrations');
+    return response.data;
+}
+export async function listConnectors(client, integrationId) {
+    const response = await client.get(`/api/v1/integrations/${integrationId}/connectors`);
+    return response.data;
+}
+export async function createSandboxPersona(client, personaData) {
+    const response = await client.post('/api/v1/customer/personas', personaData);
+    return response.data;
+}
+export async function createActor(client, personaId, actorData) {
+    const response = await client.post(`/api/v1/customer/personas/${personaId}/actors`, actorData);
+    return response.data;
+}
+export async function sendChatMessage(client, actorId, messageData) {
+    await client.post(`/api/v1/chat/user/${actorId}`, messageData);
+}
+export async function getConversationActs(client, params) {
+    const queryParams = {
+        user_persona_id: params.user_persona_id,
+        user_actor_id: params.user_actor_id,
+        per: params.per || 100,
+        page: params.page || 1
+    };
+    // Only add agent_persona_id if provided
+    if (params.agent_persona_id) {
+        queryParams.agent_persona_id = params.agent_persona_id;
+    }
+    const response = await client.get('/api/v1/bff/conversations/acts', {
+        params: queryParams
+    });
+    return response.data;
+}
 //# sourceMappingURL=api.js.map

package/dist/auth.js

@@ -48,6 +48,10 @@ function validateUrl(url, name) {
 }
 // Enhanced logging function
 function logAuthEvent(level, message, meta) {
+    // Skip all logging if in quiet mode
+    if (process.env.NEWO_QUIET_MODE === 'true') {
+        return;
+    }
     const timestamp = new Date().toISOString();
     const logEntry = {
         timestamp,

package/dist/cli/commands/help.js

@@ -10,6 +10,8 @@ Core Commands:
   newo push [--customer <idn>] [--no-publish]    # upload modified *.guidance/*.jinja + attributes back to NEWO, publish flows by default
   newo status [--customer <idn>]                # show modified files that would be pushed
   newo conversations [--customer <idn>] [--all] # download user conversations -> ./newo_customers/<idn>/conversations.yaml
+  newo sandbox "<message>" [--customer <idn>]   # test agent in sandbox - single message mode (NEW v3.1.0)
+  newo sandbox --actor <id> "message"           # continue existing sandbox conversation with chat ID
   newo pull-attributes [--customer <idn>]       # download customer attributes -> ./newo_customers/<idn>/attributes.yaml
   newo list-customers                           # list available customers and their configuration
   newo meta [--customer <idn>]                  # get project metadata (debug command)
@@ -45,6 +47,8 @@ Flags:
   --all                        # include all available data (for conversations: all personas and acts)
   --force, -f                  # force overwrite without prompting (for pull command)
   --verbose, -v                # enable detailed logging and progress information
+  --quiet, -q                  # minimal output for automation (sandbox only)
+  --actor <id>                 # continue existing sandbox chat with actor/chat ID
   --confirm                    # confirm destructive operations without prompting
   --no-publish                 # skip automatic flow publishing during push operations
 
@@ -107,6 +111,12 @@ Usage Examples:
   # Import AKB articles:
   newo import-akb articles.txt da4550db-2b95-4500-91ff-fb4b60fe7be9
 
+  # Sandbox testing (NEW v3.1.0):
+  newo sandbox "Hello, I want to order pizza"                    # Start new conversation
+  newo sandbox --actor abc123... "I want 2 large pizzas"         # Continue conversation
+  newo sandbox "Test query" --verbose                            # With debug info
+  newo sandbox "Test query" --quiet                              # For automation/scripts
+
 File Structure:
   newo_customers/
   ├── <customer-idn>/

package/dist/cli/commands/sandbox.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Sandbox Chat Command Handler
+ * Supports both single-command and interactive modes
+ */
+import type { MultiCustomerConfig, CliArgs } from '../../types.js';
+/**
+ * Handle sandbox command
+ * Usage:
+ *   npx newo sandbox "Hello" --customer <idn>              # Single message mode
+ *   npx newo sandbox --actor <actor_id> "Follow up"       # Continue existing chat
+ *   npx newo sandbox --interactive                        # Interactive mode (TBD)
+ */
+export declare function handleSandboxCommand(customerConfig: MultiCustomerConfig, args: CliArgs, verbose: boolean): Promise<void>;
+//# sourceMappingURL=sandbox.d.ts.map

package/dist/cli/commands/sandbox.js

@@ -0,0 +1,306 @@
+/**
+ * Sandbox Chat Command Handler
+ * Supports both single-command and interactive modes
+ */
+import { makeClient } from '../../api.js';
+import { getValidAccessToken } from '../../auth.js';
+import { selectSingleCustomer } from '../customer-selection.js';
+import { getChatHistory } from '../../api.js';
+import { findSandboxConnector, createChatSession, sendMessage, pollForResponse, extractAgentMessages, formatDebugInfo } from '../../sandbox/chat.js';
+/**
+ * Handle sandbox command
+ * Usage:
+ *   npx newo sandbox "Hello" --customer <idn>              # Single message mode
+ *   npx newo sandbox --actor <actor_id> "Follow up"       # Continue existing chat
+ *   npx newo sandbox --interactive                        # Interactive mode (TBD)
+ */
+export async function handleSandboxCommand(customerConfig, args, verbose) {
+    const quiet = Boolean(args.quiet || args.q);
+    // Save original console functions
+    const originalConsoleLog = console.log;
+    const originalConsoleError = console.error;
+    const originalConsoleWarn = console.warn;
+    // In quiet mode, set environment variable to suppress auth logging AND suppress console
+    if (quiet) {
+        process.env.NEWO_QUIET_MODE = 'true';
+        console.log = () => { };
+        console.error = () => { };
+        console.warn = () => { };
+    }
+    try {
+        // Select customer
+        const customerArg = args.customer;
+        const result = selectSingleCustomer(customerConfig, customerArg);
+        if (!result.selectedCustomer) {
+            if (!quiet) {
+                console.error = originalConsoleError;
+                console.error('❌ No customer selected');
+            }
+            process.exit(1);
+        }
+        // Get access token and create client (quiet mode already suppressing logs)
+        const token = await getValidAccessToken(result.selectedCustomer);
+        const client = await makeClient(quiet ? false : verbose, token);
+        // Restore console for our own output
+        if (quiet) {
+            console.log = originalConsoleLog;
+            console.error = originalConsoleError;
+            console.warn = originalConsoleWarn;
+        }
+        // Check for interactive mode
+        const interactive = args.interactive || args.i;
+        if (interactive) {
+            if (!quiet) {
+                console.log('❌ Interactive mode not yet implemented');
+                console.log('   Use single-command mode: npx newo sandbox "your message"');
+            }
+            process.exit(1);
+        }
+        // Check if continuing existing chat
+        const actorId = args.actor;
+        // Extract message from arguments (position depends on whether --actor is used)
+        const messageArg = args._[1];
+        if (!messageArg) {
+            if (!quiet) {
+                console.log('❌ Message is required');
+                console.log('Usage: npx newo sandbox "your message" [--actor <id>]');
+                console.log('   or: npx newo sandbox --actor <id> "your message"');
+            }
+            process.exit(1);
+        }
+        // Convert to string (minimist may parse numbers)
+        const message = String(messageArg);
+        if (message.trim() === '') {
+            if (!quiet)
+                console.log('❌ Message cannot be empty');
+            process.exit(1);
+        }
+        if (actorId) {
+            // Continue existing chat
+            await continueExistingChat(client, actorId, message, verbose, quiet, originalConsoleLog, originalConsoleError, originalConsoleWarn);
+        }
+        else {
+            // Start new chat
+            await startNewChat(client, message, verbose, quiet, originalConsoleLog, originalConsoleError, originalConsoleWarn);
+        }
+    }
+    catch (error) {
+        // Restore console for error reporting
+        if (quiet) {
+            console.error = originalConsoleError;
+            console.log = originalConsoleLog;
+            console.warn = originalConsoleWarn;
+        }
+        console.error('❌ Sandbox chat error:', error.message);
+        if (verbose && error.response?.data) {
+            console.error('   Response data:', JSON.stringify(error.response.data, null, 2));
+        }
+        process.exit(1);
+    }
+    finally {
+        // Always restore console functions and clear quiet mode flag
+        if (quiet) {
+            console.log = originalConsoleLog;
+            console.error = originalConsoleError;
+            console.warn = originalConsoleWarn;
+            delete process.env.NEWO_QUIET_MODE;
+        }
+    }
+}
+/**
+ * Start a new sandbox chat and send a message
+ */
+async function startNewChat(client, message, verbose, quiet = false, originalConsoleLog = console.log, _originalConsoleError = console.error, _originalConsoleWarn = console.warn) {
+    if (!quiet)
+        console.log('🔧 Starting new sandbox chat...\n');
+    // Find sandbox connector
+    const connector = await findSandboxConnector(client, quiet ? false : verbose);
+    if (!connector) {
+        if (!quiet) {
+            console.error('❌ No running sandbox connector found');
+            console.error('   Please ensure you have a sandbox connector configured in your NEWO project');
+        }
+        process.exit(1);
+    }
+    // Create chat session
+    const session = await createChatSession(client, connector, quiet ? false : verbose);
+    if (!quiet) {
+        console.log(`\n📋 Chat Session Created:`);
+        console.log(`   Chat ID (actor_id): ${session.user_actor_id}`);
+        console.log(`   Persona ID: ${session.user_persona_id}`);
+        console.log(`   Connector: ${session.connector_idn}`);
+        console.log(`   External ID: ${session.external_id}\n`);
+        console.log(`📤 You: ${message}\n`);
+    }
+    else {
+        // In quiet mode, output Chat ID FIRST to stdout
+        originalConsoleLog(`CHAT_ID:${session.user_actor_id}`);
+        originalConsoleLog(`You: ${message}`);
+    }
+    const sentAt = await sendMessage(client, session, message, quiet ? false : verbose);
+    // Poll for response
+    const { acts, agentPersonaId } = await pollForResponse(client, session, sentAt, quiet ? false : verbose);
+    if (acts.length === 0) {
+        if (!quiet) {
+            console.log('⏱️  No response received within timeout period');
+            console.log(`   You can continue this chat with: npx newo sandbox --actor ${session.user_actor_id} "your message"`);
+        }
+        return;
+    }
+    // Update session with agent_persona_id
+    session.agent_persona_id = agentPersonaId;
+    // Extract agent messages - show only the MOST RECENT one
+    const agentMessages = extractAgentMessages(acts);
+    if (agentMessages.length > 0) {
+        // Show only the latest agent message (messages are in reverse chronological order from API)
+        const latestAgentMessage = agentMessages[0];
+        if (latestAgentMessage) {
+            if (quiet) {
+                // Quiet mode: ONLY message content
+                originalConsoleLog(`Agent: ${latestAgentMessage.source_text || latestAgentMessage.original_text}`);
+            }
+            else {
+                // Normal mode: full output
+                console.log('🤖 Agent:');
+                console.log(`   ${latestAgentMessage.source_text || latestAgentMessage.original_text}`);
+                console.log('');
+                if (verbose && agentMessages.length > 1) {
+                    console.log(`ℹ️  Note: Received ${agentMessages.length} agent messages, showing latest only\n`);
+                }
+            }
+        }
+    }
+    // In quiet mode, skip all debug output and continuation info completely
+    if (quiet) {
+        return; // Exit early, showing only messages
+    }
+    // Display debug information (skip in quiet mode)
+    if (!quiet) {
+        if (verbose) {
+            console.log('\n📊 Debug Information:');
+            console.log(formatDebugInfo(acts));
+            console.log('');
+        }
+        else {
+            // Show condensed debug info for single-command mode
+            console.log('📊 Debug Summary:');
+            const agentActs = acts.filter(a => a.is_agent);
+            if (agentActs.length > 0) {
+                const lastAct = agentActs[agentActs.length - 1];
+                if (lastAct) {
+                    console.log(`   Flow: ${lastAct.flow_idn || 'N/A'}`);
+                    console.log(`   Skill: ${lastAct.skill_idn || 'N/A'}`);
+                    console.log(`   Session: ${lastAct.session_id}`);
+                }
+                console.log(`   Acts Processed: ${acts.length} (${agentActs.length} agent, ${acts.length - agentActs.length} system)`);
+            }
+            console.log('');
+        }
+        // Show continuation info
+        console.log(`💡 To continue this conversation:`);
+        console.log(`   npx newo sandbox --actor ${session.user_actor_id} "your next message"`);
+        console.log('');
+    }
+}
+/**
+ * Continue an existing sandbox chat
+ */
+async function continueExistingChat(client, actorId, message, verbose, quiet = false, originalConsoleLog = console.log, _originalConsoleError = console.error, _originalConsoleWarn = console.warn) {
+    if (!quiet) {
+        console.log(`💬 Continuing chat...`);
+        console.log(`   Chat ID: ${actorId}\n`);
+    }
+    // First, get current chat history to find the last message ID
+    const historyResponse = await getChatHistory(client, {
+        user_actor_id: actorId,
+        page: 1,
+        per: 100
+    });
+    // Get the last message ID
+    let lastMessageId = null;
+    if (historyResponse.items && historyResponse.items.length > 0) {
+        const lastItem = historyResponse.items[0];
+        if (lastItem && 'id' in lastItem) {
+            lastMessageId = lastItem.id;
+        }
+    }
+    if (verbose && lastMessageId && !quiet) {
+        console.log(`📌 Last message ID: ${lastMessageId}`);
+    }
+    // Create a temporary session for the existing chat
+    const session = {
+        user_actor_id: actorId,
+        user_persona_id: 'unknown', // Not needed for continuation
+        agent_persona_id: null,
+        connector_idn: 'sandbox',
+        session_id: null,
+        external_id: 'continuation'
+    };
+    // Send message (use original console in quiet mode)
+    if (quiet) {
+        originalConsoleLog(`You: ${message}`);
+    }
+    else {
+        console.log(`📤 You: ${message}\n`);
+    }
+    const sentAt = await sendMessage(client, session, message, quiet ? false : verbose);
+    // Poll for response using timestamp-based filtering
+    const { acts } = await pollForResponse(client, session, sentAt, quiet ? false : verbose);
+    if (acts.length === 0) {
+        if (!quiet) {
+            console.log('⏱️  No response received within timeout period');
+            console.log(`   You can continue this chat with: npx newo sandbox --actor ${actorId} "your message"`);
+        }
+        return;
+    }
+    // Extract agent messages - show only the MOST RECENT one
+    const agentMessages = extractAgentMessages(acts);
+    if (agentMessages.length > 0) {
+        // Show only the latest agent message (messages are in reverse chronological order from API)
+        const latestAgentMessage = agentMessages[0];
+        if (latestAgentMessage) {
+            if (quiet) {
+                // Quiet mode: ONLY message content
+                originalConsoleLog(`Agent: ${latestAgentMessage.source_text || latestAgentMessage.original_text}`);
+                return; // Exit immediately, no debug output
+            }
+            else {
+                // Normal mode: full output
+                console.log('🤖 Agent:');
+                console.log(`   ${latestAgentMessage.source_text || latestAgentMessage.original_text}`);
+                console.log('');
+                if (verbose && agentMessages.length > 1) {
+                    console.log(`ℹ️  Note: Received ${agentMessages.length} agent messages, showing latest only\n`);
+                }
+            }
+        }
+    }
+    // Display debug information (skip in quiet mode)
+    if (!quiet) {
+        if (verbose) {
+            console.log('\n📊 Debug Information:');
+            console.log(formatDebugInfo(acts));
+            console.log('');
+        }
+        else {
+            // Show condensed debug info
+            console.log('📊 Debug Summary:');
+            const agentActs = acts.filter(a => a.is_agent);
+            if (agentActs.length > 0) {
+                const lastAct = agentActs[agentActs.length - 1];
+                if (lastAct) {
+                    console.log(`   Flow: ${lastAct.flow_idn || 'N/A'}`);
+                    console.log(`   Skill: ${lastAct.skill_idn || 'N/A'}`);
+                    console.log(`   Session: ${lastAct.session_id}`);
+                }
+                console.log(`   Acts Processed: ${acts.length} (${agentActs.length} agent, ${acts.length - agentActs.length} user)`);
+            }
+            console.log('');
+        }
+        // Show continuation info
+        console.log(`💡 To continue this conversation:`);
+        console.log(`   npx newo sandbox --actor ${actorId} "your next message"`);
+        console.log('');
+    }
+}
+//# sourceMappingURL=sandbox.js.map

package/dist/cli.js

@@ -28,6 +28,7 @@ import { handleCreateStateCommand } from './cli/commands/create-state.js';
 import { handleCreateParameterCommand } from './cli/commands/create-parameter.js';
 import { handleCreatePersonaCommand } from './cli/commands/create-persona.js';
 import { handleCreateAttributeCommand } from './cli/commands/create-attribute.js';
+import { handleSandboxCommand } from './cli/commands/sandbox.js';
 dotenv.config();
 async function main() {
     try {
@@ -41,6 +42,11 @@ async function main() {
     const args = minimist(process.argv.slice(2));
     const cmd = args._[0];
     const verbose = Boolean(args.verbose || args.v);
+    const quiet = Boolean(args.quiet || args.q);
+    // Set quiet mode flag EARLY to suppress auth logging
+    if (quiet) {
+        process.env.NEWO_QUIET_MODE = 'true';
+    }
     if (verbose)
         console.log(`🔍 Command parsed: "${cmd}"`);
     // Handle help command first
@@ -77,6 +83,9 @@ async function main() {
             case 'conversations':
                 await handleConversationsCommand(customerConfig, args, verbose);
                 break;
+            case 'sandbox':
+                await handleSandboxCommand(customerConfig, args, verbose);
+                break;
             case 'meta':
                 await handleMetaCommand(customerConfig, args, verbose);
                 break;

package/dist/sandbox/chat.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Sandbox Chat Utility Module
+ * Handles chat session management, message sending, and polling for responses
+ */
+import type { AxiosInstance } from 'axios';
+import type { SandboxChatSession, Connector, ConversationAct, ChatDebugInfo } from '../types.js';
+/**
+ * Find a sandbox connector from the customer's connectors list
+ */
+export declare function findSandboxConnector(client: AxiosInstance, verbose?: boolean): Promise<Connector | null>;
+/**
+ * Create a new sandbox chat session
+ */
+export declare function createChatSession(client: AxiosInstance, connector: Connector, verbose?: boolean): Promise<SandboxChatSession>;
+/**
+ * Send a message in the chat session
+ * Returns the timestamp when message was sent (for filtering responses)
+ */
+export declare function sendMessage(client: AxiosInstance, session: SandboxChatSession, text: string, verbose?: boolean): Promise<Date>;
+/**
+ * Poll for new conversation acts (messages and debug info)
+ * Continues polling until we get an agent response, not just any new message
+ */
+export declare function pollForResponse(client: AxiosInstance, session: SandboxChatSession, messageSentAt?: Date | null, verbose?: boolean): Promise<{
+    acts: ConversationAct[];
+    agentPersonaId: string | null;
+}>;
+/**
+ * Extract agent messages from acts
+ */
+export declare function extractAgentMessages(acts: ConversationAct[]): ConversationAct[];
+/**
+ * Extract debug information from acts
+ */
+export declare function extractDebugInfo(acts: ConversationAct[]): ChatDebugInfo[];
+/**
+ * Format debug info for display
+ */
+export declare function formatDebugInfo(acts: ConversationAct[]): string;
+//# sourceMappingURL=chat.d.ts.map