Approval and User Input

import { accessTokenFromEnv, query } from '@qoder-ai/qoder-agent-sdk';

query({
  prompt: 'Read the release configuration and generate a changelog. Ask before writing files.',
  options: {
    auth: accessTokenFromEnv(),
    permissionMode: 'default',
    allowedTools: ['Read'],
    async canUseTool(toolName, input, context) {
      const approved = await showApprovalDialog({
        toolName,
        input,
        title: context.title,
        description: context.description,
        signal: context.signal,
      });

      if (!approved) {
        return {
          behavior: 'deny',
          message: 'The user denied this operation.',
          toolUseID: context.toolUseID,
        };
      }

      return {
        behavior: 'allow',
        updatedInput: input,
        toolUseID: context.toolUseID,
      };
    },
  },
});

return {
  behavior: 'allow',
  updatedInput: input,
  toolUseID: context.toolUseID,
};

return {
  behavior: 'deny',
  message: 'This command is not allowed in production.',
  toolUseID: context.toolUseID,
};

return {
  behavior: 'allow',
  updatedInput: input,
  updatedPermissions: context.suggestions,
  toolUseID: context.toolUseID,
};

import { createInterface } from 'node:readline/promises';
import {
  accessTokenFromEnv,
  query,
  type CanUseTool,
} from '@qoder-ai/qoder-agent-sdk';

type Question = {
  question: string;
  header: string;
  options: Array<{ label: string; description: string }>;
  multiSelect?: boolean;
};

const readline = createInterface({
  input: process.stdin,
  output: process.stdout,
});

function parseAnswer(raw: string, question: Question): string {
  const indexes = raw
    .split(',')
    .map((part) => Number.parseInt(part.trim(), 10) - 1)
    .filter((index) => index >= 0 && index < question.options.length);

  if (indexes.length > 0) {
    const selected = question.multiSelect ? indexes : indexes.slice(0, 1);
    return selected.map((index) => question.options[index].label).join(', ');
  }

  return raw.trim();
}

async function readLine(
  prompt: string,
  signal: AbortSignal,
): Promise<string | null> {
  try {
    return await readline.question(prompt, { signal });
  } catch (error) {
    if (
      signal.aborted ||
      (error instanceof Error && error.name === 'AbortError')
    ) {
      return null;
    }
    throw error;
  }
}

const canUseTool: CanUseTool = async (toolName, input, context) => {
  if (context.signal.aborted) {
    return {
      behavior: 'deny',
      message: 'The request was cancelled.',
      toolUseID: context.toolUseID,
    };
  }

  if (toolName === 'AskUserQuestion') {
    const questions = (input.questions ?? []) as Question[];
    const answers: Record<string, string> = {};

    for (const question of questions) {
      console.log(`\n${question.header}: ${question.question}`);
      question.options.forEach((option, index) => {
        console.log(`${index + 1}. ${option.label} — ${option.description}`);
      });

      const hint = question.multiSelect
        ? 'Enter option numbers separated by commas, or a custom answer (/cancel to cancel): '
        : 'Enter an option number or a custom answer (/cancel to cancel): ';

      let answer = '';
      while (!answer) {
        const raw = await readLine(hint, context.signal);
        if (raw === null || raw.trim() === '/cancel') {
          return {
            behavior: 'deny',
            message: 'The user cancelled the questions.',
            toolUseID: context.toolUseID,
          };
        }

        answer = parseAnswer(raw, question);
        if (!answer) {
          console.log('An answer is required. Try again.');
        }
      }

      answers[question.question] = answer;
    }

    return {
      behavior: 'allow',
      updatedInput: { questions, answers },
      toolUseID: context.toolUseID,
    };
  }

  const answer = await readLine(
    `\nAllow ${toolName} with input ${JSON.stringify(input)}? [y/N] `,
    context.signal,
  );

  if (answer === null) {
    return {
      behavior: 'deny',
      message: 'The request was cancelled.',
      toolUseID: context.toolUseID,
    };
  }

  if (answer.trim().toLowerCase() !== 'y') {
    return {
      behavior: 'deny',
      message: `The user denied ${toolName}.`,
      toolUseID: context.toolUseID,
    };
  }

  return {
    behavior: 'allow',
    updatedInput: input,
    toolUseID: context.toolUseID,
  };
};

try {
  for await (const message of query({
    prompt: 'Inspect the project and produce release notes. Ask me when the release target is unclear.',
    options: {
      auth: accessTokenFromEnv(),
      tools: ['AskUserQuestion', 'Read', 'Write', 'Bash'],
      allowedTools: ['Read'],
      permissionMode: 'default',
      canUseTool,
    },
  })) {
    if (message.type === 'result') {
      console.log(message.subtype);
    }
  }
} finally {
  readline.close();
}