@malloy-publisher/server 0.0.235 → 0.0.236

package/src/materialization_metrics.ts

@@ -1,346 +0,0 @@
-/**
- * Centralized telemetry for materialization builds.
- *
- * Operators need to answer "are builds completing, how long do they take, and
- * where are they failing?" without grepping logs. The run counter carries
- * `mode` (`auto`|`orchestrated`) and `outcome` (`success`|`failed`|`cancelled`);
- * the run-duration histogram carries `mode` so a dashboard can render auto-run
- * vs orchestrated build latency side by side.
- *
- * Instruments are created lazily for the same reason as {@link ./query_cap_metrics}:
- * one created before `setGlobalMeterProvider` binds to a NoOp meter
- * (https://github.com/open-telemetry/opentelemetry-js/issues/3505).
- */
-
-import { type Counter, type Histogram } from "@opentelemetry/api";
-import { publisherMeter } from "./telemetry";
-
-export type MaterializationMode = "auto" | "orchestrated";
-export type MaterializationOutcome = "success" | "failed" | "cancelled";
-/** Manifest bind outcome: timeout is split out from generic failure on purpose. */
-export type ManifestBindOutcome = "success" | "failure" | "timeout";
-/**
- * Which engine a source build / table drop ran against: the source's own
- * warehouse (colocated, in-warehouse CTAS) or a DuckDB/DuckLake `storage=`
- * destination (federated passthrough CTAS). The two have very different latency
- * and failure profiles, so build/drop metrics are labeled with it rather than
- * pooling the two into one series.
- */
-export type StorageBuildEngine = "storage" | "in_warehouse";
-/** Why a source was refused materialization into a storage destination. */
-export type EligibilityRefusalReason =
-   | "free_parameter"
-   | "given"
-   | "authorize"
-   | "not_duckdb_portable"
-   | "public_surface_unknown";
-/**
- * How a chained `storage=` source (one that reads a storage-materialized
- * upstream) was built: `parent_reuse` = built by reading the upstream's stored
- * lake table ("stack on the parent" — reuses the parent's work and is
- * consistent-by-construction); `inline_fallback` = stacking was ineligible/failed
- * so the upstream was recomputed from raw against the warehouse (non-strict);
- * `strict_refused` = stacking was ineligible under `strictUpstreams`, so
- * the build failed loudly rather than silently recomputing. This is the headline
- * signal for how far the parent-reuse path gets us in practice.
- */
-export type ChainedStorageBuildOutcome =
-   | "parent_reuse"
-   | "inline_fallback"
-   | "strict_refused"
-   // The parent-reuse attempt failed on infrastructure (attach, CTAS, the
-   // destination being unreachable) rather than on shape. Distinct from
-   // `inline_fallback` because it is an outage, not a modelling limit: the build
-   // fails rather than recomputing from raw against the same destination.
-   | "infra_failure";
-
-const resetHooks: (() => void)[] = [];
-
-/**
- * A lazily-created instrument: built from the global meter on first use (so it
- * binds to the real MeterProvider, not the NoOp default) and memoized. Each
- * registers a reset hook so a test can swap in a fresh MeterProvider.
- */
-function lazyCounter(name: string, description: string): () => Counter {
-   let instrument: Counter | null = null;
-   resetHooks.push(() => (instrument = null));
-   return () =>
-      (instrument ??= publisherMeter().createCounter(name, { description }));
-}
-
-function lazyHistogram(
-   name: string,
-   description: string,
-   unit: string,
-): () => Histogram {
-   let instrument: Histogram | null = null;
-   resetHooks.push(() => (instrument = null));
-   return () =>
-      (instrument ??= publisherMeter().createHistogram(name, {
-         description,
-         unit,
-      }));
-}
-
-const runCounter = lazyCounter(
-   "publisher_materialization_runs_total",
-   "Materialization builds completed. Labels: mode ('auto'|'orchestrated'), outcome ('success'|'failed'|'cancelled').",
-);
-const runDuration = lazyHistogram(
-   "publisher_materialization_run_duration_ms",
-   "Wall-clock duration of a materialization build. Label: mode ('auto'|'orchestrated').",
-   "ms",
-);
-const sourcesCounter = lazyCounter(
-   "publisher_materialization_sources_total",
-   "Persist sources processed by a materialization run. Label: outcome ('built'|'reused').",
-);
-const buildPlanComputeDuration = lazyHistogram(
-   "publisher_materialization_build_plan_compute_duration_ms",
-   "Wall-clock duration of compiling a package's build plan (Package.buildPlan).",
-   "ms",
-);
-const autoLoadCounter = lazyCounter(
-   "publisher_materialization_auto_load_total",
-   "Auto-run manifest auto-load attempts. Label: outcome ('success'|'failure').",
-);
-const connectionDigestSkipCounter = lazyCounter(
-   "publisher_materialization_connection_digest_skipped_total",
-   "Connection digests skipped during build-plan compile because the connection did not resolve.",
-);
-const manifestBindCounter = lazyCounter(
-   "publisher_materialization_manifest_bind_total",
-   "Manifest bind attempts. Label: outcome ('success'|'failure'|'timeout').",
-);
-const manifestBindDegradedCounter = lazyCounter(
-   "publisher_materialization_manifest_bind_degraded_total",
-   "Manifest entries bound with an UNQUOTED table path because their connection " +
-      "could not be resolved (serve-side bind) or is absent from the build " +
-      "(build-side seed). A misconfiguration that breaks the source on a " +
-      "case-folding engine (Snowflake); alertable.",
-);
-const sourceBuildDuration = lazyHistogram(
-   "publisher_materialization_source_build_duration_ms",
-   "Wall-clock duration of building a single persist source.",
-   "ms",
-);
-const dropTablesCounter = lazyCounter(
-   "publisher_materialization_drop_tables_total",
-   "Physical tables dropped on delete. Label: outcome ('success'|'failure').",
-);
-const scheduledFireCounter = lazyCounter(
-   "publisher_materialization_scheduled_fires_total",
-   "Standalone-scheduler attempts to fire a package's materialization.schedule. " +
-      "Label: outcome ('fired'|'conflict'|'error').",
-);
-const storageServeRoutingCounter = lazyCounter(
-   "publisher_storage_serve_routing_total",
-   "storage= serve routing decisions. Label: outcome ('storage'|'live_fallback'|'runtime_live_fallback').",
-);
-const storageBuildFailureCounter = lazyCounter(
-   "publisher_storage_build_failures_total",
-   "storage= build failures (federation/passthrough/attach/CTAS), distinct from " +
-      "in-warehouse build failures. Label: destination (connection name).",
-);
-const eligibilityRefusedCounter = lazyCounter(
-   "publisher_materialization_eligibility_refused_total",
-   "storage= materialization-eligibility refusals. Label: reason " +
-      "('free_parameter'|'given'|'authorize'|'not_duckdb_portable'|" +
-      "'public_surface_unknown').",
-);
-const serveShapeTierDropCounter = lazyCounter(
-   "publisher_storage_serve_shape_tier_drop_total",
-   "storage serve-shape compile escalations: a refinement tier failed to " +
-      "compile and the riskiest category was dropped. Label: tier (the failed " +
-      "tier index, 0=full).",
-);
-const serveShapeTypeFallbackCounter = lazyCounter(
-   "publisher_storage_serve_shape_type_fallback_total",
-   "Captured DuckDB column types mapped to json in the serve shape (type " +
-      "fidelity loss). Label: kind ('array'|'unrecognized').",
-);
-const chainedStorageBuildCounter = lazyCounter(
-   "publisher_storage_chained_build_total",
-   "Chained storage= source builds (a source reading a storage-materialized " +
-      "upstream). Label: outcome ('parent_reuse'|'inline_fallback'|" +
-      "'strict_refused'). The parent_reuse share is the headline signal for how " +
-      "far the stack-on-the-parent path gets us vs recompute-from-raw.",
-);
-
-/**
- * Record a standalone-scheduler fire attempt. `fired` = a SCHEDULER run started;
- * `conflict` = a materialization was already active (this occurrence coalesces
- * into it); `error` = the fire failed unexpectedly.
- */
-export function recordScheduledFire(
-   outcome: "fired" | "conflict" | "error",
-): void {
-   scheduledFireCounter().add(1, { outcome });
-}
-
-/** Record the outcome and duration of a materialization build. */
-export function recordMaterializationRun(
-   mode: MaterializationMode,
-   outcome: MaterializationOutcome,
-   durationMs: number,
-): void {
-   runCounter().add(1, { mode, outcome });
-   runDuration().record(durationMs, { mode });
-}
-
-/**
- * Record how many persist sources a run built vs. reused (carried forward
- * unchanged via skip-if-unchanged). Lets a dashboard show the reuse ratio,
- * the main lever on materialization cost.
- */
-export function recordSourcesOutcome(
-   outcome: "built" | "reused",
-   count: number,
-): void {
-   if (count <= 0) return;
-   sourcesCounter().add(count, { outcome });
-}
-
-/**
- * Record the wall-clock cost of compiling a package's build plan
- * (`Package.buildPlan`). This recompiles models at load, so it is worth
- * tracking as a discrete cost separate from the build itself.
- */
-export function recordBuildPlanComputeDuration(durationMs: number): void {
-   buildPlanComputeDuration().record(durationMs);
-}
-
-/**
- * Record an auto-run manifest auto-load attempt. Auto-load is best-effort (a
- * failure does not fail the run), so a failure here is otherwise invisible:
- * the run is MANIFEST_FILE_READY but queries still resolve to the old tables.
- */
-export function recordAutoLoadOutcome(outcome: "success" | "failure"): void {
-   autoLoadCounter().add(1, { outcome });
-}
-
-/**
- * Record that a connection digest could not be computed during build-plan
- * compilation because the connection failed to resolve. The resulting sourceEntityIds
- * are computed without a digest, so this is a correctness signal, not just noise.
- */
-export function recordConnectionDigestSkipped(): void {
-   connectionDigestSkipCounter().add(1);
-}
-
-/**
- * Record a manifest-bind attempt (publisher binding a configured manifest to a
- * package at load). `timeout` is distinguished from `failure` so operators can
- * tell an unreachable/slow manifest store from a malformed manifest.
- */
-export function recordManifestBind(outcome: ManifestBindOutcome): void {
-   manifestBindCounter().add(1, { outcome });
-}
-
-/**
- * A single manifest entry bound with an unquoted table path because its
- * connection could not be resolved for quoting. Per-entry degradation (the rest
- * of the bind succeeds), distinct from the whole-bind {@link recordManifestBind}
- * outcome — hence its own counter rather than a label on that one.
- */
-export function recordManifestBindDegraded(): void {
-   manifestBindDegradedCounter().add(1);
-}
-
-/**
- * Record the wall-clock duration of building one persist source's table,
- * labeled by engine so the DuckDB passthrough path and the in-warehouse CTAS
- * path (very different latency profiles) don't pool into one series.
- */
-export function recordSourceBuildDuration(
-   durationMs: number,
-   engine: StorageBuildEngine,
-): void {
-   sourceBuildDuration().record(durationMs, { engine });
-}
-
-/** Record a best-effort physical-table drop on materialization delete. */
-export function recordDropTables(
-   outcome: "success" | "failure",
-   engine: StorageBuildEngine,
-): void {
-   dropTablesCounter().add(1, { outcome, engine });
-}
-
-/**
- * Record a `storage=` build failure (federation / passthrough / attach / CTAS),
- * counted separately from in-warehouse build failures because the storage path
- * has its own failure modes and destination axis.
- */
-export function recordStorageBuildFailure(destination: string): void {
-   storageBuildFailureCounter().add(1, { destination });
-}
-
-/**
- * Record a materialization-eligibility refusal (a source that can't be safely
- * materialized into a storage destination). The `given` reason is a security
- * refusal (a frozen given-filtered table would leak rows across tenants); worth
- * tracking how often authors attempt it.
- */
-export function recordEligibilityRefused(
-   reason: EligibilityRefusalReason,
-): void {
-   eligibilityRefusedCounter().add(1, { reason });
-}
-
-/**
- * Record a serve-shape compile escalation: the refinement tier at `failedTier`
- * did not compile, so the riskiest category was dropped and the shape retried.
- * A systematically-dropping source tells authors which refinements aren't
- * servable from storage.
- */
-export function recordServeShapeTierDrop(failedTier: number): void {
-   serveShapeTierDropCounter().add(1, { tier: String(failedTier) });
-}
-
-/**
- * Record a captured DuckDB column type that could not map onto a Malloy basic
- * type and was carried as json in the serve shape — a type-fidelity loss
- * specific to the storage tier. `array` = a collection/array type; `unrecognized`
- * = an unknown/nested/struct/enum/blob type.
- */
-export function recordServeShapeTypeFallback(
-   kind: "array" | "unrecognized",
-): void {
-   serveShapeTypeFallbackCounter().add(1, { kind });
-}
-
-/**
- * Record a `storage=` serve-routing decision: `storage` = the query was served
- * from the materialized table via the virtual-source transform; `live_fallback`
- * = the transform was ineligible for this query (a refinement it can't
- * reproduce, an unbound source, mode not `on`) so it was served live;
- * `runtime_live_fallback` = the query DID route to storage and the store then
- * failed underneath it, and every binding's `freshnessFallback=live` allowed it
- * to degrade. That last one is the operationally interesting label: it means the
- * tier is broken while queries still succeed, which is invisible in the hit rate
- * alone. This hit rate is the headline KPI of the storage tier — otherwise the
- * fallback side is only a DEBUG log.
- */
-export function recordStorageServeRouting(
-   outcome: "storage" | "live_fallback" | "runtime_live_fallback",
-): void {
-   storageServeRoutingCounter().add(1, { outcome });
-}
-
-/**
- * Record how a chained `storage=` source was built (see
- * {@link ChainedStorageBuildOutcome}). Only fired for a source that actually
- * reads a storage-materialized upstream — a single-source build emits nothing
- * here. The parent_reuse : inline_fallback ratio is the spike's key learning.
- */
-export function recordChainedStorageBuild(
-   outcome: ChainedStorageBuildOutcome,
-): void {
-   chainedStorageBuildCounter().add(1, { outcome });
-}
-
-/** Visible for tests. Drops cached instruments so a fresh MeterProvider can capture emissions. */
-export function resetMaterializationTelemetryForTesting(): void {
-   for (const reset of resetHooks) reset();
-}

package/src/mcp/error_messages.spec.ts

@@ -1,35 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { AccessDeniedError } from "../errors";
-import { getMalloyErrorDetails } from "./error_messages";
-
-describe("getMalloyErrorDetails — access-denied branch", () => {
-   it("recognizes an authorize denial and gives access-relevant (not syntax) advice", () => {
-      const details = getMalloyErrorDetails(
-         "executeQuery",
-         "env/pkg/model.malloy",
-         new AccessDeniedError('Access denied for source "gated".'),
-      );
-
-      // Message carries the source name, never the gate expression.
-      expect(details.message).toContain('Access denied for source "gated".');
-
-      // The suggestion is about satisfying access (givens/role), and the
-      // generic Malloy-syntax suggestions are replaced, not appended.
-      expect(details.suggestions).toHaveLength(1);
-      expect(details.suggestions[0]).toMatch(/given|authorize|restricted/i);
-      // Not the generic "check the database connection / consult the language
-      // docs" advice that an unrecognized error would yield.
-      expect(details.suggestions.join(" ")).not.toMatch(
-         /database connection configuration|language documentation/i,
-      );
-   });
-
-   it("still falls back to generic suggestions for an unrecognized error", () => {
-      const details = getMalloyErrorDetails(
-         "executeQuery",
-         "env/pkg/model.malloy",
-         new Error("something unexpected"),
-      );
-      expect(details.suggestions.length).toBeGreaterThan(1);
-   });
-});

package/src/mcp/error_messages.ts

@@ -1,183 +0,0 @@
-export interface ErrorDetails {
-   message: string;
-   suggestions: string[];
-}
-
-/**
- * Generates error details for a resource not found scenario.
- * @param resourceUriOrContext The URI that was not found, or a context string (e.g., "Package 'X'", "Model 'Y' in package 'X'").
- * @returns ErrorDetails object with message and suggestions.
- */
-export function getNotFoundError(resourceUriOrContext: string): ErrorDetails {
-   const baseMessage = `Resource not found: ${resourceUriOrContext}`;
-   const suggestions: string[] = [
-      `Verify the identifier (${resourceUriOrContext}) is spelled correctly and exists. Check capitalization and path separators.`,
-      "Check if the resource exists and is correctly named in your Malloy environment structure or the specific model file.",
-   ];
-
-   return {
-      message: baseMessage,
-      suggestions: suggestions,
-   };
-}
-
-/**
- * Generates generic error details for internal server errors.
- * @param operation The operation that failed (e.g., 'executeQuery').
- * @param error Optional: The underlying error object or message.
- * @returns ErrorDetails object.
- */
-export function getInternalError(
-   operation: string,
-   error?: unknown,
-): ErrorDetails {
-   const baseMessage = `An unexpected internal error occurred during ${operation}.`;
-   const errorMessage = error instanceof Error ? error.message : String(error);
-   return {
-      message: error ? `${baseMessage}: ${errorMessage}` : baseMessage,
-      suggestions: [
-         "Try the request again later.",
-         "If the problem persists, check server logs or contact support.",
-      ],
-   };
-}
-
-/**
- * Generates detailed error information for Malloy compilation or query execution errors.
- * @param operation The operation that failed (e.g., 'executeQuery (load model)', 'executeQuery').
- * @param modelIdentifier A path or URI identifying the model/notebook involved.
- * @param error The underlying Malloy error object or other error.
- * @returns ErrorDetails object.
- */
-export function getMalloyErrorDetails(
-   operation: string,
-   modelIdentifier: string,
-   error: unknown,
-): ErrorDetails {
-   let baseMessage = `Error during ${operation} for resource '${modelIdentifier}'.`;
-   const initialSuggestions: string[] = [
-      `Verify the structure and syntax within the Malloy file: ${modelIdentifier}. Check for typos in source, query, or view names (e.g., 'source: my_source is ...', 'query: my_query is ...', 'view: my_view is { ... }'). See Model Structure: https://docs.malloydata.dev/documentation/language/statement`,
-      "Ensure all referenced sources, queries, or views are correctly defined within the model or imported files using expected keywords (e.g., 'source:', 'query:', 'view:'). See Sources: https://docs.malloydata.dev/documentation/language/source",
-      "Check the database connection configuration used by the model, if applicable.",
-      "Consult the Malloy language documentation for syntax rules: https://docs.malloydata.dev/documentation/",
-   ];
-
-   let suggestions: string[] = [...initialSuggestions]; // Clone initial suggestions
-   let refined = false; // Flag to track if specific suggestions were added
-
-   // Attempt to extract more specific info if it's a MalloyError or similar
-   if (error instanceof Error) {
-      // Prepend the specific error message
-      baseMessage = `Error during ${operation} for resource '${modelIdentifier}': ${error.message}`;
-
-      // --- Add more specific suggestions based on common Malloy error patterns ---
-      // Note: Order matters, check for more specific patterns first.
-
-      const viewNotFoundMatch = error.message.match(
-         /View '([^']+)' not found in source '([^']+)'/i,
-      );
-      const sourceNotFoundMatch = error.message.match(
-         /Source '([^']+)' not found/i,
-      );
-      const queryNotFoundMatch = error.message.match(
-         /Query '([^']+)' not found/i,
-      );
-      const referenceErrorMatch = error.message.match(
-         /Reference to undefined object(?: '([^']+)')?/i,
-      );
-      const syntaxErrorMatch = error.message.match(
-         /no viable alternative at input/i,
-      );
-      const connectionErrorMatch = error.message.match(
-         /Cannot connect to database/i,
-      );
-      const fieldNotFoundMatch = error.message.match(
-         /Field '([^']+)' not found in (source|query|view) '([^']+)'/i,
-      );
-      const invalidRequestMatch = error.message.match(
-         /Invalid query request\\. Query OR queryName must be defined/i,
-      );
-      // `#(authorize)` gate denial. The message names only the source (gate
-      // logic is never leaked), so the suggestion is about satisfying access,
-      // not fixing syntax — otherwise this falls through to generic Malloy
-      // syntax advice that misleads the caller.
-      const accessDeniedMatch = error.message.match(
-         /Access denied for source "([^"]+)"/i,
-      );
-
-      if (accessDeniedMatch) {
-         refined = true;
-         const [, sourceName] = accessDeniedMatch;
-         suggestions = [
-            `Suggestion: Access to source '${sourceName}' is restricted by an #(authorize) gate. Supply the givens its authorize expression requires (e.g. a role/region given) and retry. This is an authorization denial, not a syntax error.`,
-         ];
-      } else if (viewNotFoundMatch) {
-         refined = true;
-         const [, viewName, sourceName] = viewNotFoundMatch;
-         suggestions.unshift(
-            `Suggestion: View '${viewName}' was not found in source '${sourceName}'. Check the view name spelling or call malloy_getContext with sourceName '${sourceName}' to see the list of available views. Views are defined within sources like 'source: ${sourceName} is ... extend { view: ${viewName} is { ... } }'.`,
-         );
-      } else if (sourceNotFoundMatch) {
-         refined = true;
-         const [, sourceName] = sourceNotFoundMatch;
-         suggestions.unshift(
-            `Suggestion: Source '${sourceName}' was not found or could not be accessed. Verify its definition (e.g., \`source: ${sourceName} is table('...')\` or \`duckdb.sql("...")\`) and ensure any associated connections are valid.`,
-            `Suggestion: Check the spelling of '${sourceName}'. You can list the sources in the package using malloy_getContext.`,
-         );
-      } else if (queryNotFoundMatch) {
-         refined = true;
-         const [, queryName] = queryNotFoundMatch;
-         suggestions.unshift(
-            `Suggestion: Named query '${queryName}' was not found. Verify its definition (e.g., \`query: ${queryName} is source_name -> { ... }\`) within the model '${modelIdentifier}'.`,
-            `Suggestion: Check the spelling of '${queryName}'. Ensure it's a named query (defined with \`query:\`), not a view. You can list named queries using malloy_getContext.`,
-         );
-      } else if (fieldNotFoundMatch) {
-         refined = true;
-         const [, fieldName, fieldContextType, fieldContextName] =
-            fieldNotFoundMatch;
-         suggestions.unshift(
-            `Suggestion: Field '${fieldName}' was not found in ${fieldContextType} '${fieldContextName}'. Check the spelling of the field name within the definition of '${fieldContextName}'.`,
-            `Suggestion: Ensure the field is defined directly or inherited correctly in the '${fieldContextName}' ${fieldContextType}. You can inspect the ${fieldContextType}'s fields using malloy_getContext.`,
-         );
-      } else if (referenceErrorMatch) {
-         refined = true;
-         const objectName = referenceErrorMatch[1] || "[unknown object]";
-         suggestions.unshift(
-            `Suggestion: Check if the referenced object '${objectName}' (source, query, view, field, dimension, measure) is defined correctly and spelled correctly (e.g., 'source: my_source is ...', 'query: my_query is ...'). Ensure it's defined *before* being used in the model file.`,
-         );
-      } else if (syntaxErrorMatch) {
-         refined = true;
-         suggestions.unshift(
-            "Suggestion: There seems to be a syntax error near the location indicated in the error message. Check for misplaced/missing keywords (like 'is', '->', 'extend', 'where', 'aggregate', 'group_by', 'nest'), commas, brackets '{ }', or parentheses '( )'. See Query Syntax: https://docs.malloydata.dev/documentation/language/query",
-         );
-      } else if (connectionErrorMatch) {
-         refined = true;
-         suggestions.unshift(
-            "Suggestion: Verify the database connection details (credentials, host, database name, connection name in Malloy) associated with this model.",
-         );
-         suggestions.push(
-            "Ensure the database server is running and accessible from the publisher server.",
-         );
-      } else if (invalidRequestMatch) {
-         refined = true;
-         suggestions.unshift(
-            "Suggestion: This error can occur when specifying a view using 'sourceName' and 'queryName'. Try providing the full query string directly in the 'query' parameter instead (e.g., 'query': 'run: your_source_name->your_view_name').",
-            "Suggestion: Also verify you are providing either the 'query' parameter OR the correct combination of 'queryName' (and optionally 'sourceName' for views).",
-         );
-      }
-
-      // If no specific pattern matched, keep the initial suggestions
-      if (!refined) {
-         suggestions = initialSuggestions;
-      }
-   } else {
-      // Generic message if it's not a standard Error object
-      baseMessage += `: ${String(error)}`;
-      suggestions = initialSuggestions; // Use initial for non-errors too
-   }
-
-   return {
-      message: baseMessage,
-      suggestions: suggestions,
-   };
-}

package/src/mcp/handler_utils.spec.ts

@@ -1,108 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { MalloyError } from "@malloydata/malloy";
-import { classifyToolError } from "./handler_utils";
-import {
-   AccessDeniedError,
-   BadRequestError,
-   ModelCompilationError,
-   PackageNotFoundError,
-   ServiceUnavailableError,
-} from "../errors";
-
-/**
- * classifyToolError decides what an agent is told to do about a failure, so
- * every branch is pinned by the advice it produces, not just by "an error came
- * back". Asserting only that an error exists is what let every class funnel
- * through the Malloy helper unnoticed.
- *
- * The routing is by error CLASS on purpose. getMalloyErrorDetails refines on
- * message patterns the shipped engine does not emit, so "did it refine?" would
- * send real compile errors to the internal branch.
- */
-describe("classifyToolError", () => {
-   const advice = (e: unknown) =>
-      JSON.stringify(classifyToolError("op", "env/pkg", e).suggestions);
-
-   it("homes a missing package as not-found, not as Malloy", () => {
-      const details = classifyToolError(
-         "op",
-         "env/pkg",
-         new PackageNotFoundError("Package 'nope' not found"),
-      );
-      expect(details.message).toContain("Resource not found");
-      expect(JSON.stringify(details.suggestions)).not.toContain("Malloy file");
-   });
-
-   it("homes back-pressure as retryable, not as Malloy", () => {
-      const details = classifyToolError(
-         "op",
-         "env/pkg",
-         new ServiceUnavailableError("Memory limit reached"),
-      );
-      expect(details.message).toContain("Memory limit reached");
-      expect(JSON.stringify(details.suggestions)).toContain("Retry");
-      expect(JSON.stringify(details.suggestions)).not.toContain("Malloy file");
-   });
-
-   it("keeps Malloy advice for a raw engine error", () => {
-      // The regression guard for executeQuery. A bad query throws MalloyError,
-      // NOT ModelCompilationError: the engine's error reaches the tool's catch
-      // unwrapped. Route it by the internal branch and a syntax error tells the
-      // agent an "unexpected internal error occurred", which is worse than the
-      // bug this classifier was written to fix.
-      const details = classifyToolError(
-         "executeQuery",
-         "env/pkg/m.malloy",
-         new MalloyError("unexpected '@'", []),
-      );
-      expect(details.message).not.toContain("unexpected internal error");
-      expect(advice(new MalloyError("unexpected '@'", []))).toContain("Malloy");
-   });
-
-   it("keeps Malloy advice for a wrapped compile error", () => {
-      // What a failed reload throws. #890's promise is that a failed reload
-      // returns the compile errors, so this must not read as an internal fault.
-      const details = classifyToolError(
-         "reloadPackage",
-         "env/pkg",
-         new ModelCompilationError({
-            message: "Error(s) compiling model: unexpected '@'",
-         }),
-      );
-      expect(details.message).not.toContain("unexpected internal error");
-   });
-
-   it("keeps Malloy advice for an authorize denial and a malformed request", () => {
-      expect(
-         classifyToolError(
-            "op",
-            "env/pkg",
-            new AccessDeniedError('Access denied for source "orders"'),
-         ).message,
-      ).not.toContain("unexpected internal error");
-      expect(
-         classifyToolError(
-            "op",
-            "env/pkg",
-            new BadRequestError("Invalid query request."),
-         ).message,
-      ).not.toContain("unexpected internal error");
-   });
-
-   it("reports anything else as internal rather than blaming the Malloy", () => {
-      // A bug in our own code, a filesystem failure, or a worker crash. Telling
-      // the agent to check its syntax sends it to edit a model that is fine.
-      for (const error of [
-         new TypeError("cannot read properties of undefined"),
-         Object.assign(new Error("EACCES: permission denied"), {
-            code: "EACCES",
-         }),
-      ]) {
-         const details = classifyToolError("op", "env/pkg", error);
-         expect(details.message).toContain("unexpected internal error");
-         expect(JSON.stringify(details.suggestions)).not.toContain(
-            "Malloy file",
-         );
-      }
-   });
-});