@smartbear/mcp 0.8.0 → 0.9.0

package/dist/bugsnag/client.js

@@ -1,9 +1,9 @@
 import NodeCache from "node-cache";
 import { z } from "zod";
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.js";
-import { FilterObjectSchema, toQueryString, } from "./client/api/filters.js";
-import { ProjectAPI, } from "./client/api/Project.js";
-import { Configuration, CurrentUserAPI, ErrorAPI } from "./client/index.js";
+import { ToolError, } from "../common/types.js";
+import { Configuration, CurrentUserAPI, ErrorAPI, ProjectAPI, } from "./client/api/index.js";
+import { FilterObjectSchema, toUrlSearchParams, } from "./client/filters.js";
 const HUB_PREFIX = "00000";
 const DEFAULT_DOMAIN = "bugsnag.com";
 const HUB_DOMAIN = "bugsnag.smartbear.com";
@@ -39,7 +39,7 @@ export class BugsnagClient {
         this.apiEndpoint = this.getEndpoint("api", projectApiKey, endpoint);
         this.appEndpoint = this.getEndpoint("app", projectApiKey, endpoint);
         const config = new Configuration({
-            authToken: token,
+            apiKey: `token ${token}`,
             headers: {
                 "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
                 "Content-Type": "application/json",
@@ -121,15 +121,15 @@ export class BugsnagClient {
     async getDashboardUrl(project) {
         return `${this.appEndpoint}/${(await this.getOrganization()).slug}/${project.slug}`;
     }
-    async getErrorUrl(project, errorId, queryString = "") {
+    async getErrorUrl(project, errorId, queryString) {
         const dashboardUrl = await this.getDashboardUrl(project);
-        return `${dashboardUrl}/errors/${errorId}${queryString}`;
+        return `${dashboardUrl}/errors/${errorId}${queryString ? `?${queryString}` : ""}`;
     }
     async getOrganization() {
         let org = this.cache.get(cacheKeys.ORG);
         if (!org) {
             const response = await this.currentUserApi.listUserOrganizations();
-            const orgs = response.body || [];
+            const orgs = response.body;
             if (!orgs || orgs.length === 0) {
                 throw new Error("No organizations found for the current user.");
             }
@@ -147,7 +147,7 @@ export class BugsnagClient {
         if (!projects) {
             const org = await this.getOrganization();
             const response = await this.currentUserApi.getOrganizationProjects(org.id);
-            projects = response.body || [];
+            projects = response.body;
             this.cache.set(cacheKeys.PROJECTS, projects);
         }
         return projects;
@@ -160,9 +160,10 @@ export class BugsnagClient {
         let project = this.cache.get(cacheKeys.CURRENT_PROJECT) ?? null;
         if (!project && this.projectApiKey) {
             const projects = await this.getProjects();
-            project = projects.find((p) => p.api_key === this.projectApiKey) ?? null;
+            project =
+                projects.find((p) => p.apiKey === this.projectApiKey) ?? null;
             if (!project) {
-                throw new Error("Unable to find project with the configured API key.");
+                throw new ToolError("Unable to find project with the configured API key.");
             }
             this.cache.set(cacheKeys.CURRENT_PROJECT, project);
             if (project) {
@@ -174,9 +175,9 @@ export class BugsnagClient {
     async getProjectEventFilters(project) {
         let filtersResponse = (await this.projectApi.listProjectEventFields(project.id)).body;
         if (!filtersResponse || filtersResponse.length === 0) {
-            throw new Error(`No event fields found for project ${project.name}.`);
+            throw new ToolError(`No event fields found for project ${project.name}.`);
         }
-        filtersResponse = filtersResponse.filter((field) => !EXCLUDED_EVENT_FIELDS.has(field.display_id));
+        filtersResponse = filtersResponse.filter((field) => field.displayId && !EXCLUDED_EVENT_FIELDS.has(field.displayId));
         return filtersResponse;
     }
     async getEvent(eventId, projectId) {
@@ -186,111 +187,48 @@ export class BugsnagClient {
         const projectEvents = await Promise.all(projectIds.map((projectId) => this.errorsApi.viewEventById(projectId, eventId).catch((_e) => null)));
         return projectEvents.find((event) => event && !!event.body)?.body || null;
     }
-    async updateError(projectId, errorId, operation, options) {
-        const errorUpdateRequest = {
-            operation: operation,
-            ...options,
-        };
-        const response = await this.errorsApi.updateErrorOnProject(projectId, errorId, errorUpdateRequest);
-        return response.status === 200 || response.status === 204;
-    }
     async getInputProject(projectId) {
         if (typeof projectId === "string") {
             const maybeProject = await this.getProject(projectId);
             if (!maybeProject) {
-                throw new Error(`Project with ID ${projectId} not found.`);
+                throw new ToolError(`Project with ID ${projectId} not found.`);
             }
             return maybeProject;
         }
         else {
             const currentProject = await this.getCurrentProject();
             if (!currentProject) {
-                throw new Error("No current project found. Please provide a projectId or configure a project API key.");
+                throw new ToolError("No current project found. Please provide a projectId or configure a project API key.");
             }
             return currentProject;
         }
     }
-    async listBuilds(projectId, opts) {
-        const response = await this.projectApi.listBuilds(projectId, opts);
-        if (!response.body || response.body.length === 0) {
-            return { ...response, body: [] };
-        }
-        const project = await this.getProject(projectId);
-        if (!project)
-            throw new Error(`Project with ID ${projectId} not found.`);
-        return {
-            ...response,
-            body: response.body.map((b) => this.addStabilityData(b, project)),
-        };
-    }
-    async getBuild(projectId, buildId) {
-        const response = await this.projectApi.getBuild(projectId, buildId);
-        if (!response.body)
-            throw new Error(`No build for ${buildId} found.`);
-        const project = await this.getProject(projectId);
-        if (!project)
-            throw new Error(`Project with ID ${projectId} not found.`);
-        return { ...response, body: this.addStabilityData(response.body, project) };
-    }
-    async listReleases(projectId, opts) {
-        const response = await this.projectApi.listReleases(projectId, opts);
-        if (!response.body || response.body.length === 0) {
-            return { ...response, body: [] };
-        }
-        const project = await this.getProject(projectId);
-        if (!project)
-            throw new Error(`Project with ID ${projectId} not found.`);
-        return {
-            ...response,
-            body: response.body.map((r) => this.addStabilityData(r, project)),
-        };
-    }
-    async getRelease(projectId, releaseId) {
-        const response = await this.projectApi.getRelease(releaseId);
-        if (!response.body)
-            throw new Error(`No release for ${releaseId} found.`);
-        const project = await this.getProject(projectId);
-        if (!project)
-            throw new Error(`Project with ID ${projectId} not found.`);
-        return { ...response, body: this.addStabilityData(response.body, project) };
-    }
-    async listBuildsInRelease(projectId, releaseId) {
-        const response = await this.projectApi.listBuildsInRelease(releaseId);
-        if (!response.body || response.body.length === 0) {
-            return { ...response, body: [] };
-        }
-        const project = await this.getProject(projectId);
-        if (!project)
-            throw new Error(`Project with ID ${projectId} not found.`);
-        return {
-            ...response,
-            body: response.body.map((b) => this.addStabilityData(b, project)),
-        };
-    }
     addStabilityData(source, project) {
-        const user_stability = source.accumulative_daily_users_seen === 0 // avoid division by zero
+        const accumulativeDailyUsersSeen = source.accumulativeDailyUsersSeen || 0;
+        const accumulativeDailyUsersWithUnhandled = source.accumulativeDailyUsersWithUnhandled || 0;
+        const userStability = accumulativeDailyUsersSeen === 0 // avoid division by zero
             ? 0
-            : (source.accumulative_daily_users_seen -
-                source.accumulative_daily_users_with_unhandled) /
-                source.accumulative_daily_users_seen;
-        const session_stability = source.total_sessions_count === 0 // avoid division by zero
+            : (accumulativeDailyUsersSeen - accumulativeDailyUsersWithUnhandled) /
+                accumulativeDailyUsersSeen;
+        const totalSessionsCount = source.totalSessionsCount || 0;
+        const unhandledSessionsCount = source.unhandledSessionsCount || 0;
+        const sessionStability = totalSessionsCount === 0 // avoid division by zero
             ? 0
-            : (source.total_sessions_count - source.unhandled_sessions_count) /
-                source.total_sessions_count;
-        const stabilityMetric = project.stability_target_type === "user"
-            ? user_stability
-            : session_stability;
-        const meets_target_stability = stabilityMetric >= project.target_stability.value;
-        const meets_critical_stability = stabilityMetric >= project.critical_stability.value;
+            : (totalSessionsCount - unhandledSessionsCount) / totalSessionsCount;
+        const stabilityMetric = project.stabilityTargetType === "user" ? userStability : sessionStability;
+        const targetStability = project.targetStability?.value || 0;
+        const criticalStability = project.criticalStability?.value || 0;
+        const meetsTargetStability = stabilityMetric >= targetStability;
+        const meetsCriticalStability = stabilityMetric >= criticalStability;
         return {
             ...source,
-            user_stability,
-            session_stability,
-            stability_target_type: project.stability_target_type,
-            target_stability: project.target_stability.value,
-            critical_stability: project.critical_stability.value,
-            meets_target_stability,
-            meets_critical_stability,
+            userStability,
+            sessionStability,
+            stabilityTargetType: project.stabilityTargetType || "user",
+            targetStability,
+            criticalStability,
+            meetsTargetStability,
+            meetsCriticalStability,
         };
     }
     registerTools(register, getInput) {
@@ -429,28 +367,22 @@ export class BugsnagClient {
         }, async (args, _extra) => {
             const project = await this.getInputProject(args.projectId);
             if (!args.errorId)
-                throw new Error("Both projectId and errorId arguments are required");
+                throw new ToolError("Both projectId and errorId arguments are required");
             const errorDetails = (await this.errorsApi.viewErrorOnProject(project.id, args.errorId)).body;
             if (!errorDetails) {
-                throw new Error(`Error with ID ${args.errorId} not found in project ${project.id}.`);
+                throw new ToolError(`Error with ID ${args.errorId} not found in project ${project.id}.`);
             }
-            // Build query parameters
-            const params = new URLSearchParams();
-            // Add sorting and pagination parameters to get the latest event
-            params.append("sort", "timestamp");
-            params.append("direction", "desc");
-            params.append("per_page", "1");
-            params.append("full_reports", "true");
             const filters = {
                 error: [{ type: "eq", value: args.errorId }],
                 ...args.filters,
             };
-            const filtersQueryString = toQueryString(filters);
-            const listEventsQueryString = `?${params}&${filtersQueryString}`;
             // Get the latest event for this error using the events endpoint with filters
             let latestEvent = null;
             try {
-                latestEvent = (await this.errorsApi.getLatestEventOnProject(project.id, listEventsQueryString)).body;
+                const latestEvents = (await this.errorsApi.listEventsOnProject(project.id, null, "timestamp", "desc", 1, filters, true)).body;
+                if (latestEvents && latestEvents.length > 0) {
+                    latestEvent = latestEvents[0];
+                }
             }
             catch (e) {
                 console.warn("Failed to fetch latest event:", e);
@@ -459,9 +391,8 @@ export class BugsnagClient {
             const content = {
                 error_details: errorDetails,
                 latest_event: latestEvent,
-                pivots: (await this.errorsApi.listErrorPivots(project.id, args.errorId))
-                    .body || [],
-                url: await this.getErrorUrl(project, args.errorId, `?${filtersQueryString}`),
+                pivots: (await this.errorsApi.getPivotValuesOnAnError(project.id, args.errorId, filters, 5)).body || [],
+                url: await this.getErrorUrl(project, args.errorId, toUrlSearchParams(filters).toString()),
             };
             return {
                 content: [{ type: "text", text: JSON.stringify(content) }],
@@ -505,17 +436,17 @@ export class BugsnagClient {
             ],
         }, async (args, _extra) => {
             if (!args.link)
-                throw new Error("link argument is required");
+                throw new ToolError("link argument is required");
             const url = new URL(args.link);
             const eventId = url.searchParams.get("event_id");
             const projectSlug = url.pathname.split("/")[2];
             if (!projectSlug || !eventId)
-                throw new Error("Both projectSlug and eventId must be present in the link");
+                throw new ToolError("Both projectSlug and eventId must be present in the link");
             // get the project id from list of projects
             const projects = await this.getProjects();
             const projectId = projects.find((p) => p.slug === projectSlug)?.id;
             if (!projectId) {
-                throw new Error("Project with the specified slug not found.");
+                throw new ToolError("Project with the specified slug not found.");
             }
             const response = await this.getEvent(eventId, projectId);
             return {
@@ -578,7 +509,7 @@ export class BugsnagClient {
                 },
                 {
                     name: "nextUrl",
-                    type: z.string().url(),
+                    type: z.string(),
                     description: "URL for retrieving the next page of results. Use the value in the previous response to get the next page when more results are available.",
                     required: false,
                     examples: [
@@ -648,29 +579,19 @@ export class BugsnagClient {
             // Validate filter keys against cached event fields
             if (args.filters) {
                 const eventFields = this.cache.get(cacheKeys.CURRENT_PROJECT_EVENT_FILTERS) || [];
-                const validKeys = new Set(eventFields.map((f) => f.display_id));
+                const validKeys = new Set(eventFields.map((f) => f.displayId));
                 for (const key of Object.keys(args.filters)) {
                     if (!validKeys.has(key)) {
-                        throw new Error(`Invalid filter key: ${key}`);
+                        throw new ToolError(`Invalid filter key: ${key}`);
                     }
                 }
             }
-            const defaultFilters = {
+            const filters = {
                 "event.since": [{ type: "eq", value: "30d" }],
                 "error.status": [{ type: "eq", value: "open" }],
+                ...args.filters,
             };
-            const options = {
-                filters: { ...defaultFilters, ...args.filters },
-            };
-            if (args.sort !== undefined)
-                options.sort = args.sort;
-            if (args.direction !== undefined)
-                options.direction = args.direction;
-            if (args.perPage !== undefined)
-                options.per_page = args.perPage;
-            if (args.nextUrl !== undefined)
-                options.next_url = args.nextUrl;
-            const response = await this.errorsApi.listProjectErrors(project.id, options);
+            const response = await this.errorsApi.listProjectErrors(project.id, null, args.sort || "last_seen", args.direction || "desc", args.perPage || 30, filters, args.nextUrl);
             const result = {
                 data: response.body,
                 next_url: response.nextUrl ?? undefined,
@@ -705,7 +626,7 @@ export class BugsnagClient {
         }, async (_args, _extra) => {
             const projectFields = this.cache.get(cacheKeys.CURRENT_PROJECT_EVENT_FILTERS);
             if (!projectFields)
-                throw new Error("No event filters found in cache.");
+                throw new ToolError("No event filters found in cache.");
             return {
                 content: [{ type: "text", text: JSON.stringify(projectFields) }],
             };
@@ -784,12 +705,18 @@ export class BugsnagClient {
                     severity = result.content.severity;
                 }
             }
-            const result = await this.updateError(project.id, errorId, operation, {
-                severity,
+            const result = await this.errorsApi.updateErrorOnProject(project.id, errorId, {
+                operation: operation,
+                severity: severity,
             });
             return {
                 content: [
-                    { type: "text", text: JSON.stringify({ success: result }) },
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: result.status === 200 || result.status === 204,
+                        }),
+                    },
                 ],
             };
         });
@@ -826,6 +753,13 @@ export class BugsnagClient {
                     required: false,
                     examples: ["true", "false"],
                 },
+                {
+                    name: "perPage",
+                    type: z.number().min(1).max(100).default(30),
+                    description: "How many results to return per page.",
+                    required: false,
+                    examples: ["30", "50", "100"],
+                },
                 {
                     name: "nextUrl",
                     type: z.string(),
@@ -866,19 +800,21 @@ export class BugsnagClient {
             idempotent: true,
             outputFormat: "JSON array of release summary objects with metadata, with a URL to the next page if more results are available",
         }, async (args, _extra) => {
-            const response = await this.listReleases((await this.getInputProject(args.projectId)).id, {
-                release_stage_name: args.releaseStage,
-                visible_only: args.visibleOnly,
-                next_url: args.nextUrl,
-            });
+            const project = await this.getInputProject(args.projectId);
+            const response = await this.projectApi.listProjectReleaseGroups(project.id, args.releaseStage || "production", false, // Not top-only
+            args.visibleOnly || false, args.perPage || 30, args.nextUrl);
+            let releases = [];
+            if (response.body) {
+                releases = response.body.map((r) => this.addStabilityData(r, project));
+            }
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
-                            data: response.body,
+                            data: releases,
                             next_url: response.nextUrl ?? undefined,
-                            data_count: response.body?.length,
+                            data_count: releases.length,
                             total_count: response.totalCount ?? undefined,
                         }),
                     },
@@ -928,17 +864,26 @@ export class BugsnagClient {
             outputFormat: "JSON object containing release details along with stability metrics such as user and session stability, and whether it meets project targets",
         }, async (args, _extra) => {
             if (!args.releaseId)
-                throw new Error("releaseId argument is required");
+                throw new ToolError("releaseId argument is required");
             const project = await this.getInputProject(args.projectId);
-            const releaseResponse = await this.getRelease(project.id, args.releaseId);
-            const buildsResponse = await this.listBuildsInRelease(project.id, args.releaseId);
+            const releaseResponse = await this.projectApi.getReleaseGroup(args.releaseId);
+            if (!releaseResponse.body)
+                throw new ToolError(`No release for ${args.releaseId} found.`);
+            const release = this.addStabilityData(releaseResponse.body, project);
+            let builds = [];
+            if (releaseResponse.body) {
+                const buildsResponse = await this.projectApi.listBuildsInRelease(args.releaseId);
+                if (buildsResponse.body) {
+                    builds = buildsResponse.body.map((b) => this.addStabilityData(b, project));
+                }
+            }
             return {
                 content: [
                     {
                         type: "text",
                         text: JSON.stringify({
-                            release: releaseResponse.body,
-                            builds: buildsResponse.body,
+                            release: release,
+                            builds: builds,
                         }),
                     },
                 ],
@@ -987,10 +932,14 @@ export class BugsnagClient {
             outputFormat: "JSON object containing build details along with stability metrics such as user and session stability, and whether it meets project targets",
         }, async (args, _extra) => {
             if (!args.buildId)
-                throw new Error("buildId argument is required");
-            const response = await this.getBuild((await this.getInputProject(args.projectId)).id, args.buildId);
+                throw new ToolError("buildId argument is required");
+            const project = await this.getInputProject(args.projectId);
+            const response = await this.projectApi.getProjectReleaseById(project.id, args.buildId);
+            if (!response.body)
+                throw new ToolError(`No build for ${args.buildId} found.`);
+            const build = this.addStabilityData(response.body, project);
             return {
-                content: [{ type: "text", text: JSON.stringify(response.body) }],
+                content: [{ type: "text", text: JSON.stringify(build) }],
             };
         });
     }

package/dist/common/server.js

@@ -2,6 +2,7 @@ import { McpServer, ResourceTemplate, } from "@modelcontextprotocol/sdk/server/m
 import { ZodAny, ZodArray, ZodBoolean, ZodEnum, ZodLiteral, ZodNumber, ZodObject, ZodOptional, ZodString, ZodUnion, } from "zod";
 import Bugsnag from "../common/bugsnag.js";
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "./info.js";
+import { ToolError } from "./types.js";
 export class SmartBearMcpServer extends McpServer {
     constructor() {
         super({
@@ -32,7 +33,24 @@ export class SmartBearMcpServer extends McpServer {
                     return await cb(args, extra);
                 }
                 catch (e) {
-                    Bugsnag.notify(e);
+                    // ToolErrors should not be reported to BugSnag
+                    if (e instanceof ToolError) {
+                        return {
+                            isError: true,
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Error executing ${toolTitle}: ${e.message}`,
+                                },
+                            ],
+                        };
+                    }
+                    else {
+                        Bugsnag.notify(e, (event) => {
+                            event.addMetadata("app", { tool: toolName });
+                            event.unhandled = true;
+                        });
+                    }
                     throw e;
                 }
             });
@@ -41,14 +59,18 @@ export class SmartBearMcpServer extends McpServer {
         });
         if (client.registerResources) {
             client.registerResources((name, path, cb) => {
-                return super.registerResource(name, new ResourceTemplate(`${client.prefix}://${name}/${path}`, {
+                const url = `${client.prefix}://${name}/${path}`;
+                return super.registerResource(name, new ResourceTemplate(url, {
                     list: undefined,
                 }), {}, async (url, variables, extra) => {
                     try {
                         return await cb(url, variables, extra);
                     }
                     catch (e) {
-                        Bugsnag.notify(e);
+                        Bugsnag.notify(e, (event) => {
+                            event.addMetadata("app", { resource: name, url: url });
+                            event.unhandled = true;
+                        });
                         throw e;
                     }
                 });

package/dist/common/types.js

@@ -1 +1,6 @@
-export {};
+/**
+ * Error class for tool-specific errors – these result in a response to the LLM with `isError: true`
+ * and are not reported to BugSnag
+ */
+export class ToolError extends Error {
+}

package/dist/pactflow/client/prompt-utils.js

@@ -1,3 +1,4 @@
+import { ToolError } from "../../common/types.js";
 import { EndpointMatcherSchema, MatcherRecommendationInputSchema, } from "./ai.js";
 import { OADMatcherPrompt } from "./prompts.js";
 /**
@@ -30,7 +31,7 @@ export async function getOADMatcherRecommendations(openAPI, server) {
         return matcherRecommendations;
     }
     else {
-        throw new Error("Unable to parse recommendations please provide OpenAPI matchers manually.");
+        throw new ToolError("Unable to parse recommendations please provide OpenAPI matchers manually.");
     }
 }
 /**

package/dist/pactflow/client/utils.js

@@ -1,6 +1,7 @@
 import yaml from "js-yaml";
 // @ts-expect-error missing type declarations
 import Swagger from "swagger-client";
+import { ToolError } from "../../common/types.js";
 import { RemoteOpenAPIDocumentSchema, } from "./ai.js";
 /**
  * Resolve the OpenAPI specification from the provided input.
@@ -12,12 +13,12 @@ import { RemoteOpenAPIDocumentSchema, } from "./ai.js";
 export async function resolveOpenAPISpec(remoteOpenAPIDocument) {
     const openAPISchema = RemoteOpenAPIDocumentSchema.safeParse(remoteOpenAPIDocument);
     if (openAPISchema.error || !remoteOpenAPIDocument) {
-        throw new Error(`Invalid RemoteOpenAPIDocument: ${JSON.stringify(openAPISchema.error?.issues)}`);
+        throw new ToolError(`Invalid RemoteOpenAPIDocument: ${JSON.stringify(openAPISchema.error?.issues)}`);
     }
     const unresolvedSpec = await getRemoteSpecContents(openAPISchema.data);
     const resolvedSpec = await Swagger.resolve({ spec: unresolvedSpec });
     if (resolvedSpec.errors?.length) {
-        throw new Error(`Failed to resolve OpenAPI document: ${resolvedSpec.errors?.join(", ")}`);
+        throw new ToolError(`Failed to resolve OpenAPI document: ${resolvedSpec.errors?.join(", ")}`);
     }
     return resolvedSpec.spec;
 }
@@ -30,7 +31,7 @@ export async function resolveOpenAPISpec(remoteOpenAPIDocument) {
  */
 export async function getRemoteSpecContents(openAPISchema) {
     if (!openAPISchema.url) {
-        throw new Error("'url' must be provided.");
+        throw new ToolError("'url' must be provided.");
     }
     let headers = {};
     if (openAPISchema.authToken) {
@@ -51,7 +52,7 @@ export async function getRemoteSpecContents(openAPISchema) {
             return yaml.load(specRawBody);
         }
         catch (yamlError) {
-            throw new Error(`Unsupported Content-Type: ${remoteSpec.headers.get("Content-Type")} for remote OpenAPI document. Found following parse errors:-\nJSON parse error: ${jsonError}\nYAML parse error: ${yamlError}`);
+            throw new ToolError(`Unsupported Content-Type: ${remoteSpec.headers.get("Content-Type")} for remote OpenAPI document. Found following parse errors:-\nJSON parse error: ${jsonError}\nYAML parse error: ${yamlError}`);
         }
     }
 }

package/dist/pactflow/client.js

@@ -1,4 +1,5 @@
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.js";
+import { ToolError, } from "../common/types.js";
 import { getOADMatcherRecommendations, getUserMatcherSelection, } from "./client/prompt-utils.js";
 import { PROMPTS } from "./client/prompts.js";
 import { TOOLS } from "./client/tools.js";
@@ -65,7 +66,7 @@ export class PactflowClient {
             body: JSON.stringify(toolInput),
         });
         if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status} - ${await response.text()}`);
+            throw new ToolError(`HTTP error! status: ${response.status} - ${await response.text()}`);
         }
         const status_response = await response.json();
         return await this.pollForCompletion(status_response, "Generation");
@@ -93,7 +94,7 @@ export class PactflowClient {
             body: JSON.stringify(toolInput),
         });
         if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status} - ${await response.text()}`);
+            throw new ToolError(`HTTP error! status: ${response.status} - ${await response.text()}`);
         }
         const status_response = await response.json();
         return await this.pollForCompletion(status_response, "Review Pacts");
@@ -116,7 +117,7 @@ export class PactflowClient {
             });
             if (!response.ok) {
                 const errorText = await response.text().catch(() => "");
-                throw new Error(`PactFlow AI Entitlements Request Failed - status: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`);
+                throw new ToolError(`PactFlow AI Entitlements Request Failed - status: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`);
             }
             return (await response.json());
         }
@@ -145,7 +146,7 @@ export class PactflowClient {
         });
         // Check if the response is OK (status 200)
         if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
+            throw new ToolError(`HTTP error! status: ${response.status}`);
         }
         return response.json();
     }
@@ -161,12 +162,12 @@ export class PactflowClient {
                 return await this.getResult(status_response.result_url);
             }
             if (statusCheck.status !== 202) {
-                throw new Error(`${operationName} failed with status: ${statusCheck.status}`);
+                throw new ToolError(`${operationName} failed with status: ${statusCheck.status}`);
             }
             // Wait before next poll
             await new Promise((resolve) => setTimeout(resolve, pollInterval));
         }
-        throw new Error(`${operationName} timed out after ${timeout / 1000} seconds`);
+        throw new ToolError(`${operationName} timed out after ${timeout / 1000} seconds`);
     }
     // PactFlow / Pact_Broker client methods
     async getProviderStates({ provider, }) {
@@ -176,7 +177,7 @@ export class PactflowClient {
             headers: this.headers,
         });
         if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status} - ${await response.text()}`);
+            throw new ToolError(`HTTP error! status: ${response.status} - ${await response.text()}`);
         }
         return response.json();
     }
@@ -206,7 +207,7 @@ export class PactflowClient {
             });
             if (!response.ok) {
                 const errorText = await response.text().catch(() => "");
-                throw new Error(`Can-I-Deploy Request Failed - status: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`);
+                throw new ToolError(`Can-I-Deploy Request Failed - status: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`);
             }
             return (await response.json());
         }
@@ -265,7 +266,7 @@ export class PactflowClient {
             });
             if (!response.ok) {
                 const errorText = await response.text().catch(() => "");
-                throw new Error(`Matrix Request Failed - status: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`);
+                throw new ToolError(`Matrix Request Failed - status: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`);
             }
             return (await response.json());
         }