@adia-ai/a2ui-mcp 0.6.4 → 0.6.6

package/tools/synthesis.js

@@ -1,51 +1,35 @@
-/**
- * Synthesis tools — chunk-based composition + multi-turn refinement.
- *
- * Extracts the 4 tools that share the LLM bridge + state-cache +
- * issue-reporter + chunk-refiner stack: `compose_from_chunks`,
- * `refine_composition`, `get_state`, `report_issue`.
- *
- * Spec: docs/specs/genui-multiturn-architecture.md (Phase A).
- */
-
-import { z } from 'zod';
-
-import { composeFromIntent as composeFromChunksImpl } from '../../compose/strategies/zettel/chunk-synthesizer.js';
-import { composeFromPlan, validatePlan } from '../../compose/strategies/zettel/chunk-composer.js';
-import { createAdapter as createLLMAdapter } from '../../../llm/llm-bridge.js';
+import { z } from "zod";
+import { composeFromIntent as composeFromChunksImpl } from "../../compose/strategies/zettel/chunk-synthesizer.js";
+import { composeFromPlan, validatePlan } from "../../compose/strategies/zettel/chunk-composer.js";
+import { createAdapter as createLLMAdapter } from "../../../llm/llm-bridge.js";
 import {
   getStateCache,
   mintStateId,
-  mintNextStateId,
-} from '../../compose/strategies/zettel/state-cache.js';
+  mintNextStateId
+} from "../../compose/strategies/zettel/state-cache.js";
 import {
   reportIssue as reportIssueImpl,
   autoReport,
-  createIssueAccumulator,
-} from '../../compose/strategies/zettel/issue-reporter.js';
+  createIssueAccumulator
+} from "../../compose/strategies/zettel/issue-reporter.js";
 import {
   refineFromIntent,
   applyOps,
   opsToA2UI,
-  validateOps,
-} from '../../compose/strategies/zettel/chunk-refiner.js';
-
+  validateOps
+} from "../../compose/strategies/zettel/chunk-refiner.js";
 const stateCache = getStateCache();
-
 const ENGINE_VERSION_INFO = {
-  mcp: '0.2.0',
-  corpus: '0.2.0',
-  engine: 'zettel',
-  llm_adapter: 'anthropic',
-  model: process.env.ANTHROPIC_MODEL || 'claude-opus-4-7',
+  mcp: "0.2.0",
+  corpus: "0.2.0",
+  engine: "zettel",
+  llm_adapter: "anthropic",
+  model: typeof process !== "undefined" && process.env["ANTHROPIC_MODEL"] || "claude-opus-4-7"
 };
-
-export { stateCache, ENGINE_VERSION_INFO, autoReport, reportIssueImpl };
-
-export function registerSynthesisTools(server) {
+function registerSynthesisTools(server) {
   server.tool(
-    'compose_from_chunks',
-    `Compose a UI page from training chunks — retrieval-first, synthesis-fallback.
+    "compose_from_chunks",
+    `Compose a UI page from training chunks \u2014 retrieval-first, synthesis-fallback.
 
 Mix-and-match composition for intents that don't have a 1:1 chunk match. Workflow:
   1. Pure-retrieval tier: if \`search_chunks\` returns a strong direct match, return
@@ -56,18 +40,18 @@ Mix-and-match composition for intents that don't have a 1:1 chunk match. Workflo
 
 Returns the composed HTML string + a binding plan describing which chunks plug
 where. Useful when the prompt is novel ("dashboard with KPI grid + funnel +
-country list") and no exact chunk has all those parts together — the LLM mixes
+country list") and no exact chunk has all those parts together \u2014 the LLM mixes
 and matches from the corpus.
 
-Two-call mode also available via \`plan\` parameter — pass a pre-baked binding
+Two-call mode also available via \`plan\` parameter \u2014 pass a pre-baked binding
 plan to skip the LLM call and just materialize HTML.`,
     {
-      intent: z.string().optional().describe('Natural-language description of what to build (uses LLM synthesis)'),
+      intent: z.string().optional().describe("Natural-language description of what to build (uses LLM synthesis)"),
       plan: z.object({
         page: z.string(),
-        slot_bindings: z.record(z.union([z.string(), z.array(z.string())])),
-      }).optional().describe('Pre-baked binding plan (skips LLM, materializes directly)'),
-      max_attempts: z.number().int().min(1).max(5).default(2).describe('LLM retry budget for synthesis'),
+        slot_bindings: z.record(z.union([z.string(), z.array(z.string())]))
+      }).optional().describe("Pre-baked binding plan (skips LLM, materializes directly)"),
+      max_attempts: z.number().int().min(1).max(5).default(2).describe("LLM retry budget for synthesis")
     },
     async ({ intent, plan, max_attempts }) => {
       if (plan) {
@@ -75,45 +59,43 @@ plan to skip the LLM call and just materialize HTML.`,
         if (!validation.ok) {
           return {
             isError: true,
-            content: [{ type: 'text', text: JSON.stringify({ error: 'invalid plan', errors: validation.errors }, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify({ error: "invalid plan", errors: validation.errors }, null, 2) }]
           };
         }
         const result = composeFromPlan(plan);
-        const state_id = mintStateId(intent || plan.page || 'plan', 1);
+        const state_id = mintStateId(intent ?? plan.page ?? "plan", 1);
         stateCache.set(state_id, {
           state_id,
-          intent: intent || `(plan) ${plan.page}`,
+          intent: intent ?? `(plan) ${plan.page}`,
           plan: result.plan,
           html: result.html,
-          source: 'plan',
+          source: "plan",
           ops_history: [],
           parent_state_id: null,
-          created_at: new Date().toISOString(),
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
         });
         return {
-          content: [{ type: 'text', text: JSON.stringify({
+          content: [{ type: "text", text: JSON.stringify({
             state_id,
             html: result.html,
             plan: result.plan,
             warnings: result.warnings,
-            source: 'plan',
-          }, null, 2) }],
+            source: "plan"
+          }, null, 2) }]
         };
       }
-
       if (!intent) {
         return {
           isError: true,
-          content: [{ type: 'text', text: JSON.stringify({ error: 'must provide either intent or plan' }, null, 2) }],
+          content: [{ type: "text", text: JSON.stringify({ error: "must provide either intent or plan" }, null, 2) }]
         };
       }
-
       try {
         const llmAdapter = await createLLMAdapter();
         const result = await composeFromChunksImpl({
           intent,
           llmAdapter,
-          maxAttempts: max_attempts,
+          maxAttempts: max_attempts
         });
         const state_id = mintStateId(intent, 1);
         stateCache.set(state_id, {
@@ -128,29 +110,23 @@ plan to skip the LLM call and just materialize HTML.`,
           warnings: result.warnings,
           synthesis: result.synthesis,
           scopeDrift: result.scopeDrift,
-          created_at: new Date().toISOString(),
+          created_at: (/* @__PURE__ */ new Date()).toISOString()
         });
-
-        // Scope-drift auto-fire: composed HTML envelope exceeded the bound-
-        // chunk envelope by > SCOPE_DRIFT_RATIO. Fires a `scope-drift` issue
-        // (writes both .json and high-res .md) so post-mortem review can
-        // catch the canvas-drift regression class without manual reporting.
         if (result.scopeDrift?.drift) {
           await autoReport(
-            'scope-drift',
+            "scope-drift",
             {
               intent,
               state_id,
               scopeDrift: result.scopeDrift,
-              tags: ['canvas-drift'],
-              trace: 'full',
+              tags: ["canvas-drift"],
+              trace: "full"
             },
             { cache: stateCache, versionInfo: ENGINE_VERSION_INFO }
           );
         }
-
         return {
-          content: [{ type: 'text', text: JSON.stringify({
+          content: [{ type: "text", text: JSON.stringify({
             state_id,
             html: result.html,
             plan: result.plan,
@@ -158,180 +134,165 @@ plan to skip the LLM call and just materialize HTML.`,
             score: result.score,
             warnings: result.warnings,
             scopeDrift: result.scopeDrift,
-            synthesis: result.synthesis ? { attempts: result.synthesis.attempts } : undefined,
-          }, null, 2) }],
+            synthesis: result.synthesis ? { attempts: result.synthesis.attempts } : void 0
+          }, null, 2) }]
         };
       } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
         return {
           isError: true,
-          content: [{ type: 'text', text: JSON.stringify({ error: e.message }, null, 2) }],
+          content: [{ type: "text", text: JSON.stringify({ error: err.message }, null, 2) }]
         };
       }
-    },
+    }
   );
-
-  // ── Multi-turn refinement (Phase A) ─────────────────────────────────
-  // Spec: docs/specs/genui-multiturn-architecture.md §3.
-
   server.tool(
-    'refine_composition',
+    "refine_composition",
     `Refine an existing chunk-composed UI based on a natural-language intent or an explicit op-list.
 
 Use when the user wants to modify an *existing* UI. Triggers on "change", "update", "modify", "add to", "remove from", "this", "it", "the X". Requires \`state_id\` from a prior \`compose_from_chunks\` call.
 
 Two modes:
-  - **Intent-driven** — pass \`intent\`. Engine runs two-pass synthesis (locator pass identifies which slots to modify; modifier pass emits chunk-plan ops). Validator-driven retry on op-validation failure.
-  - **Explicit ops** — pass \`ops\` directly. Skips the LLM entirely; engine applies + materializes.
+  - **Intent-driven** \u2014 pass \`intent\`. Engine runs two-pass synthesis (locator pass identifies which slots to modify; modifier pass emits chunk-plan ops). Validator-driven retry on op-validation failure.
+  - **Explicit ops** \u2014 pass \`ops\` directly. Skips the LLM entirely; engine applies + materializes.
 
 Returns a new \`state_id\` (versioned chain from the parent), the A2UI op-list applied, the post-op HTML, and a delta summary. Failed ops are reported in \`ops_failed\` with reasons.
 
 For *fresh creation* use \`compose_from_chunks\`, not this tool.`,
     {
-      state_id: z.string().describe('State id from a prior compose_from_chunks or refine_composition call'),
+      state_id: z.string().describe("State id from a prior compose_from_chunks or refine_composition call"),
       intent: z.string().optional().describe('Natural-language description of what to change (e.g. "add a country list to page-content")'),
-      ops: z.array(z.any()).optional().describe('Pre-computed chunk-plan ops to apply directly (skips the LLM)'),
-      max_attempts: z.number().int().min(1).max(5).default(2).describe('Validator retry budget for synthesis'),
+      ops: z.array(z.any()).optional().describe("Pre-computed chunk-plan ops to apply directly (skips the LLM)"),
+      max_attempts: z.number().int().min(1).max(5).default(2).describe("Validator retry budget for synthesis")
     },
     async ({ state_id, intent, ops, max_attempts }) => {
       const priorState = stateCache.get(state_id);
       if (!priorState) {
         await autoReport(
-          'cache-miss-on-known-state',
-          { state_id, tool: 'refine_composition' },
+          "cache-miss-on-known-state",
+          { state_id, tool: "refine_composition" },
           { cache: stateCache, versionInfo: ENGINE_VERSION_INFO }
         );
         return {
           isError: true,
-          content: [{ type: 'text', text: JSON.stringify({
-            error: 'state_id not found in cache',
-            hint: 'state cache is in-memory and bounded; re-run compose_from_chunks to mint a fresh state_id',
-            state_id,
-          }, null, 2) }],
+          content: [{ type: "text", text: JSON.stringify({
+            error: "state_id not found in cache",
+            hint: "state cache is in-memory and bounded; re-run compose_from_chunks to mint a fresh state_id",
+            state_id
+          }, null, 2) }]
         };
       }
-
       if (!intent && !ops) {
         return {
           isError: true,
-          content: [{ type: 'text', text: JSON.stringify({ error: 'must provide either intent or ops' }, null, 2) }],
+          content: [{ type: "text", text: JSON.stringify({ error: "must provide either intent or ops" }, null, 2) }]
         };
       }
-
       const issueAccumulator = createIssueAccumulator();
       const issueCtx = { cache: stateCache, versionInfo: ENGINE_VERSION_INFO };
       const startedAt = Date.now();
-
       try {
         let resolvedOps;
-        let delta_summary = '';
+        let delta_summary = "";
         let synthesis = null;
         let warnings = [];
-
         if (ops && Array.isArray(ops)) {
-          // Explicit ops path — validate then apply
           const validation = validateOps(ops, priorState);
           if (!validation.ok) {
             await issueAccumulator.flush(issueCtx);
             return {
               isError: true,
-              content: [{ type: 'text', text: JSON.stringify({
-                error: 'ops failed validation',
-                errors: validation.errors,
-              }, null, 2) }],
+              content: [{ type: "text", text: JSON.stringify({
+                error: "ops failed validation",
+                errors: validation.errors
+              }, null, 2) }]
             };
           }
           resolvedOps = ops;
           delta_summary = `applied ${ops.length} explicit op(s)`;
         } else {
-          // Intent path — two-pass synthesis with stub-friendly LLM bridge
           const llmAdapter = await createLLMAdapter();
           const refined = await refineFromIntent({
             priorState,
             intent,
             llmAdapter,
             maxAttempts: max_attempts,
-            issueAccumulator,
+            issueAccumulator
           });
           resolvedOps = refined.ops;
-          delta_summary = refined.delta_summary || '';
+          delta_summary = refined.delta_summary ?? "";
           synthesis = refined.synthesis;
           warnings = refined.warnings;
-
           if (resolvedOps.length === 0) {
-            // Synthesizer gave up. Auto-fires already accumulated.
             await issueAccumulator.flush(issueCtx);
-            const childId = mintNextStateId(state_id, (priorState.version || 1) + 1);
+            const childId = mintNextStateId(state_id, (priorState["version"] ?? 1) + 1);
+            const synthInfo2 = synthesis;
             return {
-              content: [{ type: 'text', text: JSON.stringify({
+              content: [{ type: "text", text: JSON.stringify({
                 state_id: childId,
                 ops_applied: [],
                 ops_failed: [],
-                delta_summary: '',
+                delta_summary: "",
                 warnings,
-                synthesis: synthesis ? { attempts: synthesis.attempts, targeted: synthesis.targeted } : null,
-                html: priorState.html,
-              }, null, 2) }],
+                synthesis: synthInfo2 ? { attempts: synthInfo2["attempts"], targeted: synthInfo2["targeted"] } : null,
+                html: priorState["html"]
+              }, null, 2) }]
             };
           }
         }
-
         const applied = await applyOps({ priorState, ops: resolvedOps });
-
         if (applied.ops_failed.length > 0) {
-          issueAccumulator.add('ops-failed-after-apply', {
+          issueAccumulator.add("ops-failed-after-apply", {
             state_id,
-            tool: 'refine_composition',
-            intent,
+            tool: "refine_composition",
+            intent
           });
         }
-
         const a2uiMessages = opsToA2UI(applied.ops_applied, applied.newState);
-
-        const parentVersion = priorState.version || 1;
+        const parentVersion = priorState["version"] ?? 1;
         const newVersion = parentVersion + 1;
         const newStateId = mintNextStateId(state_id, newVersion);
-
         stateCache.set(newStateId, {
           state_id: newStateId,
-          intent: intent || `(ops) ${priorState.intent}`,
-          plan: applied.newState.plan,
-          html: applied.newState.html,
-          source: 'refinement',
+          intent: intent ?? `(ops) ${priorState["intent"] ?? ""}`,
+          plan: applied.newState["plan"],
+          html: applied.newState["html"],
+          source: "refinement",
           version: newVersion,
-          ops_history: [...(priorState.ops_history || []), ...a2uiMessages],
+          ops_history: [...priorState["ops_history"] ?? [], ...a2uiMessages],
           parent_state_id: state_id,
-          warnings: applied.newState.warnings,
+          warnings: applied.newState["warnings"],
           delta_summary,
           synthesis,
-          created_at: new Date().toISOString(),
-          duration_ms: Date.now() - startedAt,
+          created_at: (/* @__PURE__ */ new Date()).toISOString(),
+          duration_ms: Date.now() - startedAt
         });
-
         await issueAccumulator.flush(issueCtx);
-
+        const synthInfo = synthesis;
+        const newStateWarnings = applied.newState["warnings"] ?? [];
         return {
-          content: [{ type: 'text', text: JSON.stringify({
+          content: [{ type: "text", text: JSON.stringify({
             state_id: newStateId,
             ops_applied: a2uiMessages,
             ops_failed: applied.ops_failed,
             delta_summary,
-            warnings: [...warnings, ...(applied.newState.warnings || [])],
-            synthesis: synthesis ? { attempts: synthesis.attempts, targeted: synthesis.targeted, locatedTargets: synthesis.locatedTargets } : null,
-            html: applied.newState.html,
-          }, null, 2) }],
+            warnings: [...warnings, ...newStateWarnings],
+            synthesis: synthInfo ? { attempts: synthInfo["attempts"], targeted: synthInfo["targeted"], locatedTargets: synthInfo["locatedTargets"] } : null,
+            html: applied.newState["html"]
+          }, null, 2) }]
         };
       } catch (e) {
         await issueAccumulator.flush(issueCtx);
+        const err = e instanceof Error ? e : new Error(String(e));
         return {
           isError: true,
-          content: [{ type: 'text', text: JSON.stringify({ error: e.message }, null, 2) }],
+          content: [{ type: "text", text: JSON.stringify({ error: err.message }, null, 2) }]
         };
       }
-    },
+    }
   );
-
   server.tool(
-    'get_state',
+    "get_state",
     `Inspect a cached composition state by state_id.
 
 Returns the full cache entry including the materialized HTML, the chunk binding plan, the chronological ops history (every refinement applied to this state's lineage), and the parent state_id (chain-back to the originating compose_from_chunks call).
@@ -340,51 +301,51 @@ Useful for debugging refinement sequences, replaying a state's history, or verif
 
 Auto-fires a low-severity \`cache-miss-on-known-state\` issue when the state_id is not in the cache (the cache is bounded LRU; long-paused conversations may evict their state).`,
     {
-      state_id: z.string().describe('State id from a prior compose_from_chunks or refine_composition call'),
+      state_id: z.string().describe("State id from a prior compose_from_chunks or refine_composition call")
     },
     async ({ state_id }) => {
       const entry = stateCache.peek(state_id);
       if (!entry) {
         await autoReport(
-          'cache-miss-on-known-state',
-          { state_id, tool: 'get_state' },
+          "cache-miss-on-known-state",
+          { state_id, tool: "get_state" },
           { cache: stateCache, versionInfo: ENGINE_VERSION_INFO }
         );
         return {
           isError: true,
-          content: [{ type: 'text', text: JSON.stringify({
-            error: 'state_id not found in cache',
-            state_id,
-          }, null, 2) }],
+          content: [{ type: "text", text: JSON.stringify({
+            error: "state_id not found in cache",
+            state_id
+          }, null, 2) }]
         };
       }
+      const e = entry;
       return {
-        content: [{ type: 'text', text: JSON.stringify({
-          state_id: entry.state_id,
-          intent: entry.intent,
-          plan: entry.plan,
-          html: entry.html,
-          source: entry.source,
-          version: entry.version || 1,
-          parent_state_id: entry.parent_state_id || null,
-          ops_history: entry.ops_history || [],
-          warnings: entry.warnings || [],
-          created_at: entry.created_at,
-        }, null, 2) }],
+        content: [{ type: "text", text: JSON.stringify({
+          state_id: e["state_id"],
+          intent: e["intent"],
+          plan: e["plan"],
+          html: e["html"],
+          source: e["source"],
+          version: e["version"] ?? 1,
+          parent_state_id: e["parent_state_id"] ?? null,
+          ops_history: e["ops_history"] ?? [],
+          warnings: e["warnings"] ?? [],
+          created_at: e["created_at"]
+        }, null, 2) }]
       };
-    },
+    }
   );
-
   server.tool(
-    'report_issue',
-    `File a structured issue ticket — writes BOTH a machine-readable JSON file AND a human-readable Markdown report containing the full session trace (intent, retrieval log, LLM prompts, every attempt's raw response, composer plan, generated HTML preview, component count, warnings, environment).
+    "report_issue",
+    `File a structured issue ticket \u2014 writes BOTH a machine-readable JSON file AND a human-readable Markdown report containing the full session trace (intent, retrieval log, LLM prompts, every attempt's raw response, composer plan, generated HTML preview, component count, warnings, environment).
 
 When to call (any of these is a trigger):
-  (a) USER PHRASES — call immediately when the user says any of:
+  (a) USER PHRASES \u2014 call immediately when the user says any of:
       "file a ticket", "log a ticket", "save a ticket",
       "report this as a bug", "report this issue", "log this issue",
       "save the trace", "capture the session", "save the session for review",
-      "create a session ticket", "this is broken — debug it",
+      "create a session ticket", "this is broken \u2014 debug it",
       "download the trace", "export this for review",
       "track this regression", "open a ticket for this".
   (b) USER COMPLAINS the output is broken / wrong / missing.
@@ -397,20 +358,20 @@ Do NOT call this for ordinary clarification or for output the user has not yet s
 
 The tool returns BOTH paths in its response: \`path\` (.json) and \`markdown_path\` (.md). Surface BOTH to the user so they can navigate / download either:
 
-  📋 Logged ticket \`{issue_id}\` (\`{severity}\` · owner: {suggested_owner})
-  • Trace report: \`{markdown_path}\` ← human-readable, scan this first
-  • Raw JSON:     \`{path}\`           ← machine-readable
+  \u{1F4CB} Logged ticket \`{issue_id}\` (\`{severity}\` \xB7 owner: {suggested_owner})
+  \u2022 Trace report: \`{markdown_path}\` \u2190 human-readable, scan this first
+  \u2022 Raw JSON:     \`{path}\`           \u2190 machine-readable
 
 Issue files land under \`.brain/audit-history/issues/\` (immutable; resolution lands in a sidecar file). Severity taxonomy matches the project's ui-audit-coherence vocabulary: blocker = contract violation; drift = quality erosion; nit = cosmetic.`,
     {
-      type: z.enum(['bug', 'training-gap', 'protocol-gap', 'ux-feedback']).describe('Issue category'),
-      severity: z.enum(['blocker', 'drift', 'nit']).describe('Severity tier'),
-      title: z.string().max(80).describe('One-line title (≤ 80 chars)'),
-      body: z.string().describe('Markdown body — observed vs expected, repro steps'),
-      state_id: z.string().optional().describe('State id from a prior tool call; auto-attaches the trace'),
-      trace: z.enum(['full', 'summary', 'none']).optional().describe('Trace depth — DEFAULT: "full" when state_id is provided (writes both .json + .md ticket with retrieval log, LLM prompts/attempts, plan, HTML preview). Use "summary" for compact tickets; "none" to suppress trace entirely.'),
-      suggested_owner: z.enum(['synthesis', 'retrieval', 'validator', 'chunk-corpus', 'mcp-protocol', 'unknown']).optional().describe('Best-guess owner for triage'),
-      tags: z.array(z.string()).optional().describe('Free-form tags for filtering'),
+      type: z.enum(["bug", "training-gap", "protocol-gap", "ux-feedback"]).describe("Issue category"),
+      severity: z.enum(["blocker", "drift", "nit"]).describe("Severity tier"),
+      title: z.string().max(80).describe("One-line title (\u2264 80 chars)"),
+      body: z.string().describe("Markdown body \u2014 observed vs expected, repro steps"),
+      state_id: z.string().optional().describe("State id from a prior tool call; auto-attaches the trace"),
+      trace: z.enum(["full", "summary", "none"]).optional().describe('Trace depth \u2014 DEFAULT: "full" when state_id is provided (writes both .json + .md ticket with retrieval log, LLM prompts/attempts, plan, HTML preview). Use "summary" for compact tickets; "none" to suppress trace entirely.'),
+      suggested_owner: z.enum(["synthesis", "retrieval", "validator", "chunk-corpus", "mcp-protocol", "unknown"]).optional().describe("Best-guess owner for triage"),
+      tags: z.array(z.string()).optional().describe("Free-form tags for filtering")
     },
     async ({ type, severity, title, body, state_id, trace, suggested_owner, tags }) => {
       try {
@@ -419,18 +380,26 @@ Issue files land under \`.brain/audit-history/issues/\` (immutable; resolution l
           {
             cache: stateCache,
             versionInfo: ENGINE_VERSION_INFO,
-            reporter: 'llm',
+            reporter: "llm"
           }
         );
         return {
-          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
         };
       } catch (e) {
+        const err = e instanceof Error ? e : new Error(String(e));
         return {
           isError: true,
-          content: [{ type: 'text', text: JSON.stringify({ error: e.message }, null, 2) }],
+          content: [{ type: "text", text: JSON.stringify({ error: err.message }, null, 2) }]
         };
       }
-    },
+    }
   );
 }
+export {
+  ENGINE_VERSION_INFO,
+  autoReport,
+  registerSynthesisTools,
+  reportIssueImpl,
+  stateCache
+};