Error handling in tool calls in Agentic AI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of error handling in a tool call

What is the output of this code snippet that calls a tool and handles errors?

Agentic AI

def call_tool(tool, input_data):
    try:
        result = tool(input_data)
        return f"Success: {result}"
    except ValueError:
        return "ValueError caught"
    except Exception:
        return "General error caught"

def sample_tool(x):
    if x < 0:
        raise ValueError("Negative input")
    elif x == 0:
        raise RuntimeError("Zero input")
    else:
        return x * 2

output = call_tool(sample_tool, 0)
print(output)

A Success: 0

B ValueError caught

C General error caught

D RuntimeError: Zero input

💡 Hint

Think about which exception is raised and which except block catches it.

The tool raises RuntimeError when input is 0. The call_tool function catches ValueError separately, but RuntimeError is caught by the general Exception block, so it returns 'General error caught'.

❓ Model Choice

intermediate

Choosing the right error handling model for tool calls

Which error handling model is best suited for a tool call that may raise multiple specific exceptions and needs to log errors distinctly?

A Multiple try-except blocks each catching one specific exception type separately

B Single try-except block catching all exceptions with a general except clause

C Try-except with nested try blocks inside except clauses

D No try-except, just let exceptions propagate to the caller

💡 Hint

Consider clarity and specific error handling needs.

Using multiple try-except blocks for specific exceptions allows distinct handling and logging of each error type, improving clarity and debugging.

🔧 Debug

advanced

Identify the error in this tool call error handling code

What error will this code raise when calling the tool with input 5?

Agentic AI

def tool(x):
    if x == 5:
        raise KeyError("Key missing")
    return x

def call_tool(tool_func, val):
    try:
        return tool_func(val)
    except ValueError:
        return "Value error handled"
    except KeyError:
        return "Key error handled"
    except:
        return "Other error"

result = call_tool(tool, 5)
print(result)

A Raises an uncaught exception

B Key error handled

C Other error

D Value error handled

💡 Hint

Check which except block matches the raised exception.

The tool raises KeyError for input 5, which is caught by the except KeyError block returning 'Key error handled'.

❓ Hyperparameter

advanced

Choosing retry count for error handling in tool calls

If a tool call fails due to a transient network error, which retry count is most reasonable to balance responsiveness and robustness?

A 1 retry

B 0 retries (fail immediately)

C 10 retries

D 100 retries

💡 Hint

Too many retries can cause delays; too few may miss recovery.

One retry balances quick failure with a chance to recover from transient errors without long delays.

🧠 Conceptual

expert

Best practice for error handling in asynchronous tool calls

Which approach best ensures error handling in asynchronous tool calls to avoid silent failures?

A Use callbacks without error handling

B Ignore errors and rely on the caller to handle exceptions

C Wrap async calls in a synchronous try-except block

D Use try-except inside the async function and log errors before returning

💡 Hint

Think about where errors can be caught in async code.

Using try-except inside async functions allows catching and logging errors immediately, preventing silent failures.