@ema.co/mcp-toolkit 2026.2.19 → 2026.2.23

package/dist/mcp/tools.js

@@ -1,12 +1,14 @@
 /**
  * MCP Tools v2 - Minimal, LLM-optimized tool set with explicit methods
  *
- * 5 tools:
+ * 7 tools:
  * 1. persona  - AI Employee entity + data + incremental modifications
  * 2. catalog  - Reference data (actions, templates, widgets, voices, patterns)
  * 3. workflow - Complex workflow generation/compilation
  * 4. sync     - Cross-environment operations
  * 5. env      - Environment info
+ * 6. toolkit_feedback - Agent feedback collection
+ * 7. debug    - Audit conversations + workflow execution traces
  *
  * Design principles:
  * - ALL operations require explicit `method` or `mode` parameter
@@ -222,6 +224,23 @@ persona(
                         type: "string",
                         description: "Version to restore, e.g. 'v3' (for method=restore)"
                     },
+                    // === Debug sub-resource ===
+                    debug: {
+                        type: "object",
+                        description: "Debug operations (requires persona id)",
+                        properties: {
+                            method: {
+                                type: "string",
+                                enum: ["conversations", "conversation_detail", "show_work", "action_detail", "search"],
+                                description: "Debug operation to perform (required)"
+                            },
+                            conversation_id: { type: "string", description: "Conversation ID (for conversation_detail)" },
+                            workflow_run_id: { type: "string", description: "Workflow run ID (for show_work, action_detail)" },
+                            action_name: { type: "string", description: "Action name (for action_detail)" },
+                            query: { type: "string", description: "Search query (for search)" },
+                        },
+                        required: ["method"],
+                    },
                     // === Data sub-resource ===
                     data: {
                         type: "object",
@@ -625,6 +644,90 @@ persona(
                 required: ["method"],
             },
         },
+        // ═══════════════════════════════════════════════════════════════════════════
+        // 7. DEBUG - Audit conversations + workflow execution traces
+        // ═══════════════════════════════════════════════════════════════════════════
+        {
+            name: "debug",
+            description: `Inspect workflow executions and audit conversations. Drill down from conversations → messages → workflow traces → action details.
+
+**IMPORTANT**: All operations require explicit \`method\` parameter.
+
+## Typical debugging flow
+1. \`debug(method="conversations", persona_id="abc")\` - list audit conversations
+2. \`debug(method="conversation_detail", conversation_id="...")\` - see messages with workflow_run_ids
+3. \`debug(method="show_work", persona_id="abc", workflow_run_id="...")\` - see all actions' execution traces
+4. \`debug(method="action_detail", persona_id="abc", workflow_run_id="...", action_name="...")\` - deep trace (inputs, outputs, LLM calls, steps)
+
+## Search
+- \`debug(method="search", persona_id="abc", query="pricing")\` - full-text search across conversation messages
+
+## Also available as persona sub-resource
+- \`persona(id="abc", debug={method:"conversations"})\` - same as debug tool but scoped to persona`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    method: {
+                        type: "string",
+                        enum: ["conversations", "conversation_detail", "show_work", "action_detail", "search"],
+                        description: "Operation to perform (required)",
+                    },
+                    persona_id: {
+                        type: "string",
+                        description: "Persona ID (required for conversations, show_work, action_detail, search)",
+                    },
+                    conversation_id: {
+                        type: "string",
+                        description: "Conversation ID (for method=conversation_detail, or to scope search)",
+                    },
+                    workflow_run_id: {
+                        type: "string",
+                        description: "Workflow run ID (for method=show_work, action_detail)",
+                    },
+                    action_name: {
+                        type: "string",
+                        description: "Action name within the workflow (for method=action_detail). Get from show_work results.",
+                    },
+                    query: {
+                        type: "string",
+                        description: "Search query string (for method=search)",
+                    },
+                    start_time: {
+                        type: "string",
+                        description: "Filter start time as ISO string (for method=conversations, search)",
+                    },
+                    end_time: {
+                        type: "string",
+                        description: "Filter end time as ISO string (for method=conversations, search)",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max results to return (for method=conversations)",
+                    },
+                    offset: {
+                        type: "number",
+                        description: "Pagination offset (for method=conversations)",
+                    },
+                    channel: {
+                        type: "string",
+                        description: "Filter by channel (for method=conversations)",
+                    },
+                    resolution: {
+                        type: "string",
+                        description: "Filter by resolution status (for method=conversations)",
+                    },
+                    rating: {
+                        type: "string",
+                        description: "Filter by user rating (for method=conversations)",
+                    },
+                    env: {
+                        type: "string",
+                        description: envDescription,
+                    },
+                },
+                required: ["method"],
+            },
+        },
     ];
 }
 /**
@@ -632,7 +735,6 @@ persona(
  * These still work for backwards compat but aren't in the tool list
  */
 export const INTERNAL_TOOLS = [
-    "knowledge", // → persona(id=..., data={method:...})
     "demo", // → persona(id=..., data={method:"upload", content:...})
     "action", // → catalog(method="list", type="actions")
     "template", // → catalog(method="list", type="templates")

package/dist/sdk/client-adapter.js

@@ -20,6 +20,10 @@
  * ```
  */
 import { EmaClientV2 } from './ema-client.js';
+import { toJson } from '@bufbuild/protobuf';
+import { GetConversationReviewsResponseSchema, GetConversationReviewDetailResponseSchema, } from './generated/protos/service/conversation_review/v1/conversation_review_pb.js';
+import { WorkflowLevelDebugLogResponseSchema, ActionLevelShowWorkLogResponseSchema, } from './generated/protos/service/persona/v1/debug_logs_pb.js';
+import { SearchMessagesResponseSchema, } from './generated/protos/service/debugger/service_pb.js';
 /**
  * Adapter that wraps EmaClientV2 with the legacy EmaClient interface.
  *
@@ -30,6 +34,9 @@ export class EmaClientAdapter {
     env;
     tokenRefreshConfig;
     refreshIntervalId;
+    static SYNC_TAG_REGEX = /<!-- synced_from:([^/]+)\/([a-f0-9-]+) -->/;
+    static LEGACY_JSON_REGEX = /<!-- _ema_sync:(.+?) -->/;
+    static SYNC_CLEANUP_REGEX = /<!-- (?:synced_from|sync|_ema_sync):[^\n]*-->/g;
     constructor(env, opts) {
         this.env = env;
         this.client = new EmaClientV2(env);
@@ -65,6 +72,8 @@ export class EmaClientAdapter {
         }
         try {
             const newToken = await this.tokenRefreshConfig.refreshCallback();
+            if (!newToken)
+                return false;
             this.updateToken(newToken);
             return true;
         }
@@ -136,18 +145,22 @@ export class EmaClientAdapter {
         }
     }
     /**
-     * Create a new AI Employee
+     * Create a new AI Employee.
+     * Passes all fields through to the V2 client (template_id, source_persona_id, etc.)
      */
-    async createAiEmployee(req) {
-        // persona_template_id is required by the API
+    async createAiEmployee(req, _opts) {
         const templateId = req.persona_template_id ?? req.template_id;
-        if (!templateId) {
-            throw new Error('persona_template_id or template_id is required');
+        if (!templateId && !req.source_persona_id) {
+            throw new Error('persona_template_id, template_id, or source_persona_id is required');
         }
         const result = await this.client.createAiEmployee({
             name: req.name,
-            persona_template_id: templateId,
+            template_id: templateId,
             description: req.description,
+            source_persona_id: req.source_persona_id,
+            clone_data: req.clone_data,
+            proto_config: req.proto_config,
+            trigger_type: req.trigger_type,
         });
         return {
             persona_id: result.persona_id ?? '',
@@ -157,7 +170,7 @@ export class EmaClientAdapter {
     /**
      * Update an existing AI Employee
      */
-    async updateAiEmployee(req) {
+    async updateAiEmployee(req, _opts) {
         const result = await this.client.updateAiEmployee({
             persona_id: req.persona_id,
             workflow: req.workflow,
@@ -231,15 +244,38 @@ export class EmaClientAdapter {
     // Dashboard Operations
     // ═══════════════════════════════════════════════════════════════════════════
     /**
-     * Get dashboard schema
+     * Get dashboard rows via gRPC.
+     * Proto response is structurally compatible with legacy DashboardRowsResponse.
      */
-    async getDashboardSchema(personaId, _dashboardId) {
-        const response = await this.client.getDashboardSchema();
-        // Extract columns from proto response
-        const schema = response;
-        return {
-            columns: schema.schema?.columns ?? [],
-        };
+    async getDashboardRows(dashboardId, personaId, opts) {
+        const response = await this.client.getDashboardRows(dashboardId, personaId, { limit: opts?.limit });
+        return response;
+    }
+    /**
+     * Get dashboard row result (for polling completion status and retrieving output).
+     */
+    async getDashboardRowResult(personaId, rowId, includeFileContents) {
+        return this.client.getDashboardRowResult(personaId, rowId, includeFileContents);
+    }
+    /**
+     * Upload inputs and run a new dashboard row (triggers workflow execution).
+     */
+    async uploadAndRunDashboardRow(personaId, inputs) {
+        return this.client.uploadAndRunDashboardRow(personaId, inputs);
+    }
+    /**
+     * Re-run the workflow for an existing dashboard row.
+     */
+    async rerunDashboardRow(personaId, rowId) {
+        return this.client.rerunDashboardRow(personaId, rowId);
+    }
+    /**
+     * Get dashboard schema (columns).
+     * Legacy signature takes (dashboardId, personaId).
+     */
+    async getDashboardSchema(dashboardId, personaId) {
+        const rows = await this.getDashboardRows(dashboardId, personaId, { limit: 1 });
+        return rows.schema;
     }
     // ═══════════════════════════════════════════════════════════════════════════
     // Data Source Operations
@@ -323,20 +359,66 @@ export class EmaClientAdapter {
         return this.client.waitForReplication(requestId, personaId, opts);
     }
     // ═══════════════════════════════════════════════════════════════════════════
+    // Document Generation Operations
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Create a new document generation request.
+     * Returns immediately with a document_id for polling.
+     */
+    async createDocument(personaId, instructions) {
+        const result = await this.client.createDocument(personaId, instructions);
+        return result;
+    }
+    /**
+     * Retrieve document generation status and content.
+     * Poll until status is COMPLETED or FAILED.
+     */
+    async retrieveDocument(personaId, documentId, projectId) {
+        const result = await this.client.retrieveDocument(personaId, documentId, projectId);
+        return result;
+    }
+    /**
+     * Generate a document end-to-end: create + poll until completion.
+     */
+    async generateDocument(personaId, instructions, opts) {
+        const result = await this.client.generateDocument(personaId, instructions, opts);
+        return result;
+    }
+    /**
+     * Regenerate a section of a document based on user instructions.
+     */
+    async regenerateDocument(personaId, request) {
+        const result = await this.client.regenerateDocument(personaId, request);
+        return result;
+    }
+    /**
+     * Update (replace) the content of a document.
+     */
+    async updateDocument(personaId, request) {
+        const result = await this.client.updateDocument(personaId, request);
+        return result;
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
     // Sync Metadata Operations
     // ═══════════════════════════════════════════════════════════════════════════
     /**
-     * Get sync metadata from a persona
+     * Get sync metadata from a persona's description.
+     * Supports compact format (<!-- synced_from:env/id -->),
+     * legacy JSON format (<!-- _ema_sync:{...} -->),
+     * and proto_config._ema_sync fallback.
      */
     getSyncMetadata(persona) {
-        // Sync metadata is stored in custom_metadata
-        const customMeta = persona.custom_metadata;
-        if (!customMeta)
-            return null;
-        const syncData = customMeta['ema_mcp_sync'];
-        if (!syncData || typeof syncData !== 'object')
-            return null;
-        return syncData;
+        const desc = persona.description;
+        if (desc) {
+            const meta = this.extractSyncMetadataFromString(desc);
+            if (meta)
+                return meta;
+        }
+        const protoConfig = persona.proto_config;
+        if (protoConfig?._ema_sync) {
+            return protoConfig._ema_sync;
+        }
+        return null;
     }
     /**
      * Check if persona was synced from another environment
@@ -344,6 +426,133 @@ export class EmaClientAdapter {
     isSyncedPersona(persona) {
         return this.getSyncMetadata(persona) !== null;
     }
+    /**
+     * List all personas that have sync metadata.
+     */
+    async listSyncedPersonas() {
+        const personas = await this.getPersonasForTenant();
+        const synced = [];
+        for (const p of personas) {
+            const meta = this.getSyncMetadata(p);
+            if (meta) {
+                synced.push({ persona: p, syncMetadata: meta });
+            }
+        }
+        return synced;
+    }
+    /**
+     * Find a synced persona by its master environment and master ID.
+     */
+    async findSyncedPersona(masterEnv, masterId) {
+        const synced = await this.listSyncedPersonas();
+        return (synced.find((s) => s.syncMetadata.master_env === masterEnv && s.syncMetadata.master_id === masterId) ?? null);
+    }
+    /**
+     * Tag a persona as synced by appending metadata to description.
+     */
+    async tagAsSynced(personaId, metadata, currentDescription, existingProtoConfig) {
+        const cleanDesc = this.getCleanDescription(currentDescription);
+        const marker = `<!-- synced_from:${metadata.master_env}/${metadata.master_id} -->`;
+        const newDescription = cleanDesc ? `${cleanDesc}\n\n${marker}` : marker;
+        await this.updateAiEmployee({
+            persona_id: personaId,
+            proto_config: existingProtoConfig ?? {},
+            description: newDescription,
+        });
+    }
+    /**
+     * Remove sync metadata from a persona (unlink from master).
+     */
+    async removeSyncTag(personaId, currentDescription, existingProtoConfig) {
+        const cleanDesc = this.getCleanDescription(currentDescription);
+        await this.updateAiEmployee({
+            persona_id: personaId,
+            proto_config: existingProtoConfig ?? {},
+            description: cleanDesc,
+        });
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Utility Operations
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * Extract file list from persona's status_log.
+     */
+    extractFilesFromStatusLog(persona, widgetName = "fileUpload") {
+        const statusLog = persona.status_log;
+        if (!statusLog)
+            return [];
+        const files = statusLog[widgetName];
+        if (!Array.isArray(files))
+            return [];
+        return files
+            .filter((f) => typeof f === "object" && f !== null)
+            .map((f) => ({
+            id: f.id ?? f.filename ?? "",
+            filename: f.filename ?? f.id ?? "",
+            status: f.status ?? "unknown",
+            tags: Array.isArray(f.tags) ? f.tags : undefined,
+        }))
+            .filter((f) => f.id !== "");
+    }
+    /**
+     * Get workflow definition by workflow_id.
+     * Not used by handlers — falls back gracefully.
+     */
+    async getWorkflowDef(_workflowId) {
+        // V2 client doesn't expose a direct getWorkflow-by-id method.
+        // Handlers get workflow_def from getPersonaById() instead.
+        return null;
+    }
+    /**
+     * Check/validate a workflow definition.
+     */
+    async checkWorkflow(workflowDef) {
+        const result = await this.client.checkWorkflow(workflowDef);
+        return result;
+    }
+    // ═══════════════════════════════════════════════════════════════════════════
+    // Debug / Audit Operations
+    // ═══════════════════════════════════════════════════════════════════════════
+    /**
+     * List audit conversations for a persona with optional filters.
+     * Uses toJson() for proper proto→JSON serialization of Timestamp and nested types.
+     *
+     * Opts shape matches EmaClientV2 / GrpcClient exactly — no translation needed.
+     */
+    async getConversationReviews(personaId, opts) {
+        const response = await this.client.getConversationReviews(personaId, opts);
+        return toJson(GetConversationReviewsResponseSchema, response);
+    }
+    /**
+     * Get full conversation detail including messages with workflow_run_ids.
+     */
+    async getConversationReviewDetail(conversationId) {
+        const response = await this.client.getConversationReviewDetail(conversationId);
+        return toJson(GetConversationReviewDetailResponseSchema, response);
+    }
+    /**
+     * Get workflow-level debug log (all actions' show work for a run).
+     * personaId is required — DebugLogService uses X-Persona-Id header for auth.
+     */
+    async getWorkflowLevelDebugLog(workflowRunId, personaId) {
+        const response = await this.client.getWorkflowLevelDebugLog(workflowRunId, personaId);
+        return toJson(WorkflowLevelDebugLogResponseSchema, response);
+    }
+    /**
+     * Get action-level show work log (deep trace for a single action).
+     * personaId is required — DebugLogService uses X-Persona-Id header for auth.
+     */
+    async getActionLevelShowWorkLog(actionName, workflowRunId, personaId) {
+        const response = await this.client.getActionLevelShowWorkLog(actionName, workflowRunId, personaId);
+        return toJson(ActionLevelShowWorkLogResponseSchema, response);
+    }
+    /**
+     * Full-text search across conversation messages.
+     */
+    async searchMessages(opts) {
+        const response = await this.client.searchMessages(opts);
+        return toJson(SearchMessagesResponseSchema, response);
+    }
     // ═══════════════════════════════════════════════════════════════════════════
     // Private Helpers
     // ═══════════════════════════════════════════════════════════════════════════
@@ -388,6 +597,38 @@ export class EmaClientAdapter {
             proto_config: t.proto_config,
         };
     }
+    /**
+     * Extract sync metadata from a string (description field).
+     * Supports compact format and legacy JSON format.
+     */
+    extractSyncMetadataFromString(text) {
+        const compactMatch = text.match(EmaClientAdapter.SYNC_TAG_REGEX);
+        if (compactMatch) {
+            return {
+                master_env: compactMatch[1],
+                master_id: compactMatch[2],
+                synced_at: new Date().toISOString(),
+            };
+        }
+        const legacyMatch = text.match(EmaClientAdapter.LEGACY_JSON_REGEX);
+        if (legacyMatch) {
+            try {
+                return JSON.parse(legacyMatch[1]);
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract the clean description (without sync marker).
+     */
+    getCleanDescription(description) {
+        if (!description)
+            return "";
+        return description.replace(EmaClientAdapter.SYNC_CLEANUP_REGEX, "").trim();
+    }
     /**
      * Convert null to undefined for type compatibility
      */

package/dist/sdk/ema-client.js

@@ -38,14 +38,49 @@ function createRestClient(env) {
         request.headers.set('Authorization', `Bearer ${env.bearerToken}`);
         return request;
     });
-    // Add error handling interceptor
+    // Add error handling interceptor — preserve full response body for debugging
     client.interceptors.response.use(async (response) => {
         if (!response.ok) {
             const body = await response.text().catch(() => '');
+            let detail = response.statusText;
+            try {
+                const parsed = JSON.parse(body);
+                const parts = [];
+                if (parsed.detail)
+                    parts.push(parsed.detail);
+                if (parsed.message)
+                    parts.push(parsed.message);
+                if (parsed.error)
+                    parts.push(parsed.error);
+                if (parsed.gwe_issues) {
+                    const gwe = parsed.gwe_issues;
+                    if (gwe.detail)
+                        parts.push(`GWE: ${gwe.detail}`);
+                    if (Array.isArray(gwe.missing_inputs)) {
+                        parts.push(`Missing inputs: ${gwe.missing_inputs.map((i) => `${i.action_name}.${i.input_name}`).join(', ')}`);
+                    }
+                    if (Array.isArray(gwe.mismatched_inputs)) {
+                        parts.push(`Mismatched inputs: ${gwe.mismatched_inputs.map((i) => `${i.action_name}.${i.input_name}`).join(', ')}`);
+                    }
+                    if (Array.isArray(gwe.named_result_errors)) {
+                        parts.push(`Result errors: ${gwe.named_result_errors.map((e) => `${e.named_result_key}: ${e.error_description}`).join('; ')}`);
+                    }
+                    if (gwe.has_cycles)
+                        parts.push('Workflow has cycles');
+                    if (gwe.has_no_outputs)
+                        parts.push('Workflow has no outputs');
+                }
+                if (parts.length > 0)
+                    detail = parts.join(' | ');
+            }
+            catch {
+                if (body)
+                    detail = body.slice(0, 500);
+            }
             throw new EmaApiError({
                 statusCode: response.status,
                 body,
-                message: `API error (${response.status}): ${response.statusText}`,
+                message: `API error (${response.status}): ${detail}`,
             });
         }
         return response;
@@ -163,12 +198,24 @@ export class EmaClientV2 {
         }
     }
     /**
-     * Create a new persona from a template
+     * Create a new persona from a template.
+     *
+     * Handles field name translation: callers use `persona_template_id` (legacy)
+     * but the generated API expects `template_id`.
      */
     async createPersona(data) {
+        const templateId = data.template_id ?? data.persona_template_id;
         const result = await api.createPersona({
             client: this.restClient,
-            body: data,
+            body: {
+                name: data.name,
+                template_id: templateId,
+                description: data.description,
+                source_persona_id: data.source_persona_id,
+                clone_data: data.clone_data,
+                proto_config: data.proto_config,
+                trigger_type: data.trigger_type,
+            },
         });
         return result.data;
     }
@@ -187,6 +234,7 @@ export class EmaClientV2 {
         let workflow = data.workflow;
         // CRITICAL: Handle workflow namespace quirk at SDK level
         if (workflow) {
+            workflow = JSON.parse(JSON.stringify(workflow));
             const incomingWfName = workflow.workflowName;
             const incomingIsPersonaScoped = incomingWfName?.name?.namespaces?.[1] === "personas" &&
                 incomingWfName?.name?.namespaces?.[2] === personaId;
@@ -198,20 +246,28 @@ export class EmaClientV2 {
                 const existingWorkflow = existing?.workflow_def;
                 const existingWfName = existingWorkflow?.workflowName;
                 if (existingWfName?.name) {
-                    // Copy namespace from existing workflow
-                    workflow = { ...workflow, workflowName: existingWfName };
+                    workflow.workflowName = existingWfName;
                 }
                 else {
-                    // Generate a valid namespace for personas without existing workflows
-                    // Format: ["ema", "personas", "<persona_id>"] with name "workflow"
                     const generatedWfName = {
                         name: {
                             namespaces: ["ema", "personas", personaId],
                             name: "workflow",
                         },
                     };
-                    workflow = { ...workflow, workflowName: generatedWfName };
+                    workflow.workflowName = generatedWfName;
+                }
+            }
+            const results = workflow.results;
+            if (results) {
+                const fixedResults = {};
+                for (const [key, value] of Object.entries(results)) {
+                    if (value.actionName && value.outputName) {
+                        const correctKey = `${value.actionName}.${value.outputName}`;
+                        fixedResults[correctKey] = value;
+                    }
                 }
+                workflow.results = fixedResults;
             }
         }
         const result = await api.updatePersona({
@@ -311,6 +367,41 @@ export class EmaClientV2 {
         return this.grpcClient.getReplicationStatus(requestId);
     }
     // ─────────────────────────────────────────────────────────────────────────────
+    // Debug & Audit Operations - gRPC (ConversationReview, DebugLog, Debugger)
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * List conversation reviews for a persona (audit tab).
+     */
+    async getConversationReviews(personaId, opts) {
+        return this.grpcClient.getConversationReviews(personaId, opts);
+    }
+    /**
+     * Get detailed conversation review with messages and workflow run IDs.
+     */
+    async getConversationReviewDetail(conversationId) {
+        return this.grpcClient.getConversationReviewDetail(conversationId);
+    }
+    /**
+     * Get workflow-level debug log (show work for all actions in a run).
+     * personaId is required — DebugLogService uses X-Persona-Id header for auth.
+     */
+    async getWorkflowLevelDebugLog(workflowRunId, personaId) {
+        return this.grpcClient.getWorkflowLevelDebugLog(workflowRunId, personaId);
+    }
+    /**
+     * Get action-level show work log (deep trace for a single action).
+     * personaId is required — DebugLogService uses X-Persona-Id header for auth.
+     */
+    async getActionLevelShowWorkLog(actionName, workflowRunId, personaId) {
+        return this.grpcClient.getActionLevelShowWorkLog(actionName, workflowRunId, personaId);
+    }
+    /**
+     * Search messages across conversations.
+     */
+    async searchMessages(opts) {
+        return this.grpcClient.searchMessages(opts);
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
     // Dashboard Row Operations - REST API (not in OpenAPI spec)
     // ─────────────────────────────────────────────────────────────────────────────
     /**