@honua/mcp-server 0.0.10-alpha.0 → 0.0.20-alpha.0

package/dist/src/eval/drivers/index.js

@@ -0,0 +1,74 @@
+import { AnthropicDriver } from "./anthropic.js";
+import { BedrockDriver } from "./bedrock.js";
+import { DeterministicDriver } from "./deterministic.js";
+import { OpenAiDriver } from "./openai.js";
+export { AnthropicDriver, BedrockDriver, DeterministicDriver, OpenAiDriver };
+/**
+ * Resolve the set of model drivers to run.
+ *
+ * The deterministic control is always included. Claude (Anthropic API) and GPT
+ * drivers are added when their API keys are present; the Claude-via-Bedrock driver
+ * is added when `HONUA_EVAL_BEDROCK` is set (its auth comes from the AWS credential
+ * chain, which can't be sniffed from a single env var). This gates live runs behind
+ * env without hardcoding any credentials. CI runs the deterministic driver only —
+ * a green, reproducible artifact with no model/API calls.
+ */
+export function resolveDrivers(options = {}) {
+    const env = options.env ?? process.env;
+    const drivers = [new DeterministicDriver()];
+    const anthropic = new AnthropicDriver({ apiKey: env.ANTHROPIC_API_KEY, model: env.HONUA_EVAL_ANTHROPIC_MODEL });
+    if (options.includeUnavailable || anthropic.isAvailable()) {
+        drivers.push(anthropic);
+    }
+    const openai = new OpenAiDriver({ apiKey: env.OPENAI_API_KEY, model: env.OPENAI_MODEL });
+    if (options.includeUnavailable || openai.isAvailable()) {
+        drivers.push(openai);
+    }
+    const bedrock = new BedrockDriver({
+        enabled: env.HONUA_EVAL_BEDROCK,
+        model: env.HONUA_EVAL_BEDROCK_MODEL,
+        region: env.AWS_REGION,
+    });
+    if (options.includeUnavailable || bedrock.isAvailable()) {
+        drivers.push(bedrock);
+    }
+    return drivers;
+}
+/**
+ * Build the driver set for an explicit `--driver` selection. The deterministic
+ * control is always included (it is the CI gate). Named live drivers are always
+ * constructed and run — even if their key/opt-in is absent — so an explicit
+ * request surfaces an honest `driverError` rather than being silently dropped.
+ */
+export function selectDrivers(names, options = {}) {
+    const env = options.env ?? process.env;
+    const drivers = [new DeterministicDriver()];
+    for (const name of names) {
+        switch (name) {
+            case "deterministic":
+                break; // already included
+            case "anthropic":
+                drivers.push(new AnthropicDriver({ apiKey: env.ANTHROPIC_API_KEY, model: env.HONUA_EVAL_ANTHROPIC_MODEL }));
+                break;
+            case "openai":
+                drivers.push(new OpenAiDriver({ apiKey: env.OPENAI_API_KEY, model: env.OPENAI_MODEL }));
+                break;
+            case "bedrock":
+                drivers.push(new BedrockDriver({ enabled: "1", model: env.HONUA_EVAL_BEDROCK_MODEL, region: env.AWS_REGION }));
+                break;
+            default: {
+                const exhaustive = name;
+                throw new Error(`unknown driver: ${String(exhaustive)}`);
+            }
+        }
+    }
+    return drivers;
+}
+/** Parse/validate a `--driver` value into a known driver name. */
+export function parseDriverName(value) {
+    const known = ["deterministic", "anthropic", "openai", "bedrock"];
+    if (known.includes(value)) {
+        return value;
+    }
+    throw new Error(`unknown --driver "${value}" (expected one of: ${known.join(", ")})`);
+}

package/dist/src/eval/drivers/openai.d.ts

@@ -0,0 +1,14 @@
+import type { ModelDriver, Scenario, WorkflowContext, WorkflowTranscript } from "../types.js";
+export interface OpenAiDriverOptions {
+    apiKey?: string | undefined;
+    model?: string;
+}
+export declare class OpenAiDriver implements ModelDriver {
+    readonly vendor: "openai";
+    readonly id: string;
+    private readonly apiKey;
+    constructor(options?: OpenAiDriverOptions);
+    isAvailable(): boolean;
+    runWorkflow(scenario: Scenario, ctx: WorkflowContext): Promise<WorkflowTranscript>;
+}
+//# sourceMappingURL=openai.d.ts.map

package/dist/src/eval/drivers/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../../src/eval/drivers/openai.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAkB,eAAe,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAkD9G,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,YAAa,YAAW,WAAW;IAC9C,QAAQ,CAAC,MAAM,EAAG,QAAQ,CAAU;IACpC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;gBAEhC,OAAO,GAAE,mBAAwB;IAK7C,WAAW,IAAI,OAAO;IAIhB,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;CA4EzF"}

package/dist/src/eval/drivers/openai.js

@@ -0,0 +1,136 @@
+/**
+ * GPT client driver for the cross-model eval (honua-server #1956).
+ *
+ * Gated behind OPENAI_API_KEY and a dynamically-imported `openai` SDK — neither
+ * is a dependency of this package, so the offline CI path never needs them. This
+ * is the "any client" counterpart to the Claude driver: the SAME corpus and the
+ * SAME grading are driven by a GPT model over the identical MCP catalog, so the
+ * artifact can compare success / clarification / edit rates across vendors.
+ *
+ * Live cross-model runs are tracked under honua-io/honua-server#1956.
+ */
+const ASK_USER_FUNCTION = {
+    type: "function",
+    function: {
+        name: "ask_user",
+        description: "Call this ONLY if the request is too ambiguous to proceed. Provide the clarifying question you would ask.",
+        parameters: {
+            type: "object",
+            properties: { question: { type: "string" } },
+            required: ["question"],
+            additionalProperties: false,
+        },
+    },
+};
+const SYSTEM_PROMPT = "You are a GIS analyst working through the Honua MCP tools. Complete the user's task by calling the available tools. " +
+    "Ground every step in real tool results — do not invent service names, layers, or fields. " +
+    "If, and only if, the request is genuinely ambiguous and you cannot proceed, call ask_user. " +
+    "When finished, give a concise final answer that references what the tools returned.";
+const MAX_ITERATIONS = 8;
+/**
+ * Default GPT model for live cross-model runs.
+ *
+ * `gpt-5.5` is OpenAI's generally-available flagship reasoning model as of
+ * July 2026 (the apex of the public Chat Completions catalog; see
+ * developers.openai.com/api/docs/models/all). The newer GPT-5.6 "Sol" family was
+ * still preview-gated to a handful of orgs at that date and not callable by an
+ * ordinary API key, so it is NOT the default — set `OPENAI_MODEL=gpt-5.6-sol`
+ * (or any other id) to override once you have access. The resolved id is recorded
+ * per-driver in the results artifact (`models[].model`) so published comparisons
+ * are attributable to an exact model.
+ */
+const DEFAULT_MODEL = "gpt-5.5";
+export class OpenAiDriver {
+    vendor = "openai";
+    id;
+    apiKey;
+    constructor(options = {}) {
+        this.id = options.model ?? process.env.OPENAI_MODEL ?? DEFAULT_MODEL;
+        this.apiKey = options.apiKey ?? process.env.OPENAI_API_KEY;
+    }
+    isAvailable() {
+        return typeof this.apiKey === "string" && this.apiKey.length > 0;
+    }
+    async runWorkflow(scenario, ctx) {
+        const steps = [];
+        const transcript = {
+            scenarioId: scenario.id,
+            modelId: this.id,
+            steps,
+            finalAnswer: "",
+            clarificationRequested: false,
+            errorCount: 0,
+        };
+        let OpenAI;
+        try {
+            const specifier = "openai";
+            const mod = (await import(specifier));
+            OpenAI = mod.default;
+        }
+        catch {
+            transcript.driverError = "openai SDK is not installed (required for live GPT eval runs)";
+            return transcript;
+        }
+        if (!this.apiKey) {
+            transcript.driverError = "OPENAI_API_KEY is not set";
+            return transcript;
+        }
+        const client = new OpenAI({ apiKey: this.apiKey });
+        const tools = [
+            ...ctx.tools.map((t) => ({
+                type: "function",
+                function: { name: t.name, description: t.description, parameters: t.inputSchema },
+            })),
+            ASK_USER_FUNCTION,
+        ];
+        const messages = [
+            { role: "system", content: SYSTEM_PROMPT },
+            { role: "user", content: scenario.prompt },
+        ];
+        try {
+            for (let i = 0; i < MAX_ITERATIONS; i++) {
+                const response = await client.chat.completions.create({ model: this.id, messages, tools });
+                const message = response.choices[0]?.message;
+                if (!message) {
+                    transcript.driverError = "no choice returned by the model";
+                    return transcript;
+                }
+                const toolCalls = message.tool_calls ?? [];
+                if (toolCalls.length === 0) {
+                    transcript.finalAnswer = message.content ?? "";
+                    return transcript;
+                }
+                messages.push({ role: "assistant", content: message.content ?? null, tool_calls: toolCalls });
+                for (const call of toolCalls) {
+                    const args = safeParse(call.function.arguments);
+                    if (call.function.name === "ask_user") {
+                        transcript.clarificationRequested = true;
+                        transcript.finalAnswer = message.content ?? "";
+                        return transcript;
+                    }
+                    const result = await ctx.callTool(call.function.name, args);
+                    steps.push({ tool: call.function.name, args, isError: result.isError });
+                    if (result.isError) {
+                        transcript.errorCount++;
+                    }
+                    messages.push({ role: "tool", tool_call_id: call.id, content: result.text });
+                }
+            }
+            transcript.driverError = `exceeded ${MAX_ITERATIONS} tool-use iterations without finishing`;
+            return transcript;
+        }
+        catch (err) {
+            transcript.driverError = err instanceof Error ? err.message : String(err);
+            return transcript;
+        }
+    }
+}
+function safeParse(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === "object" && parsed !== null ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}

package/dist/src/eval/grade.d.ts

@@ -0,0 +1,14 @@
+import type { Scenario, ScenarioGrade, WorkflowTranscript } from "./types.js";
+/** True if `sequence` appears as an ordered (not necessarily contiguous) subsequence of `steps`. */
+export declare function isOrderedSubsequence(steps: string[], sequence: string[]): boolean;
+/**
+ * Grade a transcript against a scenario's declarative success criteria.
+ *
+ * Outcomes:
+ *  - `error`: the driver failed to run (unavailable model, exception).
+ *  - `clarified`: the driver asked a clarifying question instead of completing.
+ *  - `pass`: all criteria satisfied.
+ *  - `fail`: completed but violated one or more criteria.
+ */
+export declare function grade(scenario: Scenario, transcript: WorkflowTranscript): ScenarioGrade;
+//# sourceMappingURL=grade.d.ts.map

package/dist/src/eval/grade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grade.d.ts","sourceRoot":"","sources":["../../../src/eval/grade.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE9E,oGAAoG;AACpG,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAQjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,kBAAkB,GAAG,aAAa,CA2CvF"}

package/dist/src/eval/grade.js

@@ -0,0 +1,56 @@
+/** True if `sequence` appears as an ordered (not necessarily contiguous) subsequence of `steps`. */
+export function isOrderedSubsequence(steps, sequence) {
+    let i = 0;
+    for (const step of steps) {
+        if (i < sequence.length && step === sequence[i]) {
+            i++;
+        }
+    }
+    return i === sequence.length;
+}
+/**
+ * Grade a transcript against a scenario's declarative success criteria.
+ *
+ * Outcomes:
+ *  - `error`: the driver failed to run (unavailable model, exception).
+ *  - `clarified`: the driver asked a clarifying question instead of completing.
+ *  - `pass`: all criteria satisfied.
+ *  - `fail`: completed but violated one or more criteria.
+ */
+export function grade(scenario, transcript) {
+    const base = {
+        scenarioId: scenario.id,
+        modelId: transcript.modelId,
+        errorCount: transcript.errorCount,
+    };
+    if (transcript.driverError) {
+        return { ...base, outcome: "error", violations: [transcript.driverError] };
+    }
+    if (transcript.clarificationRequested) {
+        return { ...base, outcome: "clarified", violations: ["driver requested clarification"] };
+    }
+    const violations = [];
+    const calledTools = transcript.steps.map((s) => s.tool);
+    const calledSet = new Set(calledTools);
+    const { criteria } = scenario;
+    for (const required of criteria.requiredTools) {
+        if (!calledSet.has(required)) {
+            violations.push(`required tool not called: ${required}`);
+        }
+    }
+    if (criteria.expectedToolSequence && !isOrderedSubsequence(calledTools, criteria.expectedToolSequence)) {
+        violations.push(`expected tool sequence not observed: ${criteria.expectedToolSequence.join(" -> ")}`);
+    }
+    for (const forbidden of criteria.forbiddenTools ?? []) {
+        if (calledSet.has(forbidden)) {
+            violations.push(`forbidden tool called: ${forbidden}`);
+        }
+    }
+    const answer = transcript.finalAnswer.toLowerCase();
+    for (const fragment of criteria.answerMustInclude ?? []) {
+        if (!answer.includes(fragment.toLowerCase())) {
+            violations.push(`answer missing expected content: "${fragment}"`);
+        }
+    }
+    return { ...base, outcome: violations.length === 0 ? "pass" : "fail", violations };
+}

package/dist/src/eval/northstar-corpus.d.ts

@@ -0,0 +1,3 @@
+import type { Scenario } from "./types.js";
+export declare const NORTHSTAR_CORPUS: Scenario[];
+//# sourceMappingURL=northstar-corpus.d.ts.map

package/dist/src/eval/northstar-corpus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"northstar-corpus.d.ts","sourceRoot":"","sources":["../../../src/eval/northstar-corpus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAiF3C,eAAO,MAAM,gBAAgB,EAAE,QAAQ,EAyHtC,CAAC"}

package/dist/src/eval/northstar-corpus.js

@@ -0,0 +1,194 @@
+/**
+ * NORTH-STAR corpus — the P1 gate measure (honua-server #1948, MCP initiative P1.7).
+ *
+ * These are the three canonical end-to-end workflows the Phase-1 gate is defined
+ * against: "all 3 north-star workflows pass via a vanilla MCP client". Encoding
+ * them as eval scenarios turns that gate into a mechanical pass/fail signal that
+ * runs on the exact same grading (required-tool selection, ordered subsequence,
+ * forbidden-tool avoidance, answer-substring evidence) as every other corpus.
+ *
+ * The tool names are the reference-implementation (`honua_*`) names for the
+ * standard geospatial-mcp tools (see geospatial-mcp `spec/schemas/index.json`).
+ * Some required tools are P1 deliverables that DO NOT yet ship on every surface:
+ *
+ *   - `honua_publish_result`   — standard `publish_result`, reference status
+ *                                `known-gap` (promote a job/result package to a
+ *                                hosted layer). Lands with P1.
+ *   - `honua_apply_style_preset` — standard `apply_style_preset`, `known-gap`
+ *                                (styling a published layer). Lands with P1.
+ *
+ * Against a server that predates the P1 tools these scenarios are EXPECTED to
+ * fail — that failure is the gate signal, not a harness bug. The report makes it
+ * explicit which required tools a surface is missing:
+ *   - `catalog.unresolvedRequiredTools` names every required tool the live
+ *     `tools/list` did not advertise, corpus-wide.
+ *   - each per-scenario `results[].missingTools` names the tools THAT scenario
+ *     requires but the surface lacks (the gate dashboard, per workflow).
+ * The deterministic offline driver degrades HONESTLY: when its scripted ideal
+ * trajectory reaches a tool the surface does not advertise it records a
+ * `driverError` ("scripted tool not advertised …") and the scenario grades as
+ * `error`, never a silent pass. No fixture responses are faked to make an
+ * unbuilt tool look green.
+ *
+ * LIVE-GATED like the operator corpus: selected only via
+ * `HONUA_EVAL_CORPUS=northstar` (or `--corpus northstar`), and included in
+ * `all`. It is NOT part of the default analyst corpus, so the offline CI gate
+ * (`test:eval`, analyst-only) is untouched. Run it live against a P1 surface
+ * with `--driver bedrock` + `HONUA_MCP_REMOTE_URL=<server>/mcp` + credentials.
+ */
+/**
+ * The generic mutation escape-hatch. Every north-star workflow must compose the
+ * structured lifecycle (plan → validate → execute → publish) rather than reach
+ * for `honua_propose_operation`, so forbidding it turns "did the client use the
+ * intended workflow?" into a graded criterion.
+ */
+const GENERIC_MUTATION_TOOL = "honua_propose_operation";
+/** A small, embedded address CSV for the geocode → publish workflow (10 rows). */
+const ADDRESS_CSV = [
+    "name,street,city,state,zip",
+    "City Hall,1 Dr Carlton B Goodlett Pl,San Francisco,CA,94102",
+    "Ferry Building,1 Ferry Building,San Francisco,CA,94111",
+    "Coit Tower,1 Telegraph Hill Blvd,San Francisco,CA,94133",
+    "Palace of Fine Arts,3601 Lyon St,San Francisco,CA,94123",
+    "SFMOMA,151 3rd St,San Francisco,CA,94103",
+    "Oracle Park,24 Willie Mays Plaza,San Francisco,CA,94107",
+    "Golden Gate Park,501 Stanyan St,San Francisco,CA,94117",
+    "Exploratorium,Pier 15 Embarcadero,San Francisco,CA,94111",
+    "Chase Center,1 Warriors Way,San Francisco,CA,94158",
+    "Sutro Baths,1004 Point Lobos Ave,San Francisco,CA,94121",
+].join("\n");
+/** Parsed address rows the geocoder batch call replays (without the header). */
+const ADDRESS_ROWS = ADDRESS_CSV.split("\n")
+    .slice(1)
+    .map((line) => {
+    const [, street, city, state, zip] = line.split(",");
+    return `${street}, ${city}, ${state} ${zip}`;
+});
+/** The natural-language prompt for the CSV → point-layer workflow (CSV embedded). */
+const CSV_GEOCODE_PROMPT = `Here is a CSV of addresses. Geocode them and publish a point layer from the results.
+
+\`\`\`csv
+${ADDRESS_CSV}
+\`\`\`
+
+Batch-geocode every row, ingest the geocoded points as a dataset, and publish that dataset as a hosted point service. Do not reach for a raw propose_operation.`;
+export const NORTHSTAR_CORPUS = [
+    {
+        id: "northstar-styled-map",
+        title: "Proximity analysis → published, styled map",
+        category: "north-star",
+        prompt: "Find all parcels within 500 m of a flood zone and produce a styled map of them. " +
+            "Resolve the parcels and flood-zone layers, plan and run the proximity analysis as a " +
+            "governed job, publish the result as a new layer, style it, and render a map. Use the " +
+            "structured analysis lifecycle — do not reach for a raw propose_operation.",
+        criteria: {
+            // Load-bearing arc of the workflow: ground the entities, execute the plan,
+            // publish the job artifact to a layer, and render a map of it.
+            requiredTools: ["honua_resolve_entity", "honua_execute_plan", "honua_publish_result", "honua_render_map"],
+            expectedToolSequence: ["honua_resolve_entity", "honua_execute_plan", "honua_publish_result", "honua_render_map"],
+            forbiddenTools: [GENERIC_MUTATION_TOOL],
+        },
+        script: [
+            { tool: "honua_resolve_entity", args: { text: "parcels", entityType: "layer" } },
+            { tool: "honua_resolve_entity", args: { text: "flood zones", entityType: "layer" } },
+            {
+                tool: "honua_plan_analysis",
+                args: { intent: "select parcels within 500 meters of a flood zone and produce a styled map" },
+            },
+            { tool: "honua_validate_plan", args: { plan: { planId: "northstar-styled-map-plan" } } },
+            { tool: "honua_execute_plan", args: { plan: { planId: "northstar-styled-map-plan" } } },
+            // P1 tools (reference known-gap today): promote the job artifact to a layer,
+            // then style it. On a pre-P1 surface these are unadvertised and the driver
+            // degrades to an honest driverError here rather than faking a response.
+            { tool: "honua_publish_result", args: { sourceId: "northstar-styled-map-result", targetKind: "layer" } },
+            {
+                tool: "honua_apply_style_preset",
+                args: { mapPackageId: "northstar-styled-map-package", styleId: "flood-risk" },
+            },
+            {
+                tool: "honua_render_map",
+                args: { layers: ["northstar-styled-map-layer"], bbox: [-122.55, 37.7, -122.35, 37.85] },
+            },
+        ],
+    },
+    {
+        id: "northstar-csv-geocode-publish",
+        title: "CSV of addresses → geocoded, published point layer",
+        category: "north-star",
+        prompt: CSV_GEOCODE_PROMPT,
+        criteria: {
+            // The CSV → point-layer arc as the standard defines it: batch geocode →
+            // ingest the resulting points → publish the source table as a service.
+            requiredTools: ["honua_geocode_addresses", "honua_ingest_dataset", "honua_publish_service"],
+            expectedToolSequence: ["honua_geocode_addresses", "honua_ingest_dataset", "honua_publish_service"],
+            forbiddenTools: [GENERIC_MUTATION_TOOL],
+        },
+        script: [
+            { tool: "honua_geocode_addresses", args: { addresses: ADDRESS_ROWS } },
+            {
+                tool: "honua_ingest_dataset",
+                args: {
+                    format: "csv",
+                    datasetName: "sf-landmarks",
+                    data: ADDRESS_CSV,
+                    addressColumn: "street",
+                },
+            },
+            {
+                tool: "honua_publish_service",
+                args: {
+                    connectionId: "default",
+                    schema: "public",
+                    table: "sf_landmarks",
+                    layerName: "SF Landmarks",
+                    geometryType: "point",
+                },
+            },
+        ],
+    },
+    {
+        id: "northstar-buffer-stats-job",
+        title: "Buffer → intersect → summary statistics, run as a job",
+        category: "north-star",
+        prompt: "Buffer highways by 100 m, intersect the buffers with wetlands, and give me summary " +
+            "statistics for the overlap. Run it as a job and report progress. Ground the goal into " +
+            "an analysis plan, validate it, then execute it as a governed job and report the results " +
+            "the job produces. Do not reach for a raw propose_operation.",
+        criteria: {
+            // Plan entry → validate → execute-as-job. The answer must carry evidence
+            // that the JOB path was used and its results read back — kept loose (the
+            // job reference token, not exact statistic values) so live variance in the
+            // numbers does not flip the grade.
+            requiredTools: ["honua_plan_analysis", "honua_validate_plan", "honua_execute_plan"],
+            expectedToolSequence: [
+                "honua_ground_candidates",
+                "honua_plan_analysis",
+                "honua_validate_plan",
+                "honua_execute_plan",
+            ],
+            forbiddenTools: [GENERIC_MUTATION_TOOL],
+            answerMustInclude: ["job"],
+        },
+        script: [
+            {
+                tool: "honua_ground_candidates",
+                args: {
+                    goal: "buffer highways by 100 meters, intersect with wetlands, and summarize the overlap",
+                    assumptionPolicy: "UseDefaults",
+                },
+            },
+            {
+                tool: "honua_plan_analysis",
+                args: { intent: "buffer highways by 100m, intersect with wetlands, and compute summary statistics" },
+            },
+            { tool: "honua_validate_plan", args: { plan: { planId: "northstar-buffer-stats-plan" } } },
+            // Optional dry-run estimate before committing (reference advertises it with
+            // the same partial-plan input schema as validate_plan).
+            { tool: "honua_dry_run_plan", args: { plan: { planId: "northstar-buffer-stats-plan" } } },
+            {
+                tool: "honua_execute_plan",
+                args: { plan: { planId: "northstar-buffer-stats-plan" }, idempotencyKey: "northstar-buffer-stats-1" },
+            },
+        ],
+    },
+];

package/dist/src/eval/operator-corpus.d.ts

@@ -0,0 +1,3 @@
+import type { Scenario } from "./types.js";
+export declare const OPERATOR_CORPUS: Scenario[];
+//# sourceMappingURL=operator-corpus.d.ts.map

package/dist/src/eval/operator-corpus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator-corpus.d.ts","sourceRoot":"","sources":["../../../src/eval/operator-corpus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AA2D3C,eAAO,MAAM,eAAe,EAAE,QAAQ,EAmJrC,CAAC"}