Customer support agent

import { LuaTool, Data } from 'lua-cli';
import { z } from 'zod';

export default class SearchKnowledgeBaseTool implements LuaTool {
  name = 'search_knowledge_base';
  description =
    'Search the help articles for an answer. Use it before offering to create a ticket.';

  inputSchema = z.object({
    query: z.string().describe("The customer's question in their own words"),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    const results = await Data.search('help_articles', input.query, 5, 0.7);
    return {
      articles: results.map((entry) => ({
        title: entry.data.title,
        excerpt: String(entry.data.content).slice(0, 300),
        url: entry.data.url,
        score: entry.score,
      })),
    };
  }
}

import { LuaTool, Data, User, env } from 'lua-cli';
import { z } from 'zod';

export default class CreateTicketTool implements LuaTool {
  name = 'create_ticket';
  description =
    'Create a Zendesk ticket for the customer when the help articles do not answer their question.';

  inputSchema = z.object({
    subject: z.string().describe('One-line summary of the problem'),
    description: z.string().describe('What the customer reported, in full'),
    priority: z.enum(['low', 'normal', 'high', 'urgent']).default('normal'),
    email: z
      .string()
      .email()
      .optional()
      .describe('Only when the customer is not signed in with an email address'),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    const subdomain = env('ZENDESK_SUBDOMAIN');
    const agentEmail = env('ZENDESK_EMAIL');
    const token = env('ZENDESK_API_TOKEN');
    if (!subdomain || !agentEmail || !token) {
      throw new Error('Zendesk is not configured');
    }

    // Prefer the email the channel verified over one the model collected.
    const user = await User.get();
    const requesterEmail = user?._luaProfile.emailAddresses[0] ?? input.email;
    if (!requesterEmail) {
      return { created: false, reason: 'Ask the customer for an email address first' };
    }

    const res = await fetch(`https://${subdomain}.zendesk.com/api/v2/tickets.json`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Basic ${btoa(`${agentEmail}/token:${token}`)}`,
      },
      body: JSON.stringify({
        ticket: {
          subject: input.subject,
          comment: { body: input.description },
          priority: input.priority,
          requester: { name: user?._luaProfile.fullName ?? requesterEmail, email: requesterEmail },
          tags: ['agent_created'],
        },
      }),
    });
    if (!res.ok) {
      throw new Error(`Zendesk responded ${res.status}`);
    }
    const { ticket } = await res.json();

    // Keep a copy so the follow-up job can find open tickets without calling Zendesk.
    await Data.create(
      'support_tickets',
      {
        zendeskId: ticket.id,
        subject: input.subject,
        customerEmail: requesterEmail,
        status: 'open',
        createdAt: new Date().toISOString(),
      },
      `${input.subject} ${input.description}`,
    );

    return { created: true, ticketId: ticket.id, url: ticket.url };
  }
}

import { LuaSkill } from 'lua-cli';
import SearchKnowledgeBaseTool from './tools/SearchKnowledgeBaseTool';
import CreateTicketTool from './tools/CreateTicketTool';

export default new LuaSkill({
  name: 'support',
  description: 'Answer questions from the help articles and open Zendesk tickets',
  context: `Always call search_knowledge_base first and answer from the articles it returns,
citing the article url. If nothing relevant comes back, or the customer says the answer
did not help, offer to open a ticket and call create_ticket with a clear subject.
Never promise a response time shorter than one business day.`,
  tools: [new SearchKnowledgeBaseTool(), new CreateTicketTool()],
});

import { LuaWebhook, User, env } from 'lua-cli';
import { z } from 'zod';

// The JSON body you configure in the Zendesk webhook's payload template.
const bodySchema = z.object({
  type: z.string(),
  ticket: z.object({
    id: z.number(),
    status: z.string(),
    requester_email: z.string().email(),
  }),
});

export default new LuaWebhook({
  name: 'zendesk-ticket-events',
  description: 'Tells the customer on their channel when Zendesk marks their ticket solved',
  bodySchema,

  execute: async ({ body, headers }) => {
    // Zendesk signs with its own header, so check the bearer token you set on
    // the Zendesk webhook instead of a Lua secret.
    if (headers?.authorization !== `Bearer ${env('ZENDESK_WEBHOOK_TOKEN')}`) {
      throw new Error('Unauthorized');
    }
    const event = bodySchema.parse(body);
    if (event.type !== 'ticket.solved') {
      return { received: true, notified: false };
    }

    const user = await User.get({ email: event.ticket.requester_email });
    if (!user) {
      return { received: true, notified: false };
    }

    await user.send([
      {
        type: 'text',
        text: `Your ticket #${event.ticket.id} is solved. Reply here if you need anything else.`,
      },
    ]);
    return { received: true, notified: true };
  },
});

import { LuaJob, Data, User } from 'lua-cli';

export default new LuaJob({
  name: 'ticket-follow-up',
  description: 'Every morning, tell customers with an open ticket that it is still being worked on',
  schedule: { type: 'cron', expression: '0 10 * * *', timezone: 'Europe/London' },
  timeout: 120,
  retry: { maxAttempts: 2, backoffSeconds: 300 },

  execute: async () => {
    const open = await Data.get('support_tickets', { status: 'open' }, 1, 50);
    let notified = 0;

    for (const ticket of open.data) {
      const user = await User.get({ email: ticket.data.customerEmail });
      if (!user) continue;
      await user.send([
        {
          type: 'text',
          text: `Ticket #${ticket.data.zendeskId} is still open. We will message you here as soon as there is news.`,
        },
      ]);
      notified += 1;
    }

    return { open: open.data.length, notified };
  },
});

import { LuaAgent } from 'lua-cli';
import supportSkill from './skills/support.skill';
import zendeskWebhook from './webhooks/ZendeskWebhook';
import ticketFollowUp from './jobs/TicketFollowUpJob';

const agent = new LuaAgent({
  name: 'acme-support',
  persona: `You are Alex, the support assistant for Acme.
Answer from the help articles first. Open a ticket only when the articles do not help,
and tell the customer the ticket number. Be brief and warm; never invent policy.
Escalate billing disputes over $500 and account security issues to a ticket marked urgent.`,
  skills: [supportSkill],
  webhooks: [zendeskWebhook],
  jobs: [ticketFollowUp],
});

✅ Compiled 6 primitives (1 agent, 1 skill, 2 tools, 1 webhook, 1 job) in 520ms
✅ Selected tool: search_knowledge_base
Input: {
  "query": "how do I reset my password"
}
🚀 Executing tool...
✅ Tool execution successful!

Tool returned: Object — fields: articles
Output:
{ articles: [] }