Summary

This refactor changes how dependencies are passed to tool handlers from a closure-based pattern to a context-based pattern. This eliminates the need to create new closures for every tool on each request, which is critical for the remote server where one server instance is created per request.

Problem

In the closure-based pattern, NewTool stored a function that took deps and returned a handler:

// Old pattern - creates closure on every call to Handler(deps)
func NewTool(..., handler func(deps) handlerFn) {
    return ServerTool{
        Handler: func(deps any) handlerFn {
            return handler(deps.(ToolDependencies))  // Creates new closure each time
        }
    }
}

For the remote server with ~89 tools, this meant 178 allocations per request just for tool handler setup.

Solution

The new pattern injects dependencies into the context once, and handlers extract them:

// New pattern - no closure creation at request time
func NewTool(..., handler func(ctx, deps, req, args) result) {
    return ServerTool{
        Handler: func(ctx any) handlerFn {
            return func(ctx, req) result {
                deps := MustDepsFromContext(ctx)  // Extract from context
                return handler(ctx, deps, req, args)
            }
        }
    }
}

Benchmark Results

Throughput (89 tools, 5s benchmark, 3 runs)

Memory

Scaling (tools from 13 to 1,300)

Changes

New APIs in pkg/github/dependencies.go

• ContextWithDeps(ctx, deps) - inject dependencies into context
• DepsFromContext(ctx) - extract dependencies (returns nil if not present)
• MustDepsFromContext(ctx) - extract dependencies (panics if not present)

Updated in pkg/inventory/server_tool.go

• NewServerToolWithContextHandler - new constructor for context-based handlers
• NewServerToolWithRawContextHandler - new constructor for raw handlers
• Old constructors marked as deprecated

Converted (89 tool handlers across 15 files)

All tool handlers converted from closure pattern to direct context-based pattern.

Test updates (17 test files)

All tests updated to use ContextWithDeps(context.Background(), deps).

Backwards Compatibility

• Old NewServerTool and NewServerToolFromHandler are deprecated but still work
• dynamic_tools.go intentionally uses the old pattern (with nolint comment) since it wraps user-provided handlers

Testing

• All existing tests pass
• script/lint passes
• script/test passes