Deduplicating Parallel Tool Calls

When a model requests several tool calls at once (a “parallel” turn), the list often contains identical calls — the same tool with the same arguments. Running each one separately wastes time and money and, for a non-idempotent tool, can be outright wrong. Your job is the dispatch layer that runs each unique call exactly once and lets duplicates reuse the cached result.

The problem

A call is a dict {"name": str, "args": dict}. Two calls are the same when they have the same name and the same args — where {"a": 1, "b": 2} and {"b": 2, "a": 1} count as the same args, since key order is not meaningful. You cannot use the args dict directly as a cache key because dicts are unhashable, so you build a canonical key from it.

Task

Complete run_parallel_calls(tools, calls):

1. For each call, build a canonical key from its name and args, for example f"{name}({json.dumps(args, sort_keys=True)})". sort_keys=True makes the key independent of args ordering.
2. Keep a cache dict from key -> result. The first time you see a key, look the tool up in tools, call it with args, and store the result under that key. On a repeated key, do not call the tool again.
3. Return the cache dict: one entry per unique call, mapping the canonical key to its result.
4. If a call names a tool that isn’t in tools, store an error string (e.g. f"error: unknown tool '{name}'") as that call’s result instead of crashing.

Example

calls_log = []
def search(args):
    calls_log.append(args["q"])
    return f"results for {args['q']}"

tools = {"search": search}
calls = [
    {"name": "search", "args": {"q": "cats"}},
    {"name": "search", "args": {"q": "dogs"}},
    {"name": "search", "args": {"q": "cats"}},   # duplicate of the first call
]

run_parallel_calls(tools, calls)
# -> {
#     'search({"q": "cats"})': 'results for cats',
#     'search({"q": "dogs"})': 'results for dogs',
# }
# calls_log == ["cats", "dogs"]   # "cats" ran once, not twice

Constraints

• Each unique (name, args) call must invoke its tool at most once.
• Treat args dicts that differ only in key order as identical.
• Assume args values are JSON-serializable.
• Do not call any real LLM or network — tools are plain callables provided to you.

Approach

Give every call a canonical string key built from its name plus json.dumps(args, sort_keys=True), so identical calls (including args written in a different key order) collapse to one key. Walk the calls, and the first time a key appears run its tool and store the result in a cache; on later appearances of the same key, skip execution entirely. The cache is exactly the name->result mapping we return.

Solution

import json
from typing import Any, Callable

def run_parallel_calls(
    tools: dict[str, Callable[[dict[str, Any]], Any]],
    calls: list[dict[str, Any]],
) -> dict[str, Any]:
    cache: dict[str, Any] = {}

    for call in calls:
        name, args = call["name"], call.get("args", {})
        key = f"{name}({json.dumps(args, sort_keys=True)})"

        if key in cache:            # duplicate call -> reuse cached result
            continue

        tool = tools.get(name)
        if tool is None:
            cache[key] = f"error: unknown tool '{name}'"
            continue

        try:
            cache[key] = tool(args)
        except Exception as e:      # a broken tool shouldn't sink the whole batch
            cache[key] = f"error: {e}"

    return cache

Walkthrough

On the example:

1. Call 1 search(q="cats") -> key 'search({"q": "cats"})'. Not in cache, so we run search (appending "cats" to calls_log) and store 'results for cats'.
2. Call 2 search(q="dogs") -> key 'search({"q": "dogs"})'. New key, run it, store 'results for dogs'; calls_log is now ["cats", "dogs"].
3. Call 3 search(q="cats") -> key 'search({"q": "cats"})'. Already in cache, so we continue — the tool is not called again.
4. Return the two-entry cache; calls_log == ["cats", "dogs"] confirms the duplicate was served from cache.

Complexity & notes

• Time is O(n) key-building plus one tool execution per unique call — the whole point of the dedup. Space is O(u) for u unique calls in the cache.
• sort_keys=True is what makes {"a": 1, "b": 2} and {"b": 2, "a": 1} hash to the same key; without it the two orderings would run the tool twice.
• json.dumps as the key generator assumes JSON-serializable args. If args can hold non-serializable objects, swap in a canonicalizer (e.g. repr of a recursively sorted structure), but the dedup logic is unchanged.
• Real runtimes execute the unique calls concurrently (threads / async) and then fan the results back out to every original slot; this version keeps the same dedup-and-cache core while running them serially so the behavior stays deterministic and hand-checkable.
• Caching is only safe within a single parallel turn. Do not reuse the cache across turns for tools whose results change over time (a clock, a live search), or you will serve stale data.