@frihet/mcp-server 1.16.6 → 2.0.0

package/dist/tools/accountingClose.js

@@ -2,35 +2,48 @@
  * Period close tools for the Frihet MCP server — D4-B megasprint (3 tools).
  *
  * Tools:
- *   1. period_close_status — get the current accounting period state (open/closing/closed)
+ *   1. period_close_status — get the current or selected fiscal-year state
  *   2. period_close        — close a monthly or quarterly period (TRUST AREA)
  *   3. period_reopen       — reopen a closed period with required reason (TRUST AREA)
  *
  * REST surface: /v1/periods/current, /v1/periods/{id}, /v1/periods/close, /v1/periods/{id}/reopen
  *
- * Closing a period freezes invoices/expenses/journal entries. Reopening requires a
- * compliance reason logged for audit. These are TRUST AREA operations.
+ * STATE OF THE WORLD (verified against erp-main functions/src/publicApi/families/
+ * periods.ts): only the READ route is implemented. Both WRITE routes answer
+ * HTTP 501 NOT_IMPLEMENTED — "deferred to the upcoming fiscal-write wave (Trust,
+ * serialized). Use year-end closing in the app for now." Nothing is frozen, and
+ * there is no idempotent no-op to rely on, because there is no handler at all.
  *
- * NOTE: ERP backend endpoints land in parallel D4-A wave. 404s propagate as isError
- * until backend ships. TODO: confirm callable boundary vs REST shell for closePeriod.
+ * The descriptions below therefore state the 501 in the present tense. Do not
+ * restore aspirational prose about freezing or idempotency until a handler exists
+ * — GAP-13 was exactly that: an agent planning a year-end close read a mechanism
+ * the backend never had.
+ *
+ * `withBackendGuard` converts 404 only (backend-availability.ts isBackendNotFound),
+ * so a 501 surfaces through the generic error path as isError with the backend's
+ * own NOT_IMPLEMENTED message — an honest failure, not a fake success.
  */
 import { z } from "zod/v4";
-import { withToolLogging, formatRecord, getContent, mutateContent, READ_ONLY_ANNOTATIONS, periodStatusOutput, } from "./shared.js";
+import { withToolLogging, formatRecord, getContent, mutateContent, READ_ONLY_ANNOTATIONS, currentPeriodOutput, periodStatusOutput, } from "./shared.js";
 import { withBackendGuard } from "./backend-availability.js";
 export function registerAccountingCloseTools(server, client) {
     // -- period_close_status --
     server.registerTool("period_close_status", {
         title: "Period Close Status",
-        description: "Get the current accounting period state (open / closing / closed / reopened). " +
-            "Without periodId returns the current open or most recently closed period. " +
-            "/ Devuelve el estado del periodo contable actual (abierto/cerrando/cerrado/reabierto).",
+        description: "Get the open or closed state of the current fiscal year, including its fiscal-year start, " +
+            "inclusive date range, and nullable closing details. Pass a four-digit fiscal-year label to read it explicitly. " +
+            "/ Devuelve el estado abierto o cerrado del ejercicio fiscal actual o indicado.",
         annotations: READ_ONLY_ANNOTATIONS,
         inputSchema: {
-            periodId: z.string().optional().describe("Specific period ID (default: current) / ID periodo especifico"),
+            periodId: z
+                .string()
+                .regex(/^\d{4}$/)
+                .optional()
+                .describe("Compatibility field: fiscal-year label YYYY, not an arbitrary period ID (default: current) / Ejercicio fiscal YYYY"),
         },
-        outputSchema: periodStatusOutput,
-    }, async ({ periodId }) => withToolLogging("period_close_status", () => withBackendGuard("period_close_status", "/v1/periods/current", async () => {
-        const result = await client.getCurrentPeriod({ periodId });
+        outputSchema: currentPeriodOutput,
+    }, async ({ periodId }) => withToolLogging("period_close_status", () => withBackendGuard("period_close_status", periodId ? `/v1/periods/${periodId}` : "/v1/periods/current", async () => {
+        const result = await client.getCurrentPeriod({ fiscalYear: periodId });
         return {
             content: [getContent(formatRecord("Period status", result))],
             structuredContent: result,
@@ -39,12 +52,15 @@ export function registerAccountingCloseTools(server, client) {
     // -- period_close --
     server.registerTool("period_close", {
         title: "Close Accounting Period",
-        description: "TRUST AREA — FISCAL CLOSE. Close a monthly or quarterly accounting period. " +
-            "Freezes invoices, expenses, journal entries and bank reconciliations for the period. " +
-            "Requires confirm=true. Idempotent: re-closing an already closed period is a no-op. " +
-            "Closed periods can be reopened with period_reopen + audit reason. " +
-            "/ AREA DE CONFIANZA — CIERRE FISCAL. Cierra un periodo contable mensual o trimestral. " +
-            "Congela facturas, gastos, asientos. Requiere confirm=true.",
+        description: "TRUST AREA — FISCAL CLOSE. NOT IMPLEMENTED SERVER-SIDE TODAY: the backend answers " +
+            "HTTP 501 NOT_IMPLEMENTED to POST /v1/periods/close, so calling this tool closes nothing. " +
+            "No invoices, expenses, journal entries or bank reconciliations are frozen, and there is no " +
+            "idempotent no-op to rely on. Close the period in the Frihet app instead. " +
+            "The call is still gated behind confirm=true and will surface the 501 as an error. " +
+            "Use period_close_status (implemented) to read the current period state. " +
+            "/ AREA DE CONFIANZA — CIERRE FISCAL. HOY NO IMPLEMENTADO EN EL SERVIDOR: el backend responde " +
+            "HTTP 501 a POST /v1/periods/close, asi que esta herramienta no cierra nada ni congela nada. " +
+            "El cierre debe hacerse en la app de Frihet.",
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
         inputSchema: {
             type: z
@@ -81,10 +97,12 @@ export function registerAccountingCloseTools(server, client) {
     // -- period_reopen --
     server.registerTool("period_reopen", {
         title: "Reopen Accounting Period",
-        description: "TRUST AREA — FISCAL REOPEN. Reopen a closed accounting period. " +
-            "Requires a compliance reason (audit log) and confirm=true. " +
-            "Reopening allows backdated edits to invoices/expenses — use with extreme caution. " +
-            "/ AREA DE CONFIANZA — REAPERTURA FISCAL. Reabre un periodo cerrado. Requiere motivo (auditoria) y confirm=true.",
+        description: "TRUST AREA — FISCAL REOPEN. NOT IMPLEMENTED SERVER-SIDE TODAY: the backend answers " +
+            "HTTP 501 NOT_IMPLEMENTED to POST /v1/periods/{id}/reopen, so calling this tool reopens nothing " +
+            "and writes no audit entry. Reopen the period in the Frihet app instead. " +
+            "The call is still gated behind confirm=true plus a reason, and will surface the 501 as an error. " +
+            "/ AREA DE CONFIANZA — REAPERTURA FISCAL. HOY NO IMPLEMENTADO EN EL SERVIDOR: el backend responde " +
+            "HTTP 501, asi que no se reabre nada ni se registra auditoria. Hazlo en la app de Frihet.",
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
         inputSchema: {
             periodId: z.string().describe("Closed period ID to reopen / ID del periodo cerrado"),

package/dist/tools/audit_gl.js

@@ -44,20 +44,20 @@ export function registerAuditGLTools(server, client) {
     // -- frihet_gl_entry_reject ------------------------------------------------
     server.registerTool("frihet_gl_entry_reject", {
         title: "Reject GL Entry",
-        description: "Reject a General Ledger journal entry pending review with a required reason. " +
-            "Sets entry status to 'rejected' and records the rejector + reason in the audit trail. " +
+        description: "Reject a General Ledger journal entry pending review with a required note. " +
+            "Sets entry status to 'rejected' and records the rejector + note in the audit trail. " +
             "Requires gestor/admin role. This is a TRUST AREA action. " +
-            "Example: entryId='gl_2026_q1_042', reason='Importe incorrecto, revisar factura F-2026-042'. " +
-            "/ Rechaza un asiento contable pendiente con una razon obligatoria. " +
+            "Example: entryId='gl_2026_q1_042', note='Importe incorrecto, revisar factura F-2026-042'. " +
+            "/ Rechaza un asiento contable pendiente con una nota obligatoria. " +
             "Requiere rol gestor/admin.",
         annotations: UPDATE_ANNOTATIONS,
         inputSchema: {
             entryId: z.string().describe("GL entry ID to reject / ID del asiento contable a rechazar"),
-            reason: z.string().describe("Mandatory rejection reason (visible to submitter) / Razon del rechazo (obligatoria, visible al emisor)"),
+            note: z.string().min(1).describe("Mandatory rejection note (visible to submitter) / Nota del rechazo (obligatoria, visible al emisor)"),
         },
-        outputSchema: openObjectOutput("Rejected GL entry record with reason and audit trail entry / Asiento contable rechazado con motivo y entrada de auditoría"),
-    }, async ({ entryId, reason }) => withToolLogging("frihet_gl_entry_reject", () => withBackendGuard("frihet_gl_entry_reject", "/v1/gl/entries/reject", async () => {
-        const result = await client.rejectGLEntry(entryId, reason);
+        outputSchema: openObjectOutput("Rejected GL entry record with note and audit trail entry / Asiento contable rechazado con nota y entrada de auditoría"),
+    }, async ({ entryId, note }) => withToolLogging("frihet_gl_entry_reject", () => withBackendGuard("frihet_gl_entry_reject", "/v1/gl/entries/reject", async () => {
+        const result = await client.rejectGLEntry(entryId, note);
         return {
             content: [
                 mutateContent(formatRecord(`GL Entry ${entryId} rejected`, result)),

package/dist/tools/backend-availability.d.ts

@@ -1,12 +1,8 @@
 /**
  * Backend-availability guard for MCP tool handlers.
  *
- * PROBLEM (the bug this prevents): several tool families are wired here AHEAD of
- * their Frihet-ERP backend Cloud Functions shipping (fiscal `/v1/fiscal/*`, bank
- * rules `/v1/banking/rules`, gestoria `/v1/gestoria/*`, GL audit `/v1/gl/*`,
- * portal domain/onboard, IGIC, IS, VIES onboarding, payroll prep, permissions,
- * HR leaves/anomalies, accounting periods, webhook test). Until the CF deploys,
- * the API returns a genuine HTTP 404.
+ * HTTP 404 can mean an unavailable record, an unknown route, or an endpoint
+ * that is not enabled. The status alone cannot establish deployment state.
  *
  * If that raw 404 reaches `handleToolError` it is mapped to the generic message
  * "Resource not found. / Recurso no encontrado." — which an LLM reads as "the
@@ -14,9 +10,9 @@
  * ("you have no Modelo 303 to file", "this workspace has no permissions matrix").
  * That is a Trust-Area failure: the model invents fiscal/compliance facts.
  *
- * FIX: wrap the client call in `withBackendGuard`. A genuine 404 is converted into
- * an explicit STRUCTURED tool error that names the tool and states the backend is
- * not available yet — never a value the LLM can mistake for real business data.
+ * Preserve typed application NOT_FOUND errors for the normal denial handler.
+ * Ambiguous 404s remain explicit errors with no inferred data or deployment
+ * state. Only notDeployedError states that a route is not deployed.
  * Any other error (401/403/429/5xx/network) is RE-THROWN unchanged so the normal
  * `withToolLogging` → `handleToolError` path still surfaces it.
  *
@@ -46,27 +42,10 @@ export interface BackendGuardErrorResult {
  * Duck-typed so it works regardless of which client implementation threw.
  */
 export declare function isBackendNotFound(error: unknown): boolean;
-/**
- * Builds the explicit, LLM-safe "backend not available" tool error.
- */
+/** Builds the explicit error for a route known not to be deployed. */
 export declare function backendUnavailableError(toolName: string, endpoint?: string): BackendGuardErrorResult;
-/**
- * Wraps a tool's client call. On a genuine 404 (backend not deployed) returns a
- * structured backend-unavailable error instead of letting the raw 404 surface as
- * a generic "resource not found" that the LLM would treat as real data. Any other
- * error is re-thrown so `withToolLogging`/`handleToolError` handle it normally.
- *
- * Usage:
- * ```ts
- * async ({ period }) => withToolLogging("get_modelo_303_summary", () =>
- *   withBackendGuard("get_modelo_303_summary", "/v1/fiscal/303", async () => {
- *     const result = await client.getFiscalModeloSummary("303", period);
- *     return { content: [getContent(formatRecord("Modelo 303 Summary", result))],
- *              structuredContent: result as unknown as Record<string, unknown> };
- *   }),
- * )
- * ```
- */
+export declare function notDeployedError(toolName: string, endpoint: string): BackendGuardErrorResult;
+/** Keep application denials intact; ambiguous HTTP 404s are never empty data. */
 export declare function withBackendGuard<T extends {
     content: unknown[];
 }>(toolName: string, endpoint: string | undefined, fn: () => Promise<T>): Promise<T | BackendGuardErrorResult>;

package/dist/tools/backend-availability.js

@@ -1,12 +1,8 @@
 /**
  * Backend-availability guard for MCP tool handlers.
  *
- * PROBLEM (the bug this prevents): several tool families are wired here AHEAD of
- * their Frihet-ERP backend Cloud Functions shipping (fiscal `/v1/fiscal/*`, bank
- * rules `/v1/banking/rules`, gestoria `/v1/gestoria/*`, GL audit `/v1/gl/*`,
- * portal domain/onboard, IGIC, IS, VIES onboarding, payroll prep, permissions,
- * HR leaves/anomalies, accounting periods, webhook test). Until the CF deploys,
- * the API returns a genuine HTTP 404.
+ * HTTP 404 can mean an unavailable record, an unknown route, or an endpoint
+ * that is not enabled. The status alone cannot establish deployment state.
  *
  * If that raw 404 reaches `handleToolError` it is mapped to the generic message
  * "Resource not found. / Recurso no encontrado." — which an LLM reads as "the
@@ -14,9 +10,9 @@
  * ("you have no Modelo 303 to file", "this workspace has no permissions matrix").
  * That is a Trust-Area failure: the model invents fiscal/compliance facts.
  *
- * FIX: wrap the client call in `withBackendGuard`. A genuine 404 is converted into
- * an explicit STRUCTURED tool error that names the tool and states the backend is
- * not available yet — never a value the LLM can mistake for real business data.
+ * Preserve typed application NOT_FOUND errors for the normal denial handler.
+ * Ambiguous 404s remain explicit errors with no inferred data or deployment
+ * state. Only notDeployedError states that a route is not deployed.
  * Any other error (401/403/429/5xx/network) is RE-THROWN unchanged so the normal
  * `withToolLogging` → `handleToolError` path still surfaces it.
  *
@@ -38,9 +34,7 @@ export function isBackendNotFound(error) {
     }
     return false;
 }
-/**
- * Builds the explicit, LLM-safe "backend not available" tool error.
- */
+/** Builds the explicit error for a route known not to be deployed. */
 export function backendUnavailableError(toolName, endpoint) {
     const message = `The backend for "${toolName}" is not available yet, so no data could be retrieved. ` +
         `This is NOT an empty or zero result — the underlying Frihet ERP endpoint ` +
@@ -63,30 +57,37 @@ export function backendUnavailableError(toolName, endpoint) {
         isError: true,
     };
 }
-/**
- * Wraps a tool's client call. On a genuine 404 (backend not deployed) returns a
- * structured backend-unavailable error instead of letting the raw 404 surface as
- * a generic "resource not found" that the LLM would treat as real data. Any other
- * error is re-thrown so `withToolLogging`/`handleToolError` handle it normally.
- *
- * Usage:
- * ```ts
- * async ({ period }) => withToolLogging("get_modelo_303_summary", () =>
- *   withBackendGuard("get_modelo_303_summary", "/v1/fiscal/303", async () => {
- *     const result = await client.getFiscalModeloSummary("303", period);
- *     return { content: [getContent(formatRecord("Modelo 303 Summary", result))],
- *              structuredContent: result as unknown as Record<string, unknown> };
- *   }),
- * )
- * ```
- */
+/** An ambiguous 404 establishes neither missing business data nor deployment. */
+function lookupUnavailableError(toolName, endpoint) {
+    const message = `Frihet could not resolve the requested resource or endpoint for "${toolName}" (HTTP 404). ` +
+        `No data could be retrieved. Do not infer an empty or zero result, missing business records, or deployment status. ` +
+        `Check the record ID and feature availability before deciding whether to retry. ` +
+        `/ Frihet no pudo resolver el recurso o endpoint solicitado (HTTP 404). ` +
+        `No se recuperaron datos. No deduzcas un resultado vacío o cero, la ausencia de registros ni el estado del despliegue.`;
+    return {
+        content: [{ type: "text", text: `Error: ${message}`, annotations: ERROR_CONTENT_ANNOTATIONS }],
+        structuredContent: {
+            error: "lookup_unavailable", code: "LOOKUP_UNAVAILABLE", tool: toolName, message,
+            ...(endpoint ? { endpoint } : {}),
+        },
+        isError: true,
+    };
+}
+export function notDeployedError(toolName, endpoint) {
+    const result = backendUnavailableError(toolName, endpoint);
+    result.structuredContent = { ...result.structuredContent, code: "NOT_DEPLOYED" };
+    return result;
+}
+/** Keep application denials intact; ambiguous HTTP 404s are never empty data. */
 export async function withBackendGuard(toolName, endpoint, fn) {
     try {
         return await fn();
     }
     catch (err) {
         if (isBackendNotFound(err)) {
-            return backendUnavailableError(toolName, endpoint);
+            if (err.errorCode === "NOT_FOUND")
+                throw err;
+            return lookupUnavailableError(toolName, endpoint);
         }
         throw err;
     }

package/dist/tools/bank_rules.js

@@ -23,6 +23,13 @@ import { withBackendGuard } from "./backend-availability.js";
 const bankRuleItemOutput = z.object({
     id: z.string(),
     name: z.string(),
+    bankConditions: z.array(z.object({
+        field: z.string(),
+        operator: z.string(),
+        value: z.string(),
+    })).optional(),
+    action: z.string().optional(),
+    actionConfig: z.record(z.string(), z.unknown()).optional(),
     conditions: z.array(z.object({
         field: z.string(),
         operator: z.string(),
@@ -35,8 +42,39 @@ const bankRuleItemOutput = z.object({
     isActive: z.boolean().optional(),
     createdAt: z.string().optional(),
 }).passthrough();
-const CONDITION_FIELD = z.enum(["description", "amount", "counterparty", "iban", "reference"]);
-const CONDITION_OPERATOR = z.enum(["contains", "startsWith", "endsWith", "equals", "greaterThan", "lessThan"]);
+// ERP authority: functions/src/banking/bankRuleCreate.ts
+//   BANK_RULE_FIELDS    = ['description', 'reference', 'amount', 'counterparty']
+//   BANK_RULE_OPERATORS = ['contains', 'exact', 'starts_with', 'ends_with', 'regex',
+//                          'amount_above', 'amount_below', 'amount_between']
+//   BANK_RULE_ACTIONS   = ['categorize_expense', 'match_invoice', 'match_client',
+//                          'ignore', 'create_expense', 'flag_review']
+//
+// Per-action required actionConfig shape (ERP):
+//   categorize_expense → { category: string }
+//   match_client       → { clientId: string }
+//   create_expense     → { expenseDefaults: { vendor?, category?, taxRate?, description? } }
+//   flag_review        → { flag: string }
+//   match_invoice      → (no required config)
+//   ignore             → (no required config)
+const CONDITION_FIELD = z.enum(["description", "reference", "amount", "counterparty"]);
+const CONDITION_OPERATOR = z.enum([
+    "contains",
+    "exact",
+    "starts_with",
+    "ends_with",
+    "regex",
+    "amount_above",
+    "amount_below",
+    "amount_between",
+]);
+const RULE_ACTION = z.enum([
+    "categorize_expense",
+    "match_invoice",
+    "match_client",
+    "ignore",
+    "create_expense",
+    "flag_review",
+]);
 export function registerBankRulesTools(server, client) {
     // -- frihet_bank_rules_list -----------------------------------------------
     server.registerTool("frihet_bank_rules_list", {
@@ -65,28 +103,41 @@ export function registerBankRulesTools(server, client) {
         title: "Create Bank Categorization Rule",
         description: "Create a new bank auto-categorization rule. " +
             "Rules apply automatically to matching incoming transactions. " +
-            "A rule has conditions (AND logic) and actions (assign category, tag, or client). " +
-            "Example: name='Mercadona groceries', condition description contains 'MERCADONA', " +
-            "action category='groceries'. " +
+            "The ERP new-engine vocabulary: `bankConditions` (AND logic) + a single `action` " +
+            "(`categorize_expense` | `match_invoice` | `match_client` | `ignore` | " +
+            "`create_expense` | `flag_review`) and its `actionConfig` payload. " +
+            "Required actionConfig per action: categorize_expense→{category}, " +
+            "match_client→{clientId}, create_expense→{expenseDefaults:{vendor,category,…}}, " +
+            "flag_review→{flag}; match_invoice and ignore require no config. " +
+            "Example: name='Mercadona groceries', bankConditions=[{field:'description', " +
+            "operator:'contains', value:'MERCADONA'}], action='categorize_expense', " +
+            "actionConfig={category:'groceries'}. " +
             "/ Crea una nueva regla de categorizacion automatica de transacciones bancarias. " +
-            "Las reglas aplican condiciones (logica AND) y acciones (categoria, etiqueta, cliente).",
+            "El nuevo motor ERP espera `bankConditions` (logica AND) y un unico `action` con su `actionConfig`.",
         annotations: CREATE_ANNOTATIONS,
         inputSchema: {
             name: z.string().describe("Rule name for identification / Nombre de la regla"),
-            conditions: z.array(z.object({
+            bankConditions: z
+                .array(z.object({
                 field: CONDITION_FIELD.describe("Transaction field to match / Campo de transaccion a comparar"),
                 operator: CONDITION_OPERATOR.describe("Comparison operator / Operador de comparacion"),
                 value: z.string().describe("Value to match against / Valor a comparar"),
-            })).min(1).describe("Rule conditions (AND logic — all must match) / Condiciones (logica AND — todas deben cumplirse)"),
-            actions: z.array(z.object({
-                type: z.enum(["setCategory", "addTag", "assignClient"]).describe("Action type / Tipo de accion"),
-                value: z.string().describe("Action value (category name, tag name, or client ID) / Valor de la accion"),
-            })).min(1).describe("Actions to apply when rule matches / Acciones a aplicar cuando la regla se cumple"),
+            }))
+                .min(1)
+                .describe("Rule conditions (AND logic — all must match) / Condiciones (logica AND — todas deben cumplirse)"),
+            action: RULE_ACTION.describe("Action to apply when the rule matches / Accion a aplicar cuando la regla se cumple"),
+            actionConfig: z
+                .record(z.string(), z.unknown())
+                .describe("Action-specific payload. categorize_expense requires {category:string}. " +
+                "match_client requires {clientId:string}. create_expense requires " +
+                "{expenseDefaults:{vendor:string, category:string, taxRate?:number, description?:string}}. " +
+                "flag_review requires {flag:string}. match_invoice and ignore require no config. " +
+                "/ Payload segun la accion."),
             isActive: z.boolean().optional().describe("Whether the rule is active (default true) / Si la regla esta activa (por defecto true)"),
         },
-        outputSchema: openObjectOutput("Created bank rule record with ID, conditions and actions / Regla bancaria creada con ID, condiciones y acciones"),
-    }, async ({ name, conditions, actions, isActive }) => withToolLogging("frihet_bank_rule_create", () => withBackendGuard("frihet_bank_rule_create", "/v1/banking/rules", async () => {
-        const result = await client.createBankRule({ name, conditions, actions, isActive });
+        outputSchema: openObjectOutput("Created bank rule record with ID, conditions and action / Regla bancaria creada con ID, condiciones y accion"),
+    }, async ({ name, bankConditions, action, actionConfig, isActive }) => withToolLogging("frihet_bank_rule_create", () => withBackendGuard("frihet_bank_rule_create", "/v1/banking/rules", async () => {
+        const result = await client.createBankRule({ name, bankConditions, action, actionConfig, isActive });
         return {
             content: [
                 mutateContent(formatRecord(`Bank rule created: ${name}`, result)),

package/dist/tools/banking.js

@@ -16,7 +16,7 @@
  * src/__tests__/banking-client-contract.test.ts.
  */
 import { z } from "zod/v4";
-import { withToolLogging, formatPaginatedResponse, formatRecord, listContent, getContent, mutateContent, READ_ONLY_ANNOTATIONS, UPDATE_ANNOTATIONS, paginatedOutput, bankAccountItemOutput, bankTransactionItemOutput, } from "./shared.js";
+import { withToolLogging, confirmationRequiredError, formatPaginatedResponse, formatRecord, listContent, getContent, mutateContent, READ_ONLY_ANNOTATIONS, UPDATE_ANNOTATIONS, paginatedOutput, bankAccountItemOutput, bankTransactionItemOutput, } from "./shared.js";
 export function registerBankingTools(server, client) {
     // -- list_bank_accounts --
     server.registerTool("list_bank_accounts", {
@@ -134,18 +134,10 @@ export function registerBankingTools(server, client) {
         outputSchema: bankTransactionItemOutput,
     }, async ({ transactionId, documentId, documentType, confirm, notes }) => withToolLogging("match_transaction_to_invoice", async () => {
         if (!confirm) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "Error: confirm=true is required to perform fiscal reconciliation. " +
-                            "This action links a bank transaction to a fiscal document and cannot be undone easily. " +
-                            "Set confirm=true when you are certain about the match. / " +
-                            "Se requiere confirm=true para realizar la conciliacion fiscal.",
-                    },
-                ],
-                isError: true,
-            };
+            return confirmationRequiredError("Error: confirm=true is required to perform fiscal reconciliation. " +
+                "This action links a bank transaction to a fiscal document and cannot be undone easily. " +
+                "Set confirm=true when you are certain about the match. / " +
+                "Se requiere confirm=true para realizar la conciliacion fiscal.");
         }
         const result = await client.matchTransactionToDocument(transactionId, { documentId, documentType, notes });
         return {