Build an intake agent

Last updated on

import {
  executeFill,
  executeGetArtifact,
  executeGetFillState,
  executeInspectArtifact,
  executeRender,
  executeUpdateFill,
  type ParadocToolsConfig,
} from "@paradoc/ai-tools"

const config: ParadocToolsConfig = { defaultRegistryUrl: "https://public.paradoc.dev" }
const source = { source: "registry", artifact_name: "pet-addendum" } as const

type Draft = { data: Record<string, unknown>; evaluation_context?: Record<string, unknown> }

// One draft per conversation. Use your database in production.
const drafts = new Map<string, Draft>()

// The model can call several tools at once. Run the calls of one
// conversation in order, so two saves never overwrite each other.
const queues = new Map<string, Promise<unknown>>()
function inOrder<T>(conversationId: string, task: () => Promise<T>): Promise<T> {
  const run = (queues.get(conversationId) ?? Promise.resolve()).then(task, task)
  queues.set(conversationId, run.catch(() => undefined))
  return run
}

/** The system prompt: the form's fields and parties, and its agent instructions. */
export async function instructions() {
  const form = await executeInspectArtifact({ ...source, sections: ["fields", "parties"] }, config)
  const artifact = await executeGetArtifact({ artifact_name: source.artifact_name }, config)
  return [
    "You help the user fill in a form. Ask for one value at a time.",
    "Save each answer with update_draft. Put only the new values in patch, such as",
    '{ "patch": { "fields": { "<field>": <value> } }, "clear": [] } or',
    '{ "patch": { "parties": { "<role>": { "name": "<name>" } } }, "clear": [] }.',
    "update_draft says what is still missing. When nothing is missing, confirm with the user, then call finish.",
    `The form: ${JSON.stringify(form.sections)}`,
    `Instructions from the form's author: ${artifact.agent_instructions?.content ?? "none"}`,
  ].join("\n\n")
}

export async function startDraft(conversationId: string) {
  const draft = await executeFill({ ...source, data: {} }, config)
  if (!draft.accepted || !draft.data) throw new Error(draft.error?.message)
  drafts.set(conversationId, { data: draft.data, evaluation_context: draft.evaluation_context })
}

/** The update_draft tool: merge the model's patch into the stored draft. */
export function updateDraft(conversationId: string, patch: Record<string, unknown>, clear: string[] = []) {
  return inOrder(conversationId, () => saveDraft(conversationId, patch, clear))
}

async function saveDraft(conversationId: string, patch: Record<string, unknown>, clear: string[]) {
  const draft = drafts.get(conversationId)
  if (!draft) throw new Error(`No draft for ${conversationId}`)

  const updated = await executeUpdateFill({ ...source, ...draft, patch, clear }, config)
  if (!updated.accepted || !updated.data) {
    // Nothing is saved. The model reads the errors and asks again.
    return { saved: false, errors: updated.errors ?? [updated.error] }
  }
  const next = { data: updated.data, evaluation_context: updated.evaluation_context }
  drafts.set(conversationId, next)

  const state = await executeGetFillState({ ...source, ...next }, config)
  return {
    saved: true,
    complete: updated.complete,
    ask_next: state.next?.key ?? null,
    missing: state.open_required.map((target) => target.key),
    rule_errors: state.rules.errors,
  }
}

/** The finish tool: render the stored draft as a PDF, once it is complete. */
export function finish(conversationId: string) {
  return inOrder(conversationId, async () => {
    const draft = drafts.get(conversationId)
    if (!draft) throw new Error(`No draft for ${conversationId}`)

    const state = await executeGetFillState({ ...source, ...draft }, config)
    const missing = state.open_required.map((target) => target.key)
    if (missing.length > 0 || !state.rules.valid) {
      return { done: false, error: { missing, rule_errors: state.rules.errors } } as const
    }

    const pdf = await executeRender({ ...source, ...draft, layer: "pdf" }, config)
    if (!pdf.success || !pdf.content) return { done: false, error: pdf.error } as const
    return { done: true, pdf: Buffer.from(pdf.content, "base64") } as const
  })
}

import { createInterface } from "node:readline/promises"
import { createIntake } from "./intake"

const reply = await createIntake("demo")
const terminal = createInterface({ input: process.stdin, output: process.stdout })

// Press Ctrl+C to stop. The agent writes demo.pdf when the form is done.
while (true) {
  const text = await terminal.question("You: ")
  console.log(`Agent: ${await reply(text)}\n`)
}

npx tsx main.ts

You: Hi, I need to add my dog to my lease.
Agent: Great! Let's start by gathering some details about your dog. What is your pet's name?

You: His name is Rex.
Agent: Thanks! What species is Rex? Please choose from dog, cat, or fish.

You: He's a parrot! Just kidding, he's a dog.
Agent: Got it! Now, can you tell me Rex's weight in pounds?

...

You: The landlord's name is Acme Properties LLC.
Agent: Here's a summary of the information you provided:
- Pet Name: Rex
- Species: Dog
- Weight: 31 lbs
- Vaccinated: Yes
- Tenant Name: Jane Doe
- Landlord Name: Acme Properties LLC
Does everything look correct?

You: Yes.
Agent: The document is ready for signing!