@frihet/mcp-server 1.17.0 → 2.0.0

package/dist/tool-exposure.js

@@ -6,7 +6,7 @@
  * the outer public composition may still attach capability truth metadata.
  *
  * ── Why ──────────────────────────────────────────────────────────────────
- * Context rot is the 2026 problem: a flat list of 157 tool descriptions,
+ * Context rot is the 2026 problem: a flat list of 158 tool descriptions,
  * each a multi-paragraph bilingual blob, eats the agent's context window and
  * degrades tool selection before any work begins. Leaders cut flat lists.
  *
@@ -30,12 +30,12 @@
  *        • search_tools(query)     — fuzzy match → matching tool summaries
  *        • describe_tool(name)     — full original description + input fields
  *
- * The agent loads ~3 meta-tool descriptions + 157 terse one-liners instead of
- * 157 full bilingual blobs, then pulls full depth only for the handful of
+ * The agent loads ~3 meta-tool descriptions + 158 terse one-liners instead of
+ * 158 full bilingual blobs, then pulls full depth only for the handful of
  * tools it actually needs. Progressive disclosure, zero behavior change.
  *
  * IMPORTANT: this is purely an EXPOSURE layer. It does NOT live in
- * src/tools/*.ts, so the audited tool count stays 157 (+ meta). The meta-tools
+ * src/tools/*.ts, so the audited tool count stays 158 (+ meta). The meta-tools
  * are added only in grouped mode and are NOT counted as ERP tools.
  *
  * @see ./openai-profile.ts — the sibling interceptor this mirrors.
@@ -61,8 +61,9 @@ export const GROUPS = {
     },
     fiscal: {
         label: "Fiscal & compliance / Fiscal y cumplimiento",
-        blurb: "Spanish/EU fiscal depth served on demand: Modelo 303/130/390/180/347/200/202/415/425/418, " +
-            "VeriFactu, TicketBAI, Facturae/FACe/KSeF e-invoicing, IGIC/AIEM, GL audit, period close, VIES.",
+        blurb: "Spanish/EU fiscal depth served on demand: Modelo 303/130/390/347, VeriFactu, TicketBAI, " +
+            "Facturae/FACe e-invoicing, GL audit, period close, VIES " +
+            "(Modelo 180/200/202/415/418/425, AIEM and KSeF registered but not deployed).",
     },
     banking: {
         label: "Banking / Banca",
@@ -133,13 +134,14 @@ export const FILE_TO_GROUP = {
     kitchen: "pos",
     intelligence: "intelligence",
     gestoria: "intelligence",
+    search: "intelligence",
     products: "catalog",
     webhooks: "platform",
     portal_domain: "platform",
 };
 /**
  * Per-tool overrides where the source FILE places a tool in a different group
- * than a naive name match would (verified against the 157 registration sites).
+ * than a naive name match would (verified against the 158 registration sites).
  * These eight names live in a file whose domain differs from their name prefix
  * (e.g. e-invoicing tools say "invoice" but belong to fiscal/compliance).
  */
@@ -159,7 +161,7 @@ const NAME_OVERRIDES = {
 };
 /**
  * Assign a group by tool NAME. The name-based mapping reproduces the
- * source-file grouping exactly for all 157 current tools (verified), with the
+ * source-file grouping exactly for every current tool (verified), with the
  * eight cross-file cases pinned via NAME_OVERRIDES. Driven off the name (not a
  * hand-kept list) so a future tool lands somewhere sensible automatically.
  *
@@ -188,7 +190,7 @@ export function groupForTool(name) {
         return "pos";
     if (/(kitchen|menu_item)/.test(n))
         return "pos";
-    if (/(business_context|monthly_summary|gestoria)/.test(n))
+    if (/(business_context|monthly_summary|gestoria|global_search)/.test(n))
         return "intelligence";
     if (/(product)/.test(n))
         return "catalog";
@@ -206,7 +208,7 @@ function firstSentence(desc) {
     const match = englishHalf.match(/^(.*?[.!?])(\s|$)/);
     const sentence = (match ? match[1] : englishHalf).trim();
     // Hard cap so a runaway description can't reintroduce context bloat.
-    return sentence.length > 160 ? sentence.slice(0, 157).trimEnd() + "…" : sentence;
+    return sentence.length > 160 ? sentence.slice(0, 158).trimEnd() + "…" : sentence;
 }
 function inputSchemaFieldNames(schema) {
     if (schema instanceof z.ZodObject) {
@@ -388,7 +390,7 @@ server, options) {
     };
     // Register the meta-tools eagerly. Their handlers close over `catalog`/`groups`
     // which finish populating as the real tools register right after this call.
-    registerMetaTools(originalRegisterTool, handle, visibleGroupIds, groupMetadata, options?.capabilityTruth, options?.securitySchemes);
+    registerMetaTools(originalRegisterTool, handle, visibleGroupIds, groupMetadata, options?.capabilityTruth, options?.securitySchemes, options?.describeToolExample);
     return handle;
 }
 /* ------------------------------------------------------------------ */
@@ -418,7 +420,7 @@ function textResult(payload) {
  */
 function registerMetaTools(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-originalRegisterTool, handle, visibleGroupIds, groupMetadata, capabilityTruth, securitySchemes) {
+originalRegisterTool, handle, visibleGroupIds, groupMetadata, capabilityTruth, securitySchemes, describeToolExample = "create_invoice") {
     const { catalog, groups } = handle;
     const oauthConfig = securitySchemes
         ? {
@@ -461,7 +463,7 @@ originalRegisterTool, handle, visibleGroupIds, groupMetadata, capabilityTruth, s
     const describeToolInputShape = {
         name: z
             .string()
-            .describe("Exact tool name as returned by search_tools (e.g. 'create_invoice') / " +
+            .describe(`Exact tool name as returned by search_tools (e.g. '${describeToolExample}') / ` +
             "Nombre exacto de la herramienta devuelto por search_tools."),
     };
     const listGroupsOutput = securitySchemes

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, and webhook test). Until a
- * staged CF deploys, the API returns a genuine HTTP 404. Live HR, payroll-read,
- * and period-read tools also retain this guard as workspace-rollout safety.
+ * 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, and webhook test). Until a
- * staged CF deploys, the API returns a genuine HTTP 404. Live HR, payroll-read,
- * and period-read tools also retain this guard as workspace-rollout safety.
+ * 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 {