Approvals with Pause & Resume

@durable_function_tool
async def human_approval(claim: InsuranceClaim) -> str:
    """Ask for human approval for high-value claims."""

    # Create an awakeable for human approval
    approval_id, approval_promise = restate_context().awakeable(type_hint=str)

    # Request human review
    await restate_context().run_typed(
        "Request review", request_human_review, claim=claim, awakeable_id=approval_id
    )

    # Wait for human approval
    return await approval_promise

async def human_approval(claim: InsuranceClaim) -> str:
    """Ask for human approval for high-value claims."""
    # Create an awakeable for human approval
    approval_id, approval_promise = restate_context().awakeable(type_hint=str)

    # Request human review
    await restate_context().run_typed(
        "Request review",
        request_review,
        claim=claim,
        awakeable_id=approval_id,
    )

    # Wait for human approval
    return await approval_promise

@agent.tool
async def human_approval(_run_ctx: RunContext[None], claim: InsuranceClaim) -> str:
    """Ask for human approval for high-value claims."""

    # Create an awakeable for human approval
    approval_id, approval_promise = restate_context().awakeable(type_hint=str)

    # Request human review
    await restate_context().run_typed(
        "Request review", request_human_review, claim=claim, awakeable_id=approval_id
    )

    # Wait for human approval
    return await approval_promise

@tool
async def human_approval(claim: InsuranceClaim) -> str:
    """Ask for human approval for high-value claims."""

    # Create an awakeable that a human can resolve via the Restate API.
    approval_id, approval_promise = restate_context().awakeable(type_hint=str)

    # Notify the reviewer (durable step).
    await restate_context().run_typed(
        "Request review", request_human_review, claim=claim, awakeable_id=approval_id
    )

    # Suspend until resolved.
    return await approval_promise

async function run(ctx: Context, { message }: { message: string }) {
  const prompt =
    "You are an insurance claim evaluation agent. Use these rules: " +
    "* if the amount is more than 1000, ask for human approval, " +
    "* if the amount is less than 1000, decide by yourself. " +
    `Evaluate this claim: ${message}`;
  const { text, toolCalls } = await ctx.run(
    "LLM call",
    // Use your preferred LLM SDK here
    async () => llmCall(prompt, tools),
    { maxRetryAttempts: 3 },
  );

  if (toolCalls?.[0]?.toolName === "humanApproval") {
    // Create a recoverable approval promise
    const approval = ctx.awakeable<boolean>();
    await ctx.run("request-review", () =>
      requestClaimReview(message, approval.id),
    );

    // Suspend until reviewer resolves the approval
    // Check the service logs to see how to resolve it over HTTP, e.g.:
    // curl http://localhost:8080/restate/awakeables/sign_.../resolve --json 'true'
    return approval.promise;
  }

  return text;
}

# TOOL IMPLEMENTATION
async def request_human_approval(ctx: restate.Context, claim: InsuranceClaim) -> str:
    # Create a recoverable approval promise
    approval_id, approval_promise = ctx.awakeable(type_hint=str)

    await ctx.run_typed(
        "Request review", request_review, claim=claim, approval_id=approval_id
    )

    # Suspend until human resolves the approval
    # Check the service logs to see how to resolve it over HTTP, e.g.:
    # curl http://localhost:8080/restate/awakeables/sign_.../resolve --json '"approved"'
    return await approval_promise


# AGENT SERVICE
claim_approval_agent = restate.Service("HumanClaimApprovalAgent")


@claim_approval_agent.handler()
async def run(ctx: restate.Context, req: ClaimPrompt) -> str | None:
    """Evaluate an insurance claim with optional human approval for high-value claims."""

    # LLM evaluates the claim and decides if human approval is needed
    result = await ctx.run_typed(
        "Evaluate claim",
        llm_call,  # Use your preferred LLM SDK here
        RunOptions(max_attempts=3),
        messages=f"""You are an insurance claim evaluation agent. Use these rules:
        - if the amount is more than 1000, ask for human approval using tools;
        - if the amount is less than 1000, decide by yourself.

        Claim: {req.message}""",
        tools=[
            tool(
                "request_human_approval",
                "Ask for human approval for high-value claims",
                InsuranceClaim.model_json_schema(),
            )
        ],
    )

    # If the LLM requests human approval, suspend until a human resolves it
    if (
        result.tool_calls
        and result.tool_calls[0].function.name == "request_human_approval"
    ):
        claim = InsuranceClaim.model_validate_json(
            result.tool_calls[0].function.arguments
        )
        return await request_human_approval(ctx, claim)

    return result.content