Support desk

import { getToolJsonSchema } from "glove-core";
import { createAdapter } from "glove-core/models/providers";
import { MemorySchema } from "glove-memory/core";
import { createSqliteMemoryAdapters } from "glove-memory/sqlite";
import {
  defineAgent,
  defineFacts,
  defineForms,
  defineSubagent,
  foundryGuidanceSubject,
  type AgentAssemblyContext,
} from "glove-foundry";
import { z } from "zod";
import { FileStore } from "../../lib/file-store.js";
import { components } from "./composition.js"; // composeAgent(helpdesk, …)
import { refundForms } from "./refund-form.js"; // a FormRegistry with the refund form
import { orders } from "../../lib/orders.js"; // your code: your order system

const guidance = (ctx: AgentAssemblyContext) =>
  createSqliteMemoryAdapters({
    file: "/data/guidance.sqlite",
    namespace: foundryGuidanceSubject(ctx, "conversation"),
    schema: new MemorySchema(),
  });

export default defineAgent({
  description: "Answers one customer's tickets",
  components,
  model: () => createAdapter({ provider: "anthropic", model: "claude-sonnet-5-5" }),
  store: ({ conversationId }) => FileStore.open(conversationId),
  systemPrompt: (_agent, ctx) =>
    `You support ${String(ctx.agentInstance.context.customer)}. Reply on the ticket. Never promise a refund before it is issued.`,
  contextProviders: (_agent, ctx) => [
    // Re-read before every model call, so a plan change mid-ticket is seen at once.
    async () => `Account: ${JSON.stringify(await orders.account(String(ctx.agentInstance.context.customer)))}`,
  ],
  tools: [
    {
      name: "lookup_order",
      description: "Get an order's status, items and shipping events.",
      inputSchema: z.object({ orderId: z.string() }),
      async do({ orderId }) {
        return { status: "success" as const, data: await orders.get(orderId) };
      },
    },
    {
      name: "issue_refund",
      description: "Refund an order, fully or in part.",
      inputSchema: z.object({ orderId: z.string(), amount: z.number().positive() }),
      requiresPermission: true, // becomes an expiring approval record
      async do(input) {
        return { status: "success" as const, data: await orders.refund(input) };
      },
    },
  ],
  facts: (_agent, ctx) => defineFacts({ adapter: guidance(ctx).facts }),
  forms: (_agent, ctx) => defineForms({ adapter: guidance(ctx).forms, registry: refundForms }),
  subagents: [
    defineSubagent({
      name: "order-researcher",
      description: "Read-only: gather what happened to one order.",
      systemPrompt: "Gather facts about one order. Never change anything. Return a short summary.",
      tools: ({ parent }) => parent.tools.filter((tool) => tool.name === "lookup_order").map((tool) => ({
        name: tool.name,
        description: tool.description,
        jsonSchema: getToolJsonSchema(tool),
        do: (input, _display, _glove, signal) => tool.run(input, undefined, signal),
      })),
    }),
  ],
});

import { choice, jev } from "glove-classifier";
import { classifyInbound } from "glove-classifier/foundry";

// inside defineTransmission({ inbound: { … } })
classify: classifyInbound({
  classifier: jev(), // TypeSafe's Jev; any ClassifierAdapter works
  question: choice("What is this ticket about?", ["refund", "bug", "other"]),
  events: { refund: refundRequested, bug: bugReported },
  fallback: generalInquiry, // below minConfidence, or "other"
  minConfidence: 0.6,
  state: (event: { subject: string; body: string }) => `${event.subject}\n${event.body}`,
}),

import { definePlaybookSubscription, install } from "glove-foundry";
import support from "../agent.js";
import helpdesk from "../apps/helpdesk.app.js";
import handle from "../actions/handle.action.js";
import refundRequested from "../events/refund-requested.event.js";
import tickets from "../transmissions/tickets.transmission.js";
import { acmeHelpdesk, ticketsInbound, ticketsOutbound } from "../topology.js";

export default definePlaybookSubscription({
  workspaceId: "acme",
  playbook: {
    transmission: tickets,
    match: { event: refundRequested, routes: [ticketsInbound] },
    directives: [{ action: handle, instruction: "Resolve the refund request on this ticket." }],
    applications: [helpdesk],
    outbound: [{ route: ticketsOutbound, application: helpdesk }],
  },
  targets: [{
    agent: support,
    // "per-requester" is your provisioner in foundry.application.ts:
    // it returns a provisioningKey per customer, so each customer gets one instance.
    provisioning: { mode: "custom", adapter: "per-requester" },
    installations: [install(helpdesk, { queue: "support" }, { account: acmeHelpdesk })],
  }],
});

import { createFoundryClient } from "glove-foundry/client";

const foundry = createFoundryClient({
  baseUrl: process.env.FOUNDRY_URL,
  // The same bearer token your requestAuthorization adapter accepts.
  authorization: {
    identifier: "support-console",
    headers: () => ({ authorization: `Bearer ${process.env.FOUNDRY_TOKEN}` }),
  },
});
for (const approval of await foundry.approvals({ status: "pending" })) {
  // show approval.toolName and approval.toolInput to a person, then:
  await foundry.resolveApproval(approval.id, "approve"); // or "deny"
}