Intelligent systems for what comes next.

async def run_tool(name: str, args: dict) -> dict:
    """Bind model output to a typed tool contract."""
    spec = registry.resolve(name)
    return await spec.execute(**args)

export async function POST(req: Request) {
  const { messages } = await req.json();
  const result = streamText({ model, messages, tools });
  return result.toUIMessageStreamResponse();
}

public interface Tool<T, R> {
  R invoke(T input) throws ToolException;
}

public final class AgentRouter {
  public CompletionStage<R> dispatch(String id, T payload) {
    return registry.get(id).invoke(payload);
  }
}
}

pub trait Tool: Send + Sync {
    async fn run(&self, input: Value) -> Result<Value, ToolError>;
}

pub struct AgentRouter {
    tools: HashMap<String, Arc<dyn Tool>>,
}
}

protocol Tool: Sendable {
  func run(_ input: [String: Any]) async throws -> [String: Any]
}

actor AgentRouter {
  private var tools: [String: any Tool] = [:]
}
}

struct ITool {
  virtual ~ITool() = default;
  virtual nlohmann::json run(const nlohmann::json& in) = 0;
};

class AgentRouter {
  std::unordered_map<std::string, std::unique_ptr<ITool>> tools_;
};
}

public interface ITool<TIn, TOut> {
  Task<TOut> RunAsync(TIn input, CancellationToken ct);
}

public sealed class AgentRouter(IToolRegistry registry) {
  public Task<TOut> DispatchAsync<TIn, TOut>(string id, TIn input, CancellationToken ct)
    => registry.Resolve<ITool<TIn, TOut>>(id).RunAsync(input, ct);
}
}