Mastra

Mastra can hold a tool call until someone approves it. Set requireApproval: true on the tool and the agent run suspends before the tool executes. @pushary/mastra adds human in the loop to Mastra: it finds that suspended run, asks your user on their phone, and approves or declines the call so the run finishes.

npm i @pushary/mastra @mastra/core zod
export PUSHARY_API_KEY=pk_xxx.xxx

Get the key at Partner onboarding. It needs Node.js 22.13 or later, like Mastra itself, and @mastra/core 1.59 or later below 2.

Set up Mastra human in the loopCopy Anchor Link

import { connect } from '@pushary/mastra'

const config = { apiKey: process.env.PUSHARY_API_KEY! }
const { universalLink } = await connect(config, user.id)

import { Agent } from '@mastra/core/agent'
import { createTool } from '@mastra/core/tools'
import { z } from 'zod'
import { resolvePusharyApprovals } from '@pushary/mastra'

const issueRefund = createTool({
  id: 'issue-refund',
  description: 'Refund an order',
  inputSchema: z.object({ orderId: z.string(), amount: z.number().positive() }),
  outputSchema: z.object({ refunded: z.boolean() }),
  requireApproval: true,
  execute: async ({ orderId, amount }) => refundOrder(orderId, amount),
})

const agent = new Agent({
  id: 'refunds',
  name: 'Refunds',
  instructions: 'Refund orders when the customer asks.',
  model: 'openai/gpt-4o',
  tools: { issueRefund },
})

const output = await agent.generate('Refund order 1234 in full.', {
  memory: { thread: conversation.id, resource: user.id },
})

if (output.finishReason === 'suspended') {
  const outcome = await resolvePusharyApprovals(
    { externalId: user.id, policy: false },
    { agent, resourceId: user.id },
  )
}

What happens when nobody answersCopy Anchor Link

The refund does not run. Each question waits up to 55 seconds. A deny or no answer in that time declines the call, and Mastra gives the model the reason:

To wait longer than one request, use deferred reviews.

Let the model ask a questionCopy Anchor Link

import { Agent } from '@mastra/core/agent'
import { createPusharyAskTool } from '@pushary/mastra'

const agent = new Agent({
  id: 'support',
  name: 'Support',
  instructions: 'Ask the customer which order they need help with.',
  model: 'openai/gpt-4o',
  tools: { askHuman: createPusharyAskTool(config, { externalId: user.id }) },
})

await agent.generate('Find out which order the customer means.')

The tool returns { approved, value, status } to the model. The model chooses when to call it, so use it for questions and keep requireApproval for actions that need a yes. A choice or a typed answer is data, not permission, even when the text is yes.

Production notesCopy Anchor Link

Make sure a person always decidesCopy Anchor Link

policy: false means a person always decides. Without it, the shared gate asks your site's policy first, and a policy rule that names the tool can allow or deny it without paging anyone.

Read every resultCopy Anchor Link

resolvePusharyApprovals returns { resolved, pending, allApproved }:

Scope it to one customerCopy Anchor Link

Pass trusted runs, a threadId or a resourceId. A call with none of them is rejected, so the resolver never sweeps every suspended run in your app.

Pick the right personCopy Anchor Link

Take the user id from your signed-in user, never from the model's tool input. A prompt injection could otherwise send the approval to someone else.

Wait minutes or hours for an answerCopy Anchor Link

resolvePusharyApprovals waits inside one request. For later answers, use deferred reviews:

1. createPusharyDeferredAskTool for questions, and requireApproval: true for actions.
2. openPusharyAgentReview after Mastra suspends. It saves the exact call and customer binding, then asks.
3. resumePusharyAgentReview from a signed callback or a polling job. It reads the authoritative decision before it resumes the saved run.

Your application supplies persistent Mastra storage, an atomic review store, output storage and business idempotency. The public package guide covers the store contract. The restart and live-phone recipe needs no model key, moves no money and polls without a public callback server. Its approval, denial, choice and text checks run in separate processes and check duplicate handling.

Pushary records the answer. Your application records the continuation and the business result. If execution becomes uncertain, reconcile the saved run and the business receipt before you retry. A timeout alone never makes a retry safe.

VersionsCopy Anchor Link

@pushary/mastra 0.4 requires @pushary/server 2.1, @mastra/core 1.59 or later below 2, and Node.js 22.13 or later.

Source and more examples: pushary-mastra on GitHub. Mastra reference: agent approval.

Next stepsCopy Anchor Link