Amazon Bedrock AgentCore 비동기 호출 패턴

# The tool the agent calls once it reaches a verdict
@tool
def conclude_validation(approved: bool, issues: list, summary: str) -> str:
    verdict = {"approved": approved, "issues": issues, "summary": summary, "source": "agentcore"}

    # A Step Functions task token was passed: resume that execution
    if task_token:
        sfn.send_task_success(taskToken=task_token, output=json.dumps(verdict))
        return "Step Functions resumed."

    # A durable-function callback ID was passed: resume the durable function
    if callback_id:
        lambda_client.send_durable_execution_callback_success(
            CallbackId=callback_id, Result=json.dumps(verdict).encode("utf-8"))
        return "Durable function resumed."

    # Neither was passed: this is a synchronous call, return the verdict inline
    return "Verdict recorded."

@app.async_task
async def validate_document_async(prompt, document, extracted_text):
    # Background work; conclude_validation fires the right callback when done
    agent = build_agent()
    await agent.invoke_async(message(prompt, document, extracted_text))

@app.entrypoint
async def handler(event):
    task_token = event.get("taskToken") # passed by the task-token pattern callback
    callback_id = event.get("callbackId") # passed by the durable-function pattern

    # Asynchronous: start the work and return "accepted" right away
    if task_token or callback_id:
        asyncio.create_task(validate_document_async(...))
        return {"status": "accepted"}

    # Synchronous: run now and return the verdict in the response
    agent = build_agent()
    await agent.invoke_async(message(...))
    return verdict

// Start the agent, pass the task token, and return without waiting
const response = await agentcore.send(
  new InvokeAgentRuntimeCommand({
    agentRuntimeArn: AGENT_RUNTIME_ARN,
    payload: new TextEncoder().encode(JSON.stringify({ ...payload, taskToken })),
    runtimeSessionId: sessionId,
  })
);

// Returning here does not complete the step. Step Functions stays paused until
// the agent calls SendTaskSuccess with this task token.
return { dispatched: true };

// Suspend the function until the agent calls back
const result = await ctx.waitForCallback(
  "validate-agentcore",
  async (callbackId) => dispatchAgentCore(callbackId, document, extractedText, executionId),
  { timeout: { seconds: 120 } }
);