@dizzlkheinz/ynab-mcpb 0.17.1 → 0.18.1

package/src/server/__tests__/completions.test.ts

@@ -0,0 +1,319 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { CompletionsManager } from '../completions.js';
+import type { CacheManager } from '../cacheManager.js';
+import type * as ynab from 'ynab';
+
+/**
+ * Unit tests for CompletionsManager
+ * Tests autocomplete functionality for YNAB entities
+ */
+describe('CompletionsManager', () => {
+  let manager: CompletionsManager;
+  let mockYnabAPI: Partial<ynab.API>;
+  let mockCacheManager: Partial<CacheManager>;
+  let getDefaultBudgetId: () => string | undefined;
+
+  const mockBudgets = [
+    { id: 'budget-1', name: 'Personal Budget' },
+    { id: 'budget-2', name: 'Business Budget' },
+    { id: 'budget-3', name: 'Savings' },
+  ];
+
+  const mockAccounts = [
+    { id: 'acc-1', name: 'Checking Account', deleted: false, closed: false },
+    { id: 'acc-2', name: 'Savings Account', deleted: false, closed: false },
+    { id: 'acc-3', name: 'Credit Card', deleted: false, closed: false },
+    { id: 'acc-deleted', name: 'Deleted Account', deleted: true, closed: false },
+    { id: 'acc-closed', name: 'Closed Account', deleted: false, closed: true },
+  ];
+
+  const mockCategories = {
+    category_groups: [
+      {
+        name: 'Bills',
+        hidden: false,
+        deleted: false,
+        categories: [
+          { id: 'cat-1', name: 'Rent', hidden: false, deleted: false },
+          { id: 'cat-2', name: 'Utilities', hidden: false, deleted: false },
+        ],
+      },
+      {
+        name: 'Food',
+        hidden: false,
+        deleted: false,
+        categories: [
+          { id: 'cat-3', name: 'Groceries', hidden: false, deleted: false },
+          { id: 'cat-4', name: 'Restaurants', hidden: false, deleted: false },
+        ],
+      },
+      {
+        name: 'Hidden Group',
+        hidden: true,
+        deleted: false,
+        categories: [{ id: 'cat-hidden', name: 'Hidden Category', hidden: false, deleted: false }],
+      },
+    ],
+  };
+
+  const mockPayees = [
+    { id: 'payee-1', name: 'Amazon', deleted: false },
+    { id: 'payee-2', name: 'Walmart', deleted: false },
+    { id: 'payee-3', name: 'Target', deleted: false },
+    { id: 'payee-deleted', name: 'Deleted Payee', deleted: true },
+  ];
+
+  beforeEach(() => {
+    mockYnabAPI = {
+      budgets: {
+        getBudgets: vi.fn().mockResolvedValue({ data: { budgets: mockBudgets } }),
+      } as unknown as ynab.BudgetsApi,
+      accounts: {
+        getAccounts: vi.fn().mockResolvedValue({ data: { accounts: mockAccounts } }),
+      } as unknown as ynab.AccountsApi,
+      categories: {
+        getCategories: vi.fn().mockResolvedValue({ data: mockCategories }),
+      } as unknown as ynab.CategoriesApi,
+      payees: {
+        getPayees: vi.fn().mockResolvedValue({ data: { payees: mockPayees } }),
+      } as unknown as ynab.PayeesApi,
+    };
+
+    // Mock cache manager that bypasses caching
+    mockCacheManager = {
+      wrap: vi.fn().mockImplementation(async (_key, { loader }) => loader()),
+    };
+
+    getDefaultBudgetId = vi.fn().mockReturnValue('default-budget-id');
+
+    manager = new CompletionsManager(
+      mockYnabAPI as ynab.API,
+      mockCacheManager as CacheManager,
+      getDefaultBudgetId,
+    );
+  });
+
+  describe('getCompletions', () => {
+    it('should return empty completion for unknown argument names', async () => {
+      const result = await manager.getCompletions('unknown_arg', 'test');
+      expect(result.completion.values).toEqual([]);
+      expect(result.completion.total).toBe(0);
+      expect(result.completion.hasMore).toBe(false);
+    });
+
+    it('should handle case-insensitive argument names', async () => {
+      const result = await manager.getCompletions('BUDGET_ID', 'pers');
+      expect(result.completion.values).toContain('Personal Budget');
+    });
+  });
+
+  describe('completeBudgets', () => {
+    it('should return matching budgets by name', async () => {
+      const result = await manager.getCompletions('budget_id', 'pers');
+      expect(result.completion.values).toContain('Personal Budget');
+      expect(result.completion.total).toBe(1);
+    });
+
+    it('should return all budgets when search value is empty', async () => {
+      const result = await manager.getCompletions('budget_id', '');
+      expect(result.completion.values).toHaveLength(3);
+      expect(result.completion.total).toBe(3);
+    });
+
+    it('should match by budget ID', async () => {
+      const result = await manager.getCompletions('budget_id', 'budget-1');
+      expect(result.completion.values.length).toBeGreaterThan(0);
+    });
+
+    it('should prioritize prefix matches over contains', async () => {
+      const result = await manager.getCompletions('budget_id', 'sav');
+      // "Savings" starts with "sav" so it should come before "Business Budget" (contains "sav" in "Business")
+      expect(result.completion.values[0]).toBe('Savings');
+    });
+  });
+
+  describe('completeAccounts', () => {
+    it('should return matching accounts by name', async () => {
+      const result = await manager.getCompletions('account_id', 'check');
+      expect(result.completion.values).toContain('Checking Account');
+    });
+
+    it('should filter out deleted accounts', async () => {
+      const result = await manager.getCompletions('account_id', 'deleted');
+      expect(result.completion.values).not.toContain('Deleted Account');
+      expect(result.completion.total).toBe(0);
+    });
+
+    it('should filter out closed accounts', async () => {
+      const result = await manager.getCompletions('account_id', 'closed');
+      expect(result.completion.values).not.toContain('Closed Account');
+      expect(result.completion.total).toBe(0);
+    });
+
+    it('should return empty when no budget context available', async () => {
+      getDefaultBudgetId = vi.fn().mockReturnValue(undefined);
+      manager = new CompletionsManager(
+        mockYnabAPI as ynab.API,
+        mockCacheManager as CacheManager,
+        getDefaultBudgetId,
+      );
+
+      const result = await manager.getCompletions('account_id', 'check');
+      expect(result.completion.values).toEqual([]);
+    });
+
+    it('should use budget_id from context if provided', async () => {
+      const context = { arguments: { budget_id: 'context-budget' } };
+      await manager.getCompletions('account_id', 'check', context);
+
+      expect(mockCacheManager.wrap).toHaveBeenCalledWith(
+        'completions:accounts:context-budget',
+        expect.any(Object),
+      );
+    });
+
+    it('should handle account_name argument', async () => {
+      const result = await manager.getCompletions('account_name', 'sav');
+      expect(result.completion.values).toContain('Savings Account');
+    });
+  });
+
+  describe('completeCategories', () => {
+    it('should return matching categories by name', async () => {
+      const result = await manager.getCompletions('category', 'groc');
+      expect(result.completion.values).toContain('Groceries');
+    });
+
+    it('should match by group:name format', async () => {
+      const result = await manager.getCompletions('category', 'Food: Groc');
+      expect(result.completion.total).toBeGreaterThan(0);
+    });
+
+    it('should filter out hidden categories', async () => {
+      const result = await manager.getCompletions('category', 'hidden');
+      expect(result.completion.values).not.toContain('Hidden Category');
+    });
+
+    it('should return empty when no budget context available', async () => {
+      getDefaultBudgetId = vi.fn().mockReturnValue(undefined);
+      manager = new CompletionsManager(
+        mockYnabAPI as ynab.API,
+        mockCacheManager as CacheManager,
+        getDefaultBudgetId,
+      );
+
+      const result = await manager.getCompletions('category', 'groc');
+      expect(result.completion.values).toEqual([]);
+    });
+
+    it('should handle category_id argument', async () => {
+      const result = await manager.getCompletions('category_id', 'rent');
+      expect(result.completion.values).toContain('Rent');
+    });
+
+    it('should prioritize name over ID in results', async () => {
+      // When searching for a category, we should get the name, not the ID
+      const result = await manager.getCompletions('category', 'cat-1');
+      // Even when matching by ID, the display value should prefer the name
+      expect(result.completion.total).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('completePayees', () => {
+    it('should return matching payees by name', async () => {
+      const result = await manager.getCompletions('payee', 'amaz');
+      expect(result.completion.values).toContain('Amazon');
+    });
+
+    it('should filter out deleted payees', async () => {
+      const result = await manager.getCompletions('payee', 'deleted');
+      expect(result.completion.values).not.toContain('Deleted Payee');
+    });
+
+    it('should handle payee_id argument', async () => {
+      const result = await manager.getCompletions('payee_id', 'targ');
+      expect(result.completion.values).toContain('Target');
+    });
+
+    it('should return empty when no budget context available', async () => {
+      getDefaultBudgetId = vi.fn().mockReturnValue(undefined);
+      manager = new CompletionsManager(
+        mockYnabAPI as ynab.API,
+        mockCacheManager as CacheManager,
+        getDefaultBudgetId,
+      );
+
+      const result = await manager.getCompletions('payee', 'amaz');
+      expect(result.completion.values).toEqual([]);
+    });
+  });
+
+  describe('filterAndFormat', () => {
+    it('should respect MAX_COMPLETIONS limit', async () => {
+      // Create a large list of budgets
+      const manyBudgets = Array.from({ length: 150 }, (_, i) => ({
+        id: `budget-${i}`,
+        name: `Budget ${i}`,
+      }));
+
+      mockYnabAPI.budgets = {
+        getBudgets: vi.fn().mockResolvedValue({ data: { budgets: manyBudgets } }),
+      } as unknown as ynab.BudgetsApi;
+
+      manager = new CompletionsManager(
+        mockYnabAPI as ynab.API,
+        mockCacheManager as CacheManager,
+        getDefaultBudgetId,
+      );
+
+      const result = await manager.getCompletions('budget_id', 'Budget');
+      expect(result.completion.values.length).toBeLessThanOrEqual(100);
+      expect(result.completion.hasMore).toBe(true);
+      expect(result.completion.total).toBe(150);
+    });
+
+    it('should cache lowercased values for performance', async () => {
+      // This is tested implicitly by the fact that filtering works correctly
+      // The internal cache is not exposed, but we verify behavior is correct
+      const result = await manager.getCompletions('budget_id', 'PERSONAL');
+      expect(result.completion.values).toContain('Personal Budget');
+    });
+
+    it('should return unique values only', async () => {
+      const result = await manager.getCompletions('budget_id', 'budget');
+      const uniqueCount = new Set(result.completion.values).size;
+      expect(uniqueCount).toBe(result.completion.values.length);
+    });
+  });
+
+  describe('caching behavior', () => {
+    it('should use cache manager for budgets', async () => {
+      await manager.getCompletions('budget_id', 'test');
+      expect(mockCacheManager.wrap).toHaveBeenCalledWith('completions:budgets', expect.any(Object));
+    });
+
+    it('should use cache manager for accounts with budget-specific key', async () => {
+      await manager.getCompletions('account_id', 'test');
+      expect(mockCacheManager.wrap).toHaveBeenCalledWith(
+        'completions:accounts:default-budget-id',
+        expect.any(Object),
+      );
+    });
+
+    it('should use cache manager for categories with budget-specific key', async () => {
+      await manager.getCompletions('category', 'test');
+      expect(mockCacheManager.wrap).toHaveBeenCalledWith(
+        'completions:categories:default-budget-id',
+        expect.any(Object),
+      );
+    });
+
+    it('should use cache manager for payees with budget-specific key', async () => {
+      await manager.getCompletions('payee', 'test');
+      expect(mockCacheManager.wrap).toHaveBeenCalledWith(
+        'completions:payees:default-budget-id',
+        expect.any(Object),
+      );
+    });
+  });
+});

package/src/server/__tests__/resources.template.test.ts

@@ -109,7 +109,7 @@ describe('ResourceManager Templates', () => {
   it('should fallback to throwing error for unknown URIs', async () => {
     const uri = 'ynab://unknown/resource';
     await expect(resourceManager.readResource(uri)).rejects.toThrow(
-      'Unknown resource: ynab://unknown/resource',
+      'Resource not found: ynab://unknown/resource',
     );
   });
 
@@ -135,7 +135,7 @@ describe('ResourceManager Templates', () => {
       (mockYnabAPI.budgets.getBudgetById as any).mockRejectedValue(new Error('Budget not found'));
 
       await expect(resourceManager.readResource('ynab://budgets/invalid-id')).rejects.toThrow(
-        'Failed to resolve template resource ynab://budgets/invalid-id: Failed to fetch budget invalid-id: Budget not found',
+        'Failed to read resource ynab://budgets/invalid-id: Failed to fetch budget invalid-id: Budget not found',
       );
     });
 
@@ -147,7 +147,7 @@ describe('ResourceManager Templates', () => {
       await expect(
         resourceManager.readResource('ynab://budgets/budget-id/accounts/invalid-account'),
       ).rejects.toThrow(
-        'Failed to resolve template resource ynab://budgets/budget-id/accounts/invalid-account: Failed to fetch account invalid-account in budget budget-id: Account not found',
+        'Failed to read resource ynab://budgets/budget-id/accounts/invalid-account: Failed to fetch account invalid-account in budget budget-id: Account not found',
       );
     });
 

package/src/server/__tests__/resources.test.ts

@@ -212,18 +212,18 @@ describe('resources module', () => {
       describe('unknown resources', () => {
         it('should throw error for unknown resource URIs', async () => {
           await expect(resourceManager.readResource('ynab://unknown')).rejects.toThrow(
-            'Unknown resource: ynab://unknown',
+            'Resource not found: ynab://unknown',
           );
         });
 
         it('should throw error for invalid URIs', async () => {
           await expect(resourceManager.readResource('invalid-uri')).rejects.toThrow(
-            'Unknown resource: invalid-uri',
+            'Resource not found: invalid-uri',
           );
         });
 
         it('should throw error for empty URI', async () => {
-          await expect(resourceManager.readResource('')).rejects.toThrow('Unknown resource: ');
+          await expect(resourceManager.readResource('')).rejects.toThrow('Resource not found: ');
         });
       });
     });

package/src/server/__tests__/toolRegistration.test.ts

@@ -66,7 +66,7 @@ describe('Tool Registration', () => {
   // Config is mocked at module level, no env setup needed
 
   describe('Tool Count Verification', () => {
-    it('registers exactly 30 tools', () => {
+    it('registers exactly 29 tools', () => {
       const server = new YNABMCPServer(false);
       const tools = server.getToolRegistry().listTools();
       expect(tools).toHaveLength(EXPECTED_TOOL_COUNT);

package/src/server/cacheManager.ts

@@ -145,14 +145,15 @@ export class CacheManager {
     } else {
       const providedTtl = ttlOrOptions?.ttl;
       ttl = providedTtl !== undefined ? providedTtl : this.defaultTTL;
-      if (ttlOrOptions && 'staleWhileRevalidate' in ttlOrOptions) {
+      const hasStaleWhileRevalidate =
+        ttlOrOptions !== undefined && 'staleWhileRevalidate' in ttlOrOptions;
+      if (hasStaleWhileRevalidate) {
         staleWhileRevalidate = ttlOrOptions.staleWhileRevalidate;
+        if (staleWhileRevalidate === undefined && this.defaultStaleWindow > 0) {
+          staleWhileRevalidate = this.defaultStaleWindow;
+        }
       } else {
-        staleWhileRevalidate = ttlOrOptions?.staleWhileRevalidate;
-      }
-      // Apply default stale window only when options object is provided and staleWhileRevalidate is undefined
-      if (staleWhileRevalidate === undefined && this.defaultStaleWindow > 0) {
-        staleWhileRevalidate = this.defaultStaleWindow;
+        staleWhileRevalidate = undefined;
       }
     }
     const entry: CacheEntry<T> = {

package/src/server/completions.ts

@@ -0,0 +1,279 @@
+/**
+ * @fileoverview MCP Completions Manager
+ * Provides autocomplete suggestions for prompts and resource templates.
+ * @module server/completions
+ */
+
+import type * as ynab from 'ynab';
+import type { CacheManager } from './cacheManager.js';
+import { CACHE_TTLS } from './cacheManager.js';
+
+/**
+ * Completion result structure following MCP spec
+ */
+export interface CompletionResult {
+  completion: {
+    values: string[];
+    total?: number;
+    hasMore?: boolean;
+  };
+}
+
+/**
+ * Arguments that can be completed
+ */
+type CompletableArgument =
+  | 'budget_id'
+  | 'account_id'
+  | 'account_name'
+  | 'category'
+  | 'category_id'
+  | 'payee'
+  | 'payee_id';
+
+/**
+ * Context for completions - previously resolved arguments
+ * The arguments property may be undefined when no prior context exists
+ */
+interface CompletionContext {
+  arguments?: Record<string, string> | undefined;
+}
+
+/**
+ * Maximum number of completion values to return (per MCP spec)
+ */
+const MAX_COMPLETIONS = 100;
+
+/**
+ * CompletionsManager handles autocomplete requests for YNAB entities.
+ * Provides completions for budgets, accounts, categories, and payees.
+ */
+export class CompletionsManager {
+  constructor(
+    private readonly ynabAPI: ynab.API,
+    private readonly cacheManager: CacheManager,
+    private readonly getDefaultBudgetId: () => string | undefined,
+  ) {}
+
+  /**
+   * Get completions for an argument based on the current value
+   */
+  async getCompletions(
+    argumentName: string,
+    value: string,
+    context?: CompletionContext,
+  ): Promise<CompletionResult> {
+    const normalizedName = argumentName.toLowerCase() as CompletableArgument;
+
+    switch (normalizedName) {
+      case 'budget_id':
+        return this.completeBudgets(value);
+
+      case 'account_id':
+      case 'account_name':
+        return this.completeAccounts(value, context);
+
+      case 'category':
+      case 'category_id':
+        return this.completeCategories(value, context);
+
+      case 'payee':
+      case 'payee_id':
+        return this.completePayees(value, context);
+
+      default:
+        return { completion: { values: [], total: 0, hasMore: false } };
+    }
+  }
+
+  /**
+   * Complete budget names/IDs
+   */
+  private async completeBudgets(value: string): Promise<CompletionResult> {
+    const budgets = await this.cacheManager.wrap('completions:budgets', {
+      ttl: CACHE_TTLS.BUDGETS,
+      loader: async () => {
+        const response = await this.ynabAPI.budgets.getBudgets();
+        return response.data.budgets.map((b) => ({
+          id: b.id,
+          name: b.name,
+        }));
+      },
+    });
+
+    return this.filterAndFormat(budgets, value, (b) => [b.name, b.id]);
+  }
+
+  /**
+   * Complete account names/IDs within a budget
+   */
+  private async completeAccounts(
+    value: string,
+    context?: CompletionContext,
+  ): Promise<CompletionResult> {
+    const budgetId = context?.arguments?.['budget_id'] ?? this.getDefaultBudgetId();
+    if (!budgetId) {
+      return { completion: { values: [], total: 0, hasMore: false } };
+    }
+
+    const accounts = await this.cacheManager.wrap(`completions:accounts:${budgetId}`, {
+      ttl: CACHE_TTLS.ACCOUNTS,
+      loader: async () => {
+        const response = await this.ynabAPI.accounts.getAccounts(budgetId);
+        return response.data.accounts
+          .filter((a) => !a.deleted && !a.closed)
+          .map((a) => ({
+            id: a.id,
+            name: a.name,
+          }));
+      },
+    });
+
+    return this.filterAndFormat(accounts, value, (a) => [a.name, a.id]);
+  }
+
+  /**
+   * Complete category names/IDs within a budget
+   */
+  private async completeCategories(
+    value: string,
+    context?: CompletionContext,
+  ): Promise<CompletionResult> {
+    const budgetId = context?.arguments?.['budget_id'] ?? this.getDefaultBudgetId();
+    if (!budgetId) {
+      return { completion: { values: [], total: 0, hasMore: false } };
+    }
+
+    const categories = await this.cacheManager.wrap(`completions:categories:${budgetId}`, {
+      ttl: CACHE_TTLS.CATEGORIES,
+      loader: async () => {
+        const response = await this.ynabAPI.categories.getCategories(budgetId);
+        const result: { id: string; name: string; group: string }[] = [];
+        for (const group of response.data.category_groups) {
+          if (group.hidden || group.deleted) continue;
+          for (const cat of group.categories) {
+            if (cat.hidden || cat.deleted) continue;
+            result.push({
+              id: cat.id,
+              name: cat.name,
+              group: group.name,
+            });
+          }
+        }
+        return result;
+      },
+    });
+
+    // For categories, include group name in display for clarity
+    return this.filterAndFormat(categories, value, (c) => [c.name, `${c.group}: ${c.name}`, c.id]);
+  }
+
+  /**
+   * Complete payee names/IDs within a budget
+   */
+  private async completePayees(
+    value: string,
+    context?: CompletionContext,
+  ): Promise<CompletionResult> {
+    const budgetId = context?.arguments?.['budget_id'] ?? this.getDefaultBudgetId();
+    if (!budgetId) {
+      return { completion: { values: [], total: 0, hasMore: false } };
+    }
+
+    const payees = await this.cacheManager.wrap(`completions:payees:${budgetId}`, {
+      ttl: CACHE_TTLS.PAYEES,
+      loader: async () => {
+        const response = await this.ynabAPI.payees.getPayees(budgetId);
+        return response.data.payees
+          .filter((p) => !p.deleted)
+          .map((p) => ({
+            id: p.id,
+            name: p.name,
+          }));
+      },
+    });
+
+    return this.filterAndFormat(payees, value, (p) => [p.name, p.id]);
+  }
+
+  /**
+   * Filter items by value match and format as completion result.
+   * Searches case-insensitively across all searchable fields.
+   * Caches lowercased values to avoid repeated toLowerCase() calls.
+   */
+  private filterAndFormat<T>(
+    items: T[],
+    value: string,
+    getSearchableValues: (item: T) => string[],
+  ): CompletionResult {
+    const lowerValue = value.toLowerCase();
+
+    // Cache lowercased values to avoid repeated toLowerCase() calls during filtering and sorting
+    const itemCache = new Map<T, { values: string[]; lowerValues: string[] }>();
+    const getCachedValues = (item: T) => {
+      let cached = itemCache.get(item);
+      if (!cached) {
+        const values = getSearchableValues(item);
+        cached = { values, lowerValues: values.map((v) => v.toLowerCase()) };
+        itemCache.set(item, cached);
+      }
+      return cached;
+    };
+
+    // Filter items that match the search value
+    const matches = items.filter((item) => {
+      const { lowerValues } = getCachedValues(item);
+      return lowerValues.some((v) => v.includes(lowerValue));
+    });
+
+    // Sort by relevance (exact prefix matches first, then contains)
+    matches.sort((a, b) => {
+      const aCache = getCachedValues(a);
+      const bCache = getCachedValues(b);
+
+      const aStartsWith = aCache.lowerValues.some((v) => v.startsWith(lowerValue));
+      const bStartsWith = bCache.lowerValues.some((v) => v.startsWith(lowerValue));
+
+      if (aStartsWith && !bStartsWith) return -1;
+      if (!aStartsWith && bStartsWith) return 1;
+
+      // Secondary sort by first value (name)
+      return (aCache.values[0] ?? '').localeCompare(bCache.values[0] ?? '');
+    });
+
+    // Get unique display values, prioritizing names over IDs
+    // The first value in the array should be the human-readable name
+    const uniqueValues = new Set<string>();
+    for (const item of matches) {
+      const { values, lowerValues } = getCachedValues(item);
+      // Find the first (name) value if it matches, otherwise find any matching value
+      // This ensures we prefer "Groceries" over the UUID when both match
+      let selectedValue: string | undefined;
+      for (let i = 0; i < values.length; i++) {
+        if (lowerValues[i]?.includes(lowerValue)) {
+          // Prefer the first matching value (typically the name), not the ID
+          // Only select this value if we haven't found a better one yet
+          if (selectedValue === undefined || i < values.indexOf(selectedValue)) {
+            selectedValue = values[i];
+          }
+          // Stop at first match - prioritizes name over ID since name comes first
+          break;
+        }
+      }
+      if (selectedValue) {
+        uniqueValues.add(selectedValue);
+      }
+      if (uniqueValues.size >= MAX_COMPLETIONS) break;
+    }
+
+    const resultValues = Array.from(uniqueValues).slice(0, MAX_COMPLETIONS);
+
+    return {
+      completion: {
+        values: resultValues,
+        total: matches.length,
+        hasMore: matches.length > MAX_COMPLETIONS,
+      },
+    };
+  }
+}

package/src/server/errorHandler.ts

@@ -121,6 +121,7 @@ export class ErrorHandler {
     }
 
     return {
+      isError: true,
       content: [
         {
           type: 'text',