Compose agents

baseAgent_agent_1770243756469_3or9n7xvf	Placeholder Agent
…

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

export default class DraftReplyTool implements LuaTool {
  name = 'draft_reply';
  description = 'Ask the sales agent to draft a reply about pricing or contracts';
  inputSchema = z.object({
    question: z.string(),
    accountId: z.string().describe('Account the question is about'),
  });

  async execute(input: z.infer<typeof this.inputSchema>) {
    const salesAgentId = env('SALES_AGENT_ID');
    if (!salesAgentId) throw new Error('SALES_AGENT_ID is not set');

    try {
      const result = await Agents.invoke(salesAgentId, {
        prompt: `Draft a short reply to this customer question: ${input.question}`,
        threadId: `account-${input.accountId}`,
        timeoutMs: 60_000,
      });
      return { draft: result.text, toolsUsed: result.toolsUsed ?? [] };
    } catch (error) {
      // The sales agent's preprocessor or governance refused the turn.
      const code = (error as { code?: string }).code;
      if (code === 'PREPROCESSOR_BLOCKED' || code === 'GOVERNANCE_BLOCKED') {
        return { draft: null, blockedBy: code, reason: (error as Error).message };
      }
      throw error;
    }
  }
}

import { LuaJob, Agents, env } from 'lua-cli';

export default new LuaJob({
  name: 'weekly-review',
  description: 'Every Monday, have the sales agent review the pipeline for the account owner',
  schedule: { type: 'cron', expression: '0 7 * * 1', timezone: 'Europe/London' },
  timeout: 300,
  metadata: { ownerUserId: 'user_abc123' },
  async execute(job) {
    const salesAgentId = env('SALES_AGENT_ID');
    if (!salesAgentId) throw new Error('SALES_AGENT_ID is not set');

    // A job has no current user, so name the user the turn should run as.
    const result = await Agents.invoke(salesAgentId, {
      prompt: 'Review open deals and message me a summary of anything at risk.',
      userId: job.metadata.ownerUserId,
      threadId: 'weekly-review',
      timeoutMs: 240_000,
    });
    return { finishReason: result.finishReason, toolsUsed: result.toolsUsed };
  },
});

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

const Classification = z.object({
  category: z.enum(['billing', 'bug', 'feature_request', 'other']),
  urgency: z.enum(['low', 'medium', 'high']),
  summary: z.string(),
});

export default class ClassifyTicketTool implements LuaTool {
  name = 'classify_ticket';
  description = 'Classify a support message by category and urgency';
  inputSchema = z.object({ text: z.string() });

  async execute(input: z.infer<typeof this.inputSchema>) {
    const result = await AI.generate({
      model: 'openai/gpt-5.4-mini',
      system: 'You classify customer support messages. Answer with JSON only.',
      prompt: input.text,
      temperature: 0,
      structuredOutput: {
        schema: {
          type: 'object',
          properties: {
            category: { type: 'string', enum: ['billing', 'bug', 'feature_request', 'other'] },
            urgency: { type: 'string', enum: ['low', 'medium', 'high'] },
            summary: { type: 'string' },
          },
          required: ['category', 'urgency', 'summary'],
          additionalProperties: false,
        },
      },
    });
    const parsed = Classification.safeParse(result.output);
    if (!parsed.success) return { error: 'Model returned an unexpected shape', raw: result.text };
    return parsed.data;
  }
}

✅ Selected tool: classify_ticket
Input: {
  "text": "I was charged twice this month and need it fixed today."
}
🚀 Executing tool...
✅ Tool execution successful!

Tool returned: Object — fields: category, urgency, summary
Output:
{
  category: 'billing',
  urgency: 'high',
  summary: 'Customer reports being charged twice this month and requests an immediate fix today.'
}