feat: in-process toolRulesProvider + analyzeApiCalls in atp-compiler

[encodedz]

Summary

Two additions, one theme: let governance-layer consumers reuse what ATP already has. Both surfaced while building a gateway-layer PDP on top of ATP (DaPulse/mcp-tools ATP POC) that had to re-implement logic locally because the server's own mechanisms weren't reachable from in-process callers.

1. In-process toolRulesProvider support

Before: toolRulesProvider registered via createServer({ toolRulesProvider }) only fires on HTTP requests (handleHTTPRequest → ctx.toolRules → runInRequestScope). In-process callers (new AgentToolProtocolClient({ server })) go straight into server.handleExecute(ctx) / server.handleExplore(ctx) and bypass the provider entirely. They must pass rules explicitly via body.toolRules or body.config.toolRules, re-wrapping the client per call.

After: handleExplore and handleExecute consult toolRulesProvider(ctx) when body.toolRules is absent. body.toolRules still takes precedence. HTTP and in-process converge on the same rule-source mechanism.

Header plumbing: the in-process session's execute(code, config) / explore(path, options) now accept per-call headers that merge into ctx.headers — so a provider that reads request headers (the primary pattern per the ServerConfig docstring) works identically on both paths. For execute, headers are pulled from config.requestContext.headers automatically (the documented per-call header entry point).

Diff is 4 files:

• packages/server/src/handlers/{execute,explorer}.handler.ts — accept optional toolRulesProvider param; call when body rules absent
• packages/server/src/create-server.ts — pass this.toolRulesProvider through
• packages/client/src/core/in-process-session.ts — per-call headers merge into ctx.headers

2. Export analyzeApiCalls from atp-compiler

Motivating use case: governance layers that deny unauthorized code BEFORE dispatch need to statically extract api.<group>.<op>(...) calls. Until now every such consumer re-implemented the Babel walk. With this export, they converge on one canonical implementation alongside @mondaydotcomorg/atp-compiler's existing AST infrastructure.

API:

import { analyzeApiCalls } from '@mondaydotcomorg/atp-compiler';

const { apiCalls, dynamicCallsDetected } = analyzeApiCalls(code);
// apiCalls: [{ apiGroup, operationId }, ...]  deduplicated
// dynamicCallsDetected: true if code does anything static analysis can't
//   resolve to a concrete call — destructuring, aliasing, computed
//   member expressions. Governance should fail-closed on this unless
//   the grant explicitly allows dynamic dispatch.

Fail-closed on parse errors (returns { apiCalls: [], dynamicCallsDetected: true }).

Test plan

• __tests__/unit/in-process-tool-rules-provider.test.ts — 3 cases: provider applies from header, body rules take precedence, neither → unrestricted
• packages/atp-compiler/__tests__/unit/api-call-analyzer.test.ts — 13 cases covering direct calls / dedup / cross-group / destructure (with/without rename) / alias-api / alias-group / computed-group / computed-op / trivial / syntax error / empty string
• Full repo __tests__/unit/ — 17 suites, 224 tests passing (Node 22)
• packages/server vitest — 111 cases passing
• tsc --noEmit on server / client / atp-compiler — clean

Live verification

Both changes were prototyped in-tree in DaPulse/mcp-tools (the mcp-gateway POC) before this PR. With the provider path live, the gateway's bridge can drop its per-request Proxy wrap and just pass forwarded headers through the documented entry point. With analyzeApiCalls exported, the gateway's local atp-code-analyzer.ts can be deleted in favor of the upstream import.

Backwards compat

Both changes are additive:

• toolRulesProvider was optional before and remains so. New param to handlers is optional with undefined default — existing callers (the HTTP middleware and both existing in-process session methods) compile unchanged.
• handleExplore / handleExecute signatures gain one trailing optional param.
• analyzeApiCalls is net-new export.

🤖 Generated with Claude Code