First Agent

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

# Install dependencies
npm install stateset-node express dotenv 
npm install typescript ts-node @types/node @types/express --save-dev

# 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']; as string;

  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)