// Create a customer service agent
const agent = await client.agents.create({
  name: 'Support Specialist',
  role: 'Senior Customer Success Manager',
  personality: {
    traits: ['empathetic', 'solution-oriented', 'professional'],
    tone: 'friendly yet professional'
  },
  capabilities: [
    'order_management',
    'refund_processing',
    'subscription_management',
    'technical_support'
  ],
  knowledge_bases: ['product_docs', 'support_playbook'],
  escalation_rules: {
    conditions: ['customer_frustrated', 'refund_over_500', 'technical_bug'],
    action: 'transfer_to_human'
  }
});

// Deploy the agent
await agent.deploy({
  channels: ['chat', 'email', 'voice'],
  availability: '24/7',
  languages: ['en', 'es', 'fr']
});

// Define an order fulfillment workflow
const workflow = await client.workflows.create({
  name: 'Order Fulfillment',
  trigger: {
    event: 'order.created',
    conditions: {
      status: 'paid',
      total: { $gte: 0 }
    }
  },
  steps: [
    {
      name: 'verify_inventory',
      action: 'inventory.check',
      onError: 'notify_customer'
    },
    {
      name: 'reserve_items',
      action: 'inventory.reserve',
      rollback: 'inventory.release'
    },
    {
      name: 'create_shipment',
      action: 'shipping.create_label',
      parallel: ['send_confirmation_email', 'update_inventory']
    },
    {
      name: 'notify_warehouse',
      action: 'warehouse.create_pick_order',
      timeout: '1h'
    }
  ],
  compensation: {
    strategy: 'saga',
    onFailure: 'rollback_all'
  }
});

// Subscribe to events
client.events.subscribe({
  events: ['order.*', 'return.created', 'customer.churning'],
  handler: async (event) => {
    switch (event.type) {
      case 'order.created':
        await handleNewOrder(event.data);
        break;
      case 'customer.churning':
        await initiateRetentionCampaign(event.data);
        break;
    }
  }
});

// Emit custom events
await client.events.emit({
  type: 'inventory.low_stock',
  data: {
    sku: 'PROD-123',
    quantity: 5,
    reorder_point: 10
  },
  metadata: {
    warehouse: 'us-west-1',
    priority: 'high'
  }
});

// Create a knowledge base
const kb = await client.knowledgeBases.create({
  name: 'Product Documentation',
  type: 'structured',
  embedding_model: 'text-embedding-3-large'
});

// Add documents
await kb.addDocuments([
  {
    content: 'Product manual content...',
    metadata: {
      type: 'manual',
      product: 'widget-pro',
      version: '2.0'
    }
  }
]);

// Query the knowledge base
const results = await kb.search({
  query: 'How to install widget pro?',
  limit: 5,
  filters: {
    product: 'widget-pro'
  }
});

# Create a new project
mkdir my-stateset-app && cd my-stateset-app
npm init -y

# Install dependencies
npm install stateset-node express dotenv

# Create environment file
echo "STATESET_API_KEY=your_api_key_here" > .env

// src/agent.ts
import { StateSetClient } from 'stateset-node';

export async function createCustomerServiceAgent(client: StateSetClient) {
  const agent = await client.agents.create({
    name: 'Alex',
    role: 'Customer Service Expert',
    instructions: `You are Alex, a senior customer service expert. 
    Your goals are to:
    1. Resolve customer issues quickly and empathetically
    2. Identify upsell opportunities when appropriate
    3. Collect feedback to improve our products
    
    Always be professional, friendly, and solution-oriented.`,
    tools: [
      {
        name: 'order_lookup',
        description: 'Look up order details by order ID',
        parameters: {
          order_id: { type: 'string', required: true }
        }
      },
      {
        name: 'process_refund',
        description: 'Process a refund for an order',
        parameters: {
          order_id: { type: 'string', required: true },
          amount: { type: 'number', required: true },
          reason: { type: 'string', required: true }
        }
      }
    ]
  });
  
  return agent;
}

// src/server.ts
import express from 'express';
import { StateSetClient } from 'stateset-node';
import { createCustomerServiceAgent } from './agent';

const app = express();
app.use(express.json());

const client = new StateSetClient({
  apiKey: process.env.STATESET_API_KEY!
});

let agent: any;

// Initialize agent on startup
async function initialize() {
  agent = await createCustomerServiceAgent(client);
  console.log('Customer service agent initialized');
}

// Chat endpoint
app.post('/api/chat', async (req, res) => {
  try {
    const { message, session_id } = req.body;
    
    const response = await agent.chat({
      message,
      session_id,
      context: {
        customer_id: req.user?.id,
        channel: 'web'
      }
    });
    
    res.json(response);
  } catch (error) {
    console.error('Chat error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

// Webhook endpoint for events
app.post('/api/webhooks/stateset', async (req, res) => {
  const signature = req.headers['x-stateset-signature'];
  
  // Verify webhook signature
  if (!client.webhooks.verify(req.body, signature)) {
    return res.status(401).send('Invalid signature');
  }
  
  const event = req.body;
  
  // Handle different event types
  switch (event.type) {
    case 'conversation.escalated':
      await notifyHumanAgent(event.data);
      break;
    case 'conversation.resolved':
      await collectFeedback(event.data);
      break;
  }
  
  res.status(200).send('OK');
});

app.listen(3000, () => {
  initialize();
  console.log('Server running on http://localhost:3000');
});

# docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - STATESET_API_KEY=${STATESET_API_KEY}
      - NODE_ENV=production
    restart: unless-stopped
    
  redis:
    image: redis:alpine
    volumes:
      - redis_data:/data

volumes:
  redis_data:

// src/__tests__/agent.test.ts
import { StateSetClient } from 'stateset-node/testing';

describe('Customer Service Agent', () => {
  let client: StateSetClient;
  let agent: any;
  
  beforeEach(() => {
    // Use test client with mocked responses
    client = new StateSetClient({
      apiKey: 'test_key',
      environment: 'test'
    });
  });
  
  test('should handle order inquiries', async () => {
    const response = await agent.chat({
      message: 'Where is my order #12345?',
      session_id: 'test_session'
    });
    
    expect(response.message).toContain('order #12345');
    expect(response.tools_called).toContain('order_lookup');
  });
});

// Enable detailed logging
const client = new StateSetClient({
  apiKey: process.env.STATESET_API_KEY,
  logger: {
    level: 'debug',
    transport: 'datadog', // or 'console', 'file'
    metadata: {
      service: 'customer-service',
      version: '1.0.0'
    }
  }
});

// Track custom metrics
client.metrics.track({
  name: 'conversation.duration',
  value: 125, // seconds
  tags: {
    agent: 'alex',
    channel: 'chat',
    resolved: true
  }
});

// Agents
client.agents.create(params)
client.agents.list(filters)
client.agents.get(id)
client.agents.update(id, params)
client.agents.delete(id)

// Workflows
client.workflows.create(params)
client.workflows.execute(id, input)
client.workflows.cancel(execution_id)

// Knowledge Bases
client.knowledgeBases.create(params)
client.knowledgeBases.search(kb_id, query)
client.knowledgeBases.addDocuments(kb_id, documents)

// Events
client.events.emit(event)
client.events.subscribe(params)
client.events.list(filters)

// Orders
client.orders.create(params)
client.orders.list(filters)
client.orders.update(id, params)

// Customers
client.customers.create(params)
client.customers.get(id)
client.customers.search(query)