@ema.co/mcp-toolkit 2026.1.30-1 → 2026.2.5

package/README.md

@@ -225,13 +225,17 @@ persona(input="IT helpdesk with KB search", type="chat", name="IT Support", prev
 ```typescript
 // Step 1: Get current workflow
 workflow(mode="get", persona_id="abc-123")
-// Returns: workflow_def, schema, guidance
+// Returns: workflow_def, schema, guidance, fingerprint
 
 // Step 2: LLM modifies the workflow_def JSON
 // (add nodes, remove nodes, rewire connections)
 
 // Step 3: Deploy modified workflow
-workflow(mode="deploy", persona_id="abc-123", workflow_def={...}, preview=true)
+// IMPORTANT: pass base_fingerprint from the get() response to prevent overwriting out-of-band changes
+workflow(mode="deploy", persona_id="abc-123", base_fingerprint="<fingerprint>", workflow_def={...})
+
+// If the workflow_def is large (near transport limits), deploy from a file instead:
+// workflow(mode="deploy", persona_id="abc-123", base_fingerprint="<fingerprint>", workflow_def_path="/path/to/wf.json")
 ```
 
 **Get reference info:**

package/dist/mcp/autobuilder.js

@@ -274,7 +274,7 @@ export function generateAutobuilderPrompt(description, personaType) {
             prompt += "- Use external_action_caller or send_email_agent as needed\n";
         }
         if (hasHITL) {
-            prompt += "- Include general_hitl with success/failure paths\n";
+            prompt += "- Enable HITL flag on agents that need approval (do NOT add standalone general_hitl nodes)\n";
         }
         prompt += `- ${config.outputNote}\n`;
     }

package/dist/mcp/domain/dashboard.js

@@ -0,0 +1,224 @@
+/**
+ * Dashboard Domain Logic
+ *
+ * Business logic for dashboard operations including:
+ * - Sanitization of PII in column values
+ * - Nested data transformation with sanitization
+ * - Validation helpers
+ *
+ * Note: Pure format translation (without sanitization) is in SDK's columnValueToInput().
+ */
+import { columnValueToInput } from "../../sdk/ema-client.js";
+// ─────────────────────────────────────────────────────────────────────────────
+// Sanitization
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Sanitization session for PII replacement.
+ * Maintains consistent replacements across multiple values.
+ */
+export class SanitizationSession {
+    replacements = new Map();
+    counters = {};
+    /**
+     * Get or create a replacement for a detected PII value.
+     * Returns consistent replacements for the same value.
+     */
+    getOrCreateReplacement(value, type) {
+        const existing = this.replacements.get(value);
+        if (existing)
+            return existing;
+        this.counters[type] = (this.counters[type] ?? 0) + 1;
+        const replacement = `[${type.toUpperCase()}_${this.counters[type]}]`;
+        this.replacements.set(value, replacement);
+        return replacement;
+    }
+    /** Get all replacements made in this session */
+    getReplacements() {
+        return new Map(this.replacements);
+    }
+}
+/**
+ * Detect PII patterns in text using regex.
+ */
+export function detectPiiPatterns(text) {
+    const detected = [];
+    // Email pattern
+    const emailRegex = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
+    for (const match of text.matchAll(emailRegex)) {
+        detected.push({ value: match[0], type: "email" });
+    }
+    // Phone pattern (various formats)
+    const phoneRegex = /\b(?:\+?1[-.\s]?)?\(?[0-9]{3}\)?[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}\b/g;
+    for (const match of text.matchAll(phoneRegex)) {
+        detected.push({ value: match[0], type: "phone" });
+    }
+    return detected;
+}
+/**
+ * Sanitize a string value by replacing detected PII.
+ */
+export function sanitizeString(value, session, additionalPatterns) {
+    let result = value;
+    // Pattern-based sanitization
+    const detected = detectPiiPatterns(result);
+    for (const entity of detected) {
+        const replacement = session.getOrCreateReplacement(entity.value, entity.type);
+        result = result.split(entity.value).join(replacement);
+    }
+    // User-provided patterns
+    if (additionalPatterns) {
+        for (const pattern of additionalPatterns) {
+            if (result.includes(pattern)) {
+                const replacement = session.getOrCreateReplacement(pattern, "custom");
+                result = result.split(pattern).join(replacement);
+            }
+        }
+    }
+    return result;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Column Value Conversion with Sanitization
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Convert a column value to DashboardInput with optional sanitization.
+ *
+ * This wraps the SDK's pure conversion function and adds sanitization.
+ * Use this in MCP handlers when sanitization is needed.
+ *
+ * @param name - The column/field name
+ * @param value - The column value from API response
+ * @param session - Sanitization session (null to skip sanitization)
+ * @param additionalPatterns - Additional strings to sanitize
+ * @returns DashboardInput for upload, or null if value is empty/unsupported
+ */
+export function columnValueToInputWithSanitization(name, value, session, additionalPatterns) {
+    if (!value)
+        return null;
+    // If no sanitization needed, delegate to SDK
+    if (!session) {
+        return columnValueToInput(name, value);
+    }
+    // Handle string value with sanitization
+    if (value.stringValue !== undefined) {
+        const sanitized = sanitizeString(value.stringValue, session, additionalPatterns);
+        return { name, string_value: sanitized };
+    }
+    // Handle number value (no sanitization needed)
+    if (value.numberValue !== undefined) {
+        return { name, number_value: value.numberValue };
+    }
+    // Handle boolean value (no sanitization needed)
+    if (value.booleanValue !== undefined) {
+        return { name, boolean_value: value.booleanValue };
+    }
+    // Handle array value (recursively with sanitization)
+    if (value.arrayValue) {
+        const elements = value.arrayValue.arrayValues ?? [];
+        if (elements.length === 0)
+            return null;
+        const arrayInputs = [];
+        for (const elem of elements) {
+            const converted = columnValueToInputWithSanitization("element", elem, session, additionalPatterns);
+            if (converted)
+                arrayInputs.push(converted);
+        }
+        return arrayInputs.length > 0 ? { name, array_value: arrayInputs } : null;
+    }
+    // Handle object value (recursively with sanitization)
+    if (value.objectValue) {
+        const objectVals = value.objectValue.objectValues ?? {};
+        const keys = Object.keys(objectVals);
+        if (keys.length === 0)
+            return null;
+        const objectInput = {};
+        for (const key of keys) {
+            const converted = columnValueToInputWithSanitization(key, objectVals[key], session, additionalPatterns);
+            if (converted)
+                objectInput[key] = converted;
+        }
+        return Object.keys(objectInput).length > 0 ? { name, object_value: objectInput } : null;
+    }
+    // Unsupported types - delegate to SDK (will return null)
+    return columnValueToInput(name, value);
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Nested Data Validation
+// ─────────────────────────────────────────────────────────────────────────────
+/** Maximum array elements to prevent oversized payloads */
+export const MAX_ARRAY_ELEMENTS = 1000;
+/** Maximum nesting depth for arrays/objects */
+export const MAX_NESTING_DEPTH = 3;
+/**
+ * Validate nested data structure.
+ * Returns errors/warnings for issues found.
+ */
+export function validateNestedData(value, schemaType, path = "", depth = 0) {
+    const errors = [];
+    // Check nesting depth
+    if (depth > MAX_NESTING_DEPTH) {
+        errors.push({
+            path,
+            message: `Nesting depth exceeds maximum of ${MAX_NESTING_DEPTH}`,
+            severity: "error",
+        });
+        return errors;
+    }
+    // Validate based on schema type
+    if (schemaType === "COLUMN_TYPE_ARRAY" || schemaType === "ARRAY") {
+        if (!Array.isArray(value)) {
+            errors.push({
+                path,
+                message: `Expected array for ARRAY column, got ${typeof value}`,
+                severity: "error",
+            });
+        }
+        else if (value.length > MAX_ARRAY_ELEMENTS) {
+            errors.push({
+                path,
+                message: `Array has ${value.length} elements, exceeds maximum of ${MAX_ARRAY_ELEMENTS}`,
+                severity: "error",
+            });
+        }
+    }
+    else if (schemaType === "COLUMN_TYPE_OBJECT" || schemaType === "OBJECT") {
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            errors.push({
+                path,
+                message: `Expected object for OBJECT column, got ${Array.isArray(value) ? "array" : typeof value}`,
+                severity: "error",
+            });
+        }
+    }
+    else if (schemaType === "COLUMN_TYPE_STRING" || schemaType === "STRING") {
+        if (typeof value !== "string") {
+            if (Array.isArray(value)) {
+                errors.push({
+                    path,
+                    message: `Column expects scalar STRING value, got array. Did you mean to use an ARRAY column?`,
+                    severity: "error",
+                });
+            }
+            else if (typeof value === "object" && value !== null) {
+                errors.push({
+                    path,
+                    message: `Column expects scalar STRING value, got object. Did you mean to use an OBJECT column?`,
+                    severity: "error",
+                });
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * Check if a value contains nested data (array or object).
+ */
+export function hasNestedData(value) {
+    if (Array.isArray(value))
+        return true;
+    if (typeof value === "object" && value !== null) {
+        // Check if it looks like a nested structure vs a simple object
+        const keys = Object.keys(value);
+        return keys.some(k => !["name", "string_value", "number_value", "boolean_value", "document_value"].includes(k));
+    }
+    return false;
+}

package/dist/mcp/domain/validation-rules.js

@@ -132,12 +132,13 @@ export const ANTI_PATTERNS = [
     {
         id: "email-without-validation",
         name: "Email Without Input Validation",
-        pattern: "send_email_agent without entity_extraction and HITL confirmation",
+        pattern: "send_email_agent without entity_extraction to validate recipient data",
         problem: "Sending emails without extracting and validating recipient data risks sending to wrong people or with wrong content. Emails are high-impact actions with external side effects.",
-        solution: "Always: 1) Extract required fields (email_address, subject) via entity_extraction, 2) Validate completeness via categorizer, 3) Ask user if missing, 4) Confirm via HITL before sending.",
+        solution: "Always: 1) Extract required fields (email_address, subject) via entity_extraction, 2) Validate completeness via categorizer, 3) Ask user if missing. " +
+            "For approval: enable the HITL flag on send_email_agent (do NOT add a standalone general_hitl node).",
         detection: {
-            issueType: "incomplete_hitl",
-            condition: "send_email_agent without preceding entity_extraction AND hitl nodes",
+            issueType: "incomplete_email_validation",
+            condition: "send_email_agent without preceding entity_extraction node to extract/validate recipient data",
         },
         severity: "critical",
     },
@@ -194,12 +195,15 @@ export const ANTI_PATTERNS = [
         name: "Incomplete HITL Paths",
         pattern: "HITL with only success path",
         problem: "Rejected requests have no handling, leaving users without response.",
-        solution: "ALWAYS implement both success AND failure paths for general_hitl.",
+        solution: "If workflow already has general_hitl node: ALWAYS implement both success AND failure paths. For NEW workflows: use HITL flag on the agent instead of standalone general_hitl nodes (see hitl-patterns guidance).",
         detection: {
             issueType: "incomplete_hitl",
             condition: "HITL node missing 'hitl_status_HITL Success' or 'hitl_status_HITL Failure' edge (note: space, not underscore)",
         },
         severity: "critical",
+        // TODO: Revisit if general_hitl is re-enabled as a standalone node.
+        // Currently HITL is a flag on agents (send_email_agent, external_action_caller).
+        // This anti-pattern still fires for existing workflows that use general_hitl.
     },
     {
         id: "orphan-nodes",
@@ -432,6 +436,64 @@ export const ANTI_PATTERNS = [
         },
         severity: "critical",
     },
+    {
+        id: "chat-conversation-without-chat-response",
+        name: "Chat Conversation Not Wired to Chat Response Node",
+        pattern: "Chat workflow where chat_conversation is consumed by processing nodes but never wired to a chat-aware response node (respond_with_sources or respond_for_external_actions)",
+        problem: "When chat_conversation is processed by nodes like entity_extraction, call_llm, or search, " +
+            "but the final response is generated by a generic call_llm (not a chat-aware response node), " +
+            "the response node lacks conversation history context. This causes:\n" +
+            "1. Duplicate/repetitive responses — the LLM re-asks questions already answered in conversation\n" +
+            "2. Lost context — follow-up messages lose prior context\n" +
+            "3. Hallucinated greetings — the LLM generates its own greeting instead of continuing the conversation\n\n" +
+            "The chat-aware response nodes (respond_with_sources, respond_for_external_actions) are specifically " +
+            "designed to handle conversation history and produce contextually appropriate responses.",
+        solution: "Wire chat_conversation through to a chat-aware response node:\n" +
+            "• For search-based responses: use respond_with_sources (takes query + search_results)\n" +
+            "• For tool/action results: use respond_for_external_actions (takes query + external_action_result)\n" +
+            "• If using call_llm as responder: wire chat_conversation into named_inputs so the LLM sees full history\n\n" +
+            "Correct patterns:\n" +
+            "  chat_trigger → search → respond_with_sources → WORKFLOW_OUTPUT\n" +
+            "  chat_trigger → external_action_caller → respond_for_external_actions → WORKFLOW_OUTPUT\n" +
+            "  chat_trigger → call_llm(named_inputs includes chat_conversation) → WORKFLOW_OUTPUT\n\n" +
+            "Anti-patterns:\n" +
+            "  ❌ chat_trigger → search → call_llm (no conversation context) → WORKFLOW_OUTPUT\n" +
+            "  ❌ chat_trigger → entity_extraction → call_llm (stateless) → WORKFLOW_OUTPUT",
+        detection: {
+            issueType: "chat_conversation_not_wired_to_response",
+            condition: "Chat workflow (chat_trigger) where terminal response node is call_llm without chat_conversation in named_inputs, " +
+                "and respond_with_sources / respond_for_external_actions are not used",
+        },
+        severity: "critical",
+    },
+    {
+        id: "entity-extraction-direct-to-email",
+        name: "Entity Extraction Wired Directly to Email Inputs",
+        pattern: "entity_extraction outputs connected directly to send_email_agent.email_to, email_subject, or email_body",
+        problem: "entity_extraction outputs are typed as WELL_KNOWN_TYPE_ANY (structured extraction results), " +
+            "but send_email_agent inputs (email_to, email_subject, email_body) require WELL_KNOWN_TYPE_TEXT_WITH_SOURCES. " +
+            "Direct wiring causes type mismatch errors or corrupted email fields.\n\n" +
+            "Additionally, entity_extraction outputs may contain multiple extracted values in a structured format — " +
+            "wiring the entire output to email_to would send an object/JSON as the recipient address, not a clean email string.",
+        solution: "Use intermediary nodes to extract and format individual fields:\n\n" +
+            "Pattern A — json_mapper + fixed_response (recommended for multiple fields):\n" +
+            "  entity_extraction → json_mapper (extract 'to', 'subject', 'body') → fixed_response({{to}}) → send_email_agent.email_to\n" +
+            "  Same json_mapper → fixed_response({{subject}}) → send_email_agent.email_subject\n" +
+            "  Same json_mapper → fixed_response({{body}}) → send_email_agent.email_body\n\n" +
+            "Pattern B — custom_agent with output_fields (simpler for LLM-generated content):\n" +
+            "  custom_agent(output_fields=[To,Subject,Body]) → send_email_agent\n" +
+            "  (custom_agent with output_fields produces individual TEXT_WITH_SOURCES outputs)\n\n" +
+            "Pattern C — fixed_response with template variables (for simple extraction):\n" +
+            "  entity_extraction → fixed_response(template='{{email_address}}', custom_data=entity_extraction) → send_email_agent.email_to\n\n" +
+            "Key principle: send_email_agent inputs need TEXT_WITH_SOURCES — always use fixed_response or " +
+            "custom_agent(output_fields) as the adapter between extraction results and email fields.",
+        detection: {
+            issueType: "entity_extraction_direct_to_email",
+            condition: "entity_extraction output connected directly to send_email_agent.email_to, email_subject, or email_body " +
+                "without an intermediary json_mapper/fixed_response/custom_agent node",
+        },
+        severity: "critical",
+    },
 ];
 export const OPTIMIZATION_RULES = [
     {

package/dist/mcp/guidance.js

@@ -25,36 +25,38 @@ export const GUIDANCE_RULES = [
         category: "workflow",
         title: "Get Workflow Before Modifying",
         applies: "Before any workflow modification",
-        description: "Always fetch the current workflow_def before making changes.",
-        do: "Call workflow(mode='get', persona_id='...') to get the current workflow_def and schema.",
-        dont: "Jump straight to deploy without understanding the current state.",
+        description: "Always fetch the current workflow_def before making changes. Use the returned workflow_def as your canonical format reference; do not reverse-engineer from local JSON files.",
+        do: "Call workflow(mode='get', persona_id='...') to get the current workflow_def and schema. Use the returned workflow_def as format reference. For extraction_columns see ema://rules/extraction-column-format.",
+        dont: "Jump straight to deploy without understanding the current state. Do not compare local JSON files in Python/scripts; use MCP get as format reference.",
         example: `// Good - get first, then modify, then deploy
 const data = await workflow({ mode: "get", persona_id: "abc" });
 const wf = data.workflow_def;
 // LLM modifies wf...
 wf.actions.push(newNode);
-await workflow({ mode: "deploy", persona_id: "abc", workflow_def: wf });`,
+await workflow({ mode: "deploy", persona_id: "abc", base_fingerprint: data.fingerprint, workflow_def: wf });`,
         antiExample: `// Bad - deploying without getting current state
-await workflow({ mode: "deploy", persona_id: "abc", workflow_def: guessedDef });`,
+await workflow({ mode: "deploy", persona_id: "abc", workflow_def: guessedDef }); // Will be blocked (missing base_fingerprint)`,
         related: ["preview-before-deploy"],
     },
     {
         id: "preview-before-deploy",
         level: "critical",
         category: "safety",
-        title: "Preview Before Deploying",
+        title: "Validate Before Deploying",
         applies: "Before any deployment",
-        description: "Always preview changes before deploying to catch errors early.",
-        do: "Use preview=true to see what will change before committing.",
-        dont: "Deploy directly without reviewing the changes.",
-        example: `// Good
-const preview = await persona({ 
-  id: "abc", 
-  update: { workflow_spec: spec },
-  preview: true  // See changes first
-});
-// Review preview.changes
-await persona({ id: "abc", update: { workflow_spec: spec } }); // Then deploy`,
+        description: "Always validate and review changes before deploying to catch errors early.",
+        do: "Use workflow(mode='validate') before workflow(mode='deploy'). For persona workflow_spec updates, you can use preview=true to review changes before applying.",
+        dont: "Deploy directly without validating/reviewing.",
+        example: `// Good (workflow deploy)
+const data = await workflow({ mode: "get", persona_id: "abc" });
+// LLM modifies data.workflow_def...
+await workflow({ mode: "validate", workflow_def: data.workflow_def });
+await workflow({ mode: "deploy", persona_id: "abc", base_fingerprint: data.fingerprint, workflow_def: data.workflow_def });
+
+// Good (persona workflow_spec preview)
+const preview = await persona({ method: "update", id: "abc", workflow_spec: spec, preview: true });
+// Review preview.changes, then apply:
+await persona({ method: "update", id: "abc", workflow_spec: spec, preview: false });`,
         related: ["get-before-modify"],
     },
     {
@@ -93,7 +95,8 @@ const stats = await persona({ id: "abc", data: { method: "stats" } });
 // stats.success should be > 0
 
 // Then deploy workflow with search
-await workflow({ mode: "deploy", persona_id: "abc", workflow_def: workflowWithSearch });`,
+const wfData = await workflow({ mode: "get", persona_id: "abc" });
+await workflow({ mode: "deploy", persona_id: "abc", base_fingerprint: wfData.fingerprint, workflow_def: workflowWithSearch });`,
         antiExample: `// BAD: Deploy search workflow with no documents
 await workflow({ mode: "deploy", persona_id: "abc", workflow_def: workflowWithSearch });
 // Search will return empty results!`,
@@ -106,11 +109,13 @@ await workflow({ mode: "deploy", persona_id: "abc", workflow_def: workflowWithSe
         title: "Workflow Modification Flow",
         applies: "When modifying workflows",
         description: "All workflow modifications follow a 3-step flow: get → modify → deploy. " +
+            "Use the returned workflow_def as your format reference; do not reverse-engineer from local files. " +
             "The LLM generates the full workflow_def, MCP just deploys it.",
-        do: "1) Get workflow: workflow(mode='get', persona_id='...') " +
-            "2) LLM modifies the workflow_def JSON " +
-            "3) Deploy: workflow(mode='deploy', persona_id='...', workflow_def={...})",
-        dont: "Try to use incremental update operations - they don't exist. Always deploy complete workflow_def.",
+        do: "1) Get workflow: workflow(mode='get', persona_id='...') — use returned workflow_def as format reference; for extraction_columns fetch ema://rules/extraction-column-format " +
+            "2) LLM modifies the workflow_def JSON (text/JSON edits) " +
+            "3) Deploy: workflow(mode='deploy', persona_id='...', base_fingerprint='<fingerprint>', workflow_def={...}) " +
+            "(or workflow_def_path='/path/to/wf.json' for large payloads)",
+        dont: "Try to use incremental update operations - they don't exist. Do not compare local JSON files in Python/scripts; use MCP get as format reference. Always deploy complete workflow_def.",
         example: `// The ONLY working pattern for workflow modifications:
 const data = await workflow({ mode: "get", persona_id: "abc" });
 const wf = data.workflow_def;
@@ -120,7 +125,7 @@ wf.actions.push(newNode);
 wf.actions[2].inputs.instructions.inline.wellKnown.stringValue = "new prompt";
 
 // Deploy the complete modified workflow
-await workflow({ mode: "deploy", persona_id: "abc", workflow_def: wf });`,
+await workflow({ mode: "deploy", persona_id: "abc", base_fingerprint: data.fingerprint, workflow_def: wf });`,
         antiExample: `// WRONG: These patterns DO NOT WORK
 persona({ method: "update", id: "abc", input: "add HITL" })  // input param ignored
 persona({ method: "update", id: "abc", operations: [...] })  // operations param ignored`,
@@ -136,7 +141,7 @@ persona({ method: "update", id: "abc", operations: [...] })  // operations param
         title: "workflow_spec via persona update has limitations",
         applies: "When using persona(method='update', workflow_spec={...})",
         description: "persona(method='update', workflow_spec={...}) can ONLY remove/rewire nodes, NOT add new ones. " +
-            "For adding nodes, use workflow(mode='deploy', workflow_def={...}) with full workflow.",
+            "For adding nodes, use workflow(mode='deploy', base_fingerprint='<fingerprint>', workflow_def={...}) with full workflow.",
         do: "Use workflow_spec for simple rewiring. Use workflow(mode='deploy') for adding nodes.",
         dont: "Try to add new nodes via workflow_spec - it will throw an error.",
         example: `// workflow_spec: good for rewiring/removing
@@ -152,7 +157,7 @@ await persona({
 // For adding nodes: use workflow(mode="deploy")
 const data = await workflow({ mode: "get", persona_id: "abc" });
 data.workflow_def.actions.push(newNode);
-await workflow({ mode: "deploy", persona_id: "abc", workflow_def: data.workflow_def });`,
+await workflow({ mode: "deploy", persona_id: "abc", base_fingerprint: data.fingerprint, workflow_def: data.workflow_def });`,
         antiExample: `// WRONG: workflow_spec cannot add new nodes
 await persona({
   method: "update",
@@ -402,7 +407,7 @@ All workflow modifications follow a 3-step flow:
 
 1. Get: \`workflow(mode="get", persona_id="...")\` → returns workflow_def, schema
 2. LLM modifies the workflow_def JSON
-3. Deploy: \`workflow(mode="deploy", persona_id="...", workflow_def={...})\`
+3. Deploy: \`workflow(mode="deploy", persona_id="...", base_fingerprint="<fingerprint>", workflow_def={...})\`
 
 The LLM generates the full workflow_def. MCP provides data and executes.
 

package/dist/mcp/handlers/data/dashboard-clone.js

@@ -16,40 +16,7 @@
  *    - Slower but allows data transformation
  */
 import { errorResult } from "../types.js";
-/**
- * Sanitization session for PII replacement.
- * Simple implementation - can be enhanced with more patterns.
- */
-class SanitizationSession {
-    replacements = new Map();
-    counters = {};
-    getOrCreateReplacement(value, type) {
-        const existing = this.replacements.get(value);
-        if (existing)
-            return existing;
-        this.counters[type] = (this.counters[type] ?? 0) + 1;
-        const replacement = `[${type.toUpperCase()}_${this.counters[type]}]`;
-        this.replacements.set(value, replacement);
-        return replacement;
-    }
-}
-/**
- * Simple pattern-based PII detection.
- */
-function detectWithPatterns(text) {
-    const detected = [];
-    // Email pattern
-    const emailRegex = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
-    for (const match of text.matchAll(emailRegex)) {
-        detected.push({ value: match[0], type: "email" });
-    }
-    // Phone pattern (various formats)
-    const phoneRegex = /\b(?:\+?1[-.\s]?)?\(?[0-9]{3}\)?[-.\s]?[0-9]{3}[-.\s]?[0-9]{4}\b/g;
-    for (const match of text.matchAll(phoneRegex)) {
-        detected.push({ value: match[0], type: "phone" });
-    }
-    return detected;
-}
+import { SanitizationSession, columnValueToInputWithSanitization, sanitizeString, } from "../../domain/dashboard.js";
 /**
  * Infer MIME type from filename extension.
  */
@@ -103,26 +70,12 @@ async function processDocumentColumn(client, sourcePersonaId, rowId, inputCol, d
 }
 /**
  * Process a string column with optional sanitization.
+ * Uses the domain sanitizeString function for PII removal.
  */
 function processStringColumn(inputCol, value, sanitizationSession, sanitizeExamples) {
-    let processedValue = value;
-    if (sanitizationSession && processedValue) {
-        // Pattern-based sanitization
-        const detected = detectWithPatterns(processedValue);
-        for (const entity of detected) {
-            const replacement = sanitizationSession.getOrCreateReplacement(entity.value, entity.type);
-            processedValue = processedValue.split(entity.value).join(replacement);
-        }
-        // User-provided examples
-        if (sanitizeExamples) {
-            for (const example of sanitizeExamples) {
-                if (processedValue.includes(example)) {
-                    const replacement = sanitizationSession.getOrCreateReplacement(example, "unknown");
-                    processedValue = processedValue.split(example).join(replacement);
-                }
-            }
-        }
-    }
+    const processedValue = sanitizationSession
+        ? sanitizeString(value, sanitizationSession, sanitizeExamples)
+        : value;
     return {
         name: inputCol.name,
         string_value: processedValue,
@@ -281,11 +234,44 @@ export async function handleDashboardClone(args, client) {
                     }
                 }
                 else if (inputCol.columnType === "COLUMN_TYPE_ARRAY") {
+                    // Handle full array - convert each element to DashboardInput using domain function
                     const arrayVals = colValue.value?.arrayValue?.arrayValues ?? [];
                     if (arrayVals.length > 0) {
-                        const value = arrayVals[0]?.stringValue ?? "";
-                        if (value) {
-                            inputs.push(processStringColumn(inputCol, value, sanitizationSession, sanitizeExamples));
+                        const arrayInputs = [];
+                        for (const elem of arrayVals) {
+                            // Cast to ColumnValueData - types are structurally compatible
+                            const elemInput = columnValueToInputWithSanitization("element", elem, sanitizationSession, sanitizeExamples);
+                            if (elemInput) {
+                                arrayInputs.push(elemInput);
+                            }
+                        }
+                        if (arrayInputs.length > 0) {
+                            inputs.push({
+                                name: inputCol.name,
+                                array_value: arrayInputs,
+                            });
+                        }
+                    }
+                }
+                else if (inputCol.columnType === "COLUMN_TYPE_OBJECT") {
+                    // Handle object columns - convert each sub-column using domain function
+                    const objectVals = colValue.value?.objectValue?.objectValues ?? {};
+                    const objectKeys = Object.keys(objectVals);
+                    if (objectKeys.length > 0) {
+                        const objectInput = {};
+                        for (const key of objectKeys) {
+                            const subValue = objectVals[key];
+                            // Cast to ColumnValueData - types are structurally compatible
+                            const subInput = columnValueToInputWithSanitization(key, subValue, sanitizationSession, sanitizeExamples);
+                            if (subInput) {
+                                objectInput[key] = subInput;
+                            }
+                        }
+                        if (Object.keys(objectInput).length > 0) {
+                            inputs.push({
+                                name: inputCol.name,
+                                object_value: objectInput,
+                            });
                         }
                     }
                 }