Tool and approval patterns

import { Agent, defineTool, type ModelProvider } from "@agentium/core";
import { z } from "zod";

type Order = { id: string; status: string; deliveryDate: string };

export function createOrderAssistant(
  model: ModelProvider,
  lookupOrder: (orderId: string) => Promise<Order | null>,
) {
  const lookup = defineTool({
    name: "lookup_order",
    description: "Look up a permitted order by its ID.",
    parameters: z.object({ orderId: z.string().min(1) }),
    execute: async ({ orderId }) => {
      const order = await lookupOrder(orderId);
      return JSON.stringify(order ?? { error: "Order unavailable" });
    },
  });
  return new Agent({
    name: "order-support", model, register: false,
    instructions: "Use lookup_order for order details. Do not invent a status.",
    tools: [lookup],
  });
}

import { Agent, type ModelProvider } from "@agentium/core";
import { FileSystemToolkit } from "@agentium/core/toolkits";

export function createFileAssistant(model: ModelProvider, directory: string) {
  const files = new FileSystemToolkit({ basePath: directory, allowWrite: false });
  return new Agent({
    name: "file-reader", model, register: false,
    instructions: "Read the selected files and cite their paths.",
    tools: files.getTools(),
  });
}

import { Agent, type ModelProvider, type ToolDef } from "@agentium/core";

export function createReviewedAssistant(
  model: ModelProvider,
  action: ToolDef,
  decide: (toolName: string) => Promise<boolean>,
) {
  return new Agent({
    name: "reviewed-action", model, register: false,
    tools: [action],
    approval: {
      policy: "all",
      onApproval: async (request) => ({
        approved: await decide(request.toolName),
        reason: "Decision supplied by the application",
      }),
    },
  });
}