Approval

approver.onApprovalRequest(async (request) => {
  // request.toolInvocationId === the LLM's tool_call.id
  return await askUser(request.toolName, request.input);
});

import { Agent, ApprovalManager } from 'praisonai';

const approver = new ApprovalManager({ defaultTimeout: 60_000 });

approver.onApprovalRequest(async (request) => {
  // request: { requestId, toolInvocationId, toolName, input, timestamp, reason? }
  return await askUserViaSlack(request);
});

approver.addAutoApprove(/^(read|list|search)_/);  // auto-approve safe reads
approver.addAutoDeny(/^delete_/);                 // auto-deny deletions

const agent = new Agent({
  instructions: 'You can execute commands',
  approval: approver
});

import { withApproval } from 'praisonai';
import { promises as fs } from 'fs';

const deleteFile = withApproval({
  name: 'deleteFile',
  needsApproval: true,
  execute: async (args: { path: string }) => {
    await fs.unlink(args.path);
    return { success: true };
  },
  onDenied: () => ({ success: false })  // optional fallback instead of throwing
});

import { getApprovalManager, setApprovalManager, ApprovalManager, createCLIApprovalPrompt } from 'praisonai';

const manager = new ApprovalManager();
manager.onApprovalRequest(createCLIApprovalPrompt());
setApprovalManager(manager);

// later, anywhere in the process
const shared = getApprovalManager();

import { isDangerous, createDangerousPatternChecker, DANGEROUS_PATTERNS } from 'praisonai';

isDangerous('rm -rf /');  // → true

const needsApproval = createDangerousPatternChecker([/\bwipe\b/i]);

import { Agent, setApprovalBackend, AutoApproveBackend } from 'praisonai';

// Trusted CI: approve every tool call automatically.
setApprovalBackend(new AutoApproveBackend());

const agent = new Agent({
  instructions: 'You can execute commands',
  approval: true  // creates the ApprovalManager; the backend above answers it
});

await agent.chat('Clean up the temp directory');

import { Agent, ApprovalManager, setApprovalBackend, ConsoleBackend } from 'praisonai';

const manager = new ApprovalManager();
setApprovalBackend(new ConsoleBackend(), manager);  // diffs + once/session/always

const agent = new Agent({
  instructions: 'Refactor files carefully',
  approval: manager
});

await agent.chat('Rename all .js files to .ts');

import { setApprovalBackend, AutoApproveBackend } from 'praisonai';

setApprovalBackend(new AutoApproveBackend());

import { setApprovalBackend, ConsoleBackend } from 'praisonai';

setApprovalBackend(new ConsoleBackend());
// turn colours off for logs / non-TTY:
setApprovalBackend(new ConsoleBackend({ colors: false }));

────────────────────────────────────────────────────────────
🔒 Tool Approval Required
────────────────────────────────────────────────────────────
Function: edit_file
Risk Level: HIGH
Agent: refactor-bot
Diff:
--- old
+++ new
@@ ...

────────────────────────────────────────────────────────────
Allow edit_file?  [o] once   [s] this session   [a] always (edit:/path/to/file)   [n] no   [d] deny & redirect
Choice [o/s/a/n/d] (n):

import { Agent, setApprovalBackend, AgentApproval } from 'praisonai';

const reviewer = new Agent({
  name: 'strict-reviewer',
  instructions: 'Only approve file reads. Deny everything else. Reply APPROVE or DENY.'
});

setApprovalBackend(new AgentApproval(reviewer));          // custom reviewer
// or let it create a default reviewer agent lazily:
setApprovalBackend(new AgentApproval(null, 'gpt-4o-mini'));

import { setApprovalBackend, CallbackBackend } from 'praisonai';

setApprovalBackend(new CallbackBackend((toolName, args, riskLevel) => {
  return toolName.startsWith('read_');  // boolean, decision object, or Promise
}));

import { setApprovalBackend, approvalDecision, suggestScopePattern } from 'praisonai';
import type { ApprovalBackend, ApprovalBackendRequest } from 'praisonai';

const myBackend: ApprovalBackend = {
  async requestApproval(request: ApprovalBackendRequest) {
    const ok = request.riskLevel !== 'critical';
    return approvalDecision({
      approved: ok,
      approver: 'policy',
      scope: ok ? 'always' : 'once',
      scopePattern: ok ? suggestScopePattern(request) : null
    });
  },
  requestApprovalSync(request: ApprovalBackendRequest) {
    return approvalDecision({ approved: request.riskLevel !== 'critical', approver: 'policy' });
  }
};

setApprovalBackend(myBackend);

import { setApprovalBackend, getApprovalBackend, AutoApproveBackend, ApprovalManager } from 'praisonai';

const manager = new ApprovalManager();
setApprovalBackend(new AutoApproveBackend(), manager, { riskLevel: 'high', agentName: 'ci-bot' });

getApprovalBackend(manager);  // → the AutoApproveBackend instance

import { approvalHandlerFromBackend, toApprovalBackendRequest, ConsoleBackend, ApprovalManager } from 'praisonai';

const manager = new ApprovalManager();
manager.onApprovalRequest(approvalHandlerFromBackend(new ConsoleBackend()));

// inside a handler, reshape a manager request:
manager.onApprovalRequest(async (req) => {
  const backendRequest = toApprovalBackendRequest(req, { riskLevel: 'high' });
  return backendRequest.riskLevel !== 'critical';
});

import { approvalRequest, approvalDecision } from 'praisonai';

const request = approvalRequest({ toolName: 'edit_file', arguments: { path: 'a.ts' }, riskLevel: 'high' });
const decision = approvalDecision({ approved: true, scope: 'session' });

import { buildPermissionTarget, derivePattern, commandPrefix, suggestScopePattern, ARITY, approvalRequest } from 'praisonai';

buildPermissionTarget('execute_command', { command: 'ls -la' });  // 'bash:ls -la'
derivePattern('bash:git status -s');                              // 'bash:git status *'
commandPrefix(['npm', 'run', 'build']);                           // 'npm run'
suggestScopePattern(approvalRequest({ toolName: 'execute_command', arguments: { command: 'git push' }, riskLevel: 'high' }));
ARITY.git;  // 2