@zenti/sdk 0.1.0

package/dist/cli/commands/validate.d.ts

@@ -0,0 +1,2 @@
+export declare function validateCommand(filePath?: string): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/cli/commands/validate.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCommand = validateCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const parser_1 = require("../../parser");
+function findZentiFile() {
+    const files = fs.readdirSync(process.cwd()).filter((f) => f.endsWith('.zenti'));
+    return files.length > 0 ? files[0] : null;
+}
+function validateCommand(filePath) {
+    const target = filePath ?? findZentiFile();
+    if (!target) {
+        console.error('Error: No se encontró ningún archivo .zenti en el directorio actual.');
+        console.error('Pasa la ruta explícita: zenti validate <archivo.zenti>');
+        process.exit(1);
+    }
+    const resolved = path.resolve(target);
+    if (!fs.existsSync(resolved)) {
+        console.error(`Error: No se encontró el archivo: ${resolved}`);
+        process.exit(1);
+    }
+    try {
+        const content = fs.readFileSync(resolved, 'utf-8');
+        const persona = (0, parser_1.parseZenti)(content);
+        console.log(`✓ ${target} es válido`);
+        console.log('');
+        console.log(`  Nombre:          ${persona.name}`);
+        console.log(`  Versión:         ${persona.version}`);
+        console.log(`  Rol:             ${persona.identity.role}`);
+        console.log(`  Ejemplos on_brand:  ${persona.examples.on_brand.length}`);
+        console.log(`  Ejemplos off_brand: ${persona.examples.off_brand.length}`);
+        console.log(`  Guardrails:      ${persona.guardrails.always.length +
+            persona.guardrails.never.length +
+            persona.guardrails.escalate_if.length} reglas`);
+    }
+    catch (e) {
+        if (e instanceof parser_1.ZentiValidationError) {
+            console.error(`✗ Error de validación: ${e.message}`);
+        }
+        else {
+            console.error(`✗ Error inesperado: ${e.message}`);
+        }
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=validate.js.map

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const validate_1 = require("./commands/validate");
+const diff_1 = require("./commands/diff");
+const test_1 = require("./commands/test");
+const program = new commander_1.Command();
+program
+    .name('zenti')
+    .description('SDK para gestionar personalidades de agentes IA de forma portable entre modelos')
+    .version('0.1.0');
+program
+    .command('init')
+    .description('Crea un archivo persona.zenti con template vacío en el directorio actual')
+    .option('-o, --output <path>', 'Ruta de salida del archivo .zenti')
+    .action((options) => {
+    (0, init_1.initCommand)(options);
+});
+program
+    .command('validate [file]')
+    .description('Parsea y valida un archivo .zenti, mostrando errores o confirmación')
+    .action((file) => {
+    (0, validate_1.validateCommand)(file);
+});
+program
+    .command('test')
+    .description('Carga el .zenti del directorio actual y abre un chat interactivo usando Claude')
+    .option('-f, --file <path>', 'Ruta al archivo .zenti (por defecto: primer .zenti encontrado)')
+    .option('-k, --key <apiKey>', 'API key de Anthropic (o usa ANTHROPIC_API_KEY env var)')
+    .action(async (options) => {
+    await (0, test_1.testCommand)(options);
+});
+program
+    .command('diff <file1> <file2>')
+    .description('Compara dos archivos .zenti y muestra qué cambió entre versiones')
+    .action((file1, file2) => {
+    (0, diff_1.diffCommand)(file1, file2);
+});
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map

package/dist/compiler/index.d.ts

@@ -0,0 +1,5 @@
+export { toClaude, ClaudeOutput } from './toClaude';
+export { toOpenAI, OpenAIOutput, OpenAIMessage } from './toOpenAI';
+export { toGemini, GeminiOutput, GeminiContent, GeminiPart } from './toGemini';
+export { translateBigFive } from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/compiler/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateBigFive = exports.toGemini = exports.toOpenAI = exports.toClaude = void 0;
+var toClaude_1 = require("./toClaude");
+Object.defineProperty(exports, "toClaude", { enumerable: true, get: function () { return toClaude_1.toClaude; } });
+var toOpenAI_1 = require("./toOpenAI");
+Object.defineProperty(exports, "toOpenAI", { enumerable: true, get: function () { return toOpenAI_1.toOpenAI; } });
+var toGemini_1 = require("./toGemini");
+Object.defineProperty(exports, "toGemini", { enumerable: true, get: function () { return toGemini_1.toGemini; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "translateBigFive", { enumerable: true, get: function () { return utils_1.translateBigFive; } });
+//# sourceMappingURL=index.js.map

package/dist/compiler/toClaude.d.ts

@@ -0,0 +1,15 @@
+import { ZentiPersona } from '../parser';
+export interface ClaudeOutput {
+    system: string;
+}
+/**
+ * Compiles a ZentiPersona into a Claude system prompt.
+ *
+ * Priority order (per spec):
+ *   1. guardrails  — constraints come first so Claude respects them absolutely
+ *   2. identity    — who the agent is
+ *   3. core        — Big Five traits as descriptive adjectives
+ *   4. few-shot examples — on_brand examples at the end
+ */
+export declare function toClaude(persona: ZentiPersona): ClaudeOutput;
+//# sourceMappingURL=toClaude.d.ts.map

package/dist/compiler/toClaude.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toClaude = toClaude;
+const utils_1 = require("./utils");
+/**
+ * Compiles a ZentiPersona into a Claude system prompt.
+ *
+ * Priority order (per spec):
+ *   1. guardrails  — constraints come first so Claude respects them absolutely
+ *   2. identity    — who the agent is
+ *   3. core        — Big Five traits as descriptive adjectives
+ *   4. few-shot examples — on_brand examples at the end
+ */
+function toClaude(persona) {
+    const lines = [];
+    // ── Layer 1: Guardrails ────────────────────────────────────────────────────
+    lines.push('## REGLAS DE COMPORTAMIENTO');
+    lines.push('');
+    if (persona.guardrails.always.length > 0) {
+        lines.push('### Siempre debes:');
+        persona.guardrails.always.forEach((rule) => lines.push(`- ${rule}`));
+        lines.push('');
+    }
+    if (persona.guardrails.never.length > 0) {
+        lines.push('### Nunca debes:');
+        persona.guardrails.never.forEach((rule) => lines.push(`- ${rule}`));
+        lines.push('');
+    }
+    if (persona.guardrails.escalate_if.length > 0) {
+        lines.push('### Escala la conversación si:');
+        persona.guardrails.escalate_if.forEach((condition) => lines.push(`- ${condition}`));
+        lines.push('');
+    }
+    // ── Layer 2: Identity ──────────────────────────────────────────────────────
+    lines.push('## IDENTIDAD');
+    lines.push('');
+    lines.push(`**Nombre:** ${persona.name}`);
+    lines.push(`**Rol:** ${persona.identity.role}`);
+    lines.push(`**Perfil:** ${persona.identity.backstory}`);
+    lines.push(`**Estilo de comunicación:** ${persona.identity.communication_style}`);
+    lines.push('');
+    // ── Layer 3: Core — Big Five as descriptive adjectives ────────────────────
+    const traits = (0, utils_1.translateBigFive)(persona.core);
+    if (traits.length > 0) {
+        lines.push('## RASGOS DE PERSONALIDAD');
+        lines.push('');
+        traits.forEach((trait) => lines.push(`- ${trait}`));
+        lines.push('');
+    }
+    // ── Layer 4: Few-shot examples ────────────────────────────────────────────
+    if (persona.examples.on_brand.length > 0) {
+        lines.push('## EJEMPLOS DE RESPUESTAS CORRECTAS');
+        lines.push('');
+        persona.examples.on_brand.forEach((ex) => {
+            lines.push(`**Usuario:** ${ex.user}`);
+            lines.push(`**Tú:** ${ex.agent}`);
+            lines.push('');
+        });
+    }
+    return { system: lines.join('\n').trim() };
+}
+//# sourceMappingURL=toClaude.js.map

package/dist/compiler/toGemini.d.ts

@@ -0,0 +1,22 @@
+import { ZentiPersona } from '../parser';
+export interface GeminiPart {
+    text: string;
+}
+export interface GeminiContent {
+    role: 'user' | 'model';
+    parts: GeminiPart[];
+}
+export interface GeminiOutput {
+    systemInstruction: {
+        parts: GeminiPart[];
+    };
+    contents: GeminiContent[];
+}
+/**
+ * Compiles a ZentiPersona into Gemini-compatible format.
+ *
+ * - `systemInstruction`: identity + guardrails (+ Big Five traits)
+ * - `contents`: on_brand examples as user/model history turns
+ */
+export declare function toGemini(persona: ZentiPersona): GeminiOutput;
+//# sourceMappingURL=toGemini.d.ts.map

package/dist/compiler/toGemini.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toGemini = toGemini;
+const utils_1 = require("./utils");
+/**
+ * Compiles a ZentiPersona into Gemini-compatible format.
+ *
+ * - `systemInstruction`: identity + guardrails (+ Big Five traits)
+ * - `contents`: on_brand examples as user/model history turns
+ */
+function toGemini(persona) {
+    const systemLines = [];
+    // Identity
+    systemLines.push(`Eres ${persona.name}, ${persona.identity.role}.`);
+    systemLines.push(persona.identity.backstory);
+    systemLines.push(`Estilo de comunicación: ${persona.identity.communication_style}.`);
+    systemLines.push('');
+    // Core traits
+    const traits = (0, utils_1.translateBigFive)(persona.core);
+    if (traits.length > 0) {
+        systemLines.push('Rasgos de personalidad:');
+        traits.forEach((trait) => systemLines.push(`- ${trait}`));
+        systemLines.push('');
+    }
+    // Guardrails
+    if (persona.guardrails.always.length > 0) {
+        systemLines.push('Siempre:');
+        persona.guardrails.always.forEach((rule) => systemLines.push(`- ${rule}`));
+        systemLines.push('');
+    }
+    if (persona.guardrails.never.length > 0) {
+        systemLines.push('Nunca:');
+        persona.guardrails.never.forEach((rule) => systemLines.push(`- ${rule}`));
+        systemLines.push('');
+    }
+    if (persona.guardrails.escalate_if.length > 0) {
+        systemLines.push('Escala si:');
+        persona.guardrails.escalate_if.forEach((condition) => systemLines.push(`- ${condition}`));
+    }
+    // Examples as conversation history
+    const contents = [];
+    persona.examples.on_brand.forEach((ex) => {
+        contents.push({ role: 'user', parts: [{ text: ex.user }] });
+        contents.push({ role: 'model', parts: [{ text: ex.agent }] });
+    });
+    return {
+        systemInstruction: {
+            parts: [{ text: systemLines.join('\n').trim() }],
+        },
+        contents,
+    };
+}
+//# sourceMappingURL=toGemini.js.map

package/dist/compiler/toOpenAI.d.ts

@@ -0,0 +1,17 @@
+import { ZentiPersona } from '../parser';
+export interface OpenAIMessage {
+    role: 'user' | 'assistant';
+    content: string;
+}
+export interface OpenAIOutput {
+    system: string;
+    messages: OpenAIMessage[];
+}
+/**
+ * Compiles a ZentiPersona into OpenAI-compatible format.
+ *
+ * - `system`: identity + core in first person + guardrails
+ * - `messages`: on_brand examples as alternating user/assistant turns
+ */
+export declare function toOpenAI(persona: ZentiPersona): OpenAIOutput;
+//# sourceMappingURL=toOpenAI.d.ts.map

package/dist/compiler/toOpenAI.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toOpenAI = toOpenAI;
+const utils_1 = require("./utils");
+/**
+ * Compiles a ZentiPersona into OpenAI-compatible format.
+ *
+ * - `system`: identity + core in first person + guardrails
+ * - `messages`: on_brand examples as alternating user/assistant turns
+ */
+function toOpenAI(persona) {
+    const systemLines = [];
+    // Identity in first person
+    systemLines.push(`Eres ${persona.name}, ${persona.identity.role}.`);
+    systemLines.push(persona.identity.backstory);
+    systemLines.push(`Tu estilo de comunicación es: ${persona.identity.communication_style}.`);
+    systemLines.push('');
+    // Core traits in first person
+    const traits = (0, utils_1.translateBigFive)(persona.core);
+    if (traits.length > 0) {
+        systemLines.push('En tu forma de ser eres:');
+        traits.forEach((trait) => systemLines.push(`- ${trait}`));
+        systemLines.push('');
+    }
+    // Guardrails
+    if (persona.guardrails.always.length > 0) {
+        systemLines.push('Siempre debes:');
+        persona.guardrails.always.forEach((rule) => systemLines.push(`- ${rule}`));
+        systemLines.push('');
+    }
+    if (persona.guardrails.never.length > 0) {
+        systemLines.push('Nunca debes:');
+        persona.guardrails.never.forEach((rule) => systemLines.push(`- ${rule}`));
+        systemLines.push('');
+    }
+    if (persona.guardrails.escalate_if.length > 0) {
+        systemLines.push('Escala si:');
+        persona.guardrails.escalate_if.forEach((condition) => systemLines.push(`- ${condition}`));
+    }
+    // Few-shot examples as user/assistant message pairs
+    const messages = [];
+    persona.examples.on_brand.forEach((ex) => {
+        messages.push({ role: 'user', content: ex.user });
+        messages.push({ role: 'assistant', content: ex.agent });
+    });
+    return {
+        system: systemLines.join('\n').trim(),
+        messages,
+    };
+}
+//# sourceMappingURL=toOpenAI.js.map

package/dist/compiler/utils.d.ts

@@ -0,0 +1,7 @@
+import { ZentiPersona } from '../parser';
+/**
+ * Translates Big Five personality scores into natural language descriptors.
+ * Only the conditions specified in the spec generate a trait string.
+ */
+export declare function translateBigFive(core: ZentiPersona['core']): string[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/compiler/utils.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateBigFive = translateBigFive;
+/**
+ * Translates Big Five personality scores into natural language descriptors.
+ * Only the conditions specified in the spec generate a trait string.
+ */
+function translateBigFive(core) {
+    const traits = [];
+    if (core.openness > 0.6) {
+        traits.push('creativo y curioso, abierto a explorar soluciones nuevas');
+    }
+    if (core.conscientiousness > 0.7) {
+        traits.push('metódico y confiable, siempre sigue los pasos correctos');
+    }
+    if (core.extraversion < 0.5) {
+        traits.push('reservado pero atento, responde con precisión sin ser efusivo');
+    }
+    if (core.agreeableness > 0.7) {
+        traits.push('empático y colaborativo, prioriza la satisfacción del usuario');
+    }
+    if (core.neuroticism < 0.3) {
+        traits.push('calmado bajo presión, mantiene tono estable ante usuarios frustrados');
+    }
+    return traits;
+}
+//# sourceMappingURL=utils.js.map

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { PersonaLayer, DeployTarget, DeployOutput } from './PersonaLayer';
+export { parseZenti, ZentiPersona, ZentiExample, ZentiValidationError } from './parser';
+export { toClaude, toOpenAI, toGemini, translateBigFive, ClaudeOutput, OpenAIOutput, OpenAIMessage, GeminiOutput, GeminiContent, GeminiPart, } from './compiler';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateBigFive = exports.toGemini = exports.toOpenAI = exports.toClaude = exports.ZentiValidationError = exports.parseZenti = exports.PersonaLayer = void 0;
+var PersonaLayer_1 = require("./PersonaLayer");
+Object.defineProperty(exports, "PersonaLayer", { enumerable: true, get: function () { return PersonaLayer_1.PersonaLayer; } });
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "parseZenti", { enumerable: true, get: function () { return parser_1.parseZenti; } });
+Object.defineProperty(exports, "ZentiValidationError", { enumerable: true, get: function () { return parser_1.ZentiValidationError; } });
+var compiler_1 = require("./compiler");
+Object.defineProperty(exports, "toClaude", { enumerable: true, get: function () { return compiler_1.toClaude; } });
+Object.defineProperty(exports, "toOpenAI", { enumerable: true, get: function () { return compiler_1.toOpenAI; } });
+Object.defineProperty(exports, "toGemini", { enumerable: true, get: function () { return compiler_1.toGemini; } });
+Object.defineProperty(exports, "translateBigFive", { enumerable: true, get: function () { return compiler_1.translateBigFive; } });
+//# sourceMappingURL=index.js.map

package/dist/parser/index.d.ts

@@ -0,0 +1,34 @@
+export interface ZentiExample {
+    user: string;
+    agent: string;
+}
+export interface ZentiPersona {
+    version: string;
+    name: string;
+    core: {
+        openness: number;
+        conscientiousness: number;
+        extraversion: number;
+        agreeableness: number;
+        neuroticism: number;
+    };
+    identity: {
+        role: string;
+        backstory: string;
+        communication_style: string;
+    };
+    examples: {
+        on_brand: ZentiExample[];
+        off_brand: ZentiExample[];
+    };
+    guardrails: {
+        always: string[];
+        never: string[];
+        escalate_if: string[];
+    };
+}
+export declare class ZentiValidationError extends Error {
+    constructor(message: string);
+}
+export declare function parseZenti(content: string): ZentiPersona;
+//# sourceMappingURL=index.d.ts.map

package/dist/parser/index.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZentiValidationError = void 0;
+exports.parseZenti = parseZenti;
+const yaml = __importStar(require("js-yaml"));
+class ZentiValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ZentiValidationError';
+    }
+}
+exports.ZentiValidationError = ZentiValidationError;
+function validateNumber(value, field) {
+    if (typeof value !== 'number') {
+        throw new ZentiValidationError(`${field} debe ser un número, se recibió ${typeof value}`);
+    }
+    if (value < 0 || value > 1) {
+        throw new ZentiValidationError(`${field} debe estar entre 0.0 y 1.0, se recibió ${value}`);
+    }
+    return value;
+}
+function validateExamples(arr, field) {
+    if (!Array.isArray(arr)) {
+        throw new ZentiValidationError(`${field} debe ser un array`);
+    }
+    return arr.map((ex, i) => {
+        if (!ex || typeof ex !== 'object') {
+            throw new ZentiValidationError(`${field}[${i}] debe ser un objeto`);
+        }
+        const item = ex;
+        if (!item.user || !item.agent) {
+            throw new ZentiValidationError(`${field}[${i}] debe tener los campos "user" y "agent"`);
+        }
+        return { user: String(item.user), agent: String(item.agent) };
+    });
+}
+function parseZenti(content) {
+    let raw;
+    try {
+        raw = yaml.load(content);
+    }
+    catch (e) {
+        throw new ZentiValidationError(`YAML inválido: ${e.message}`);
+    }
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        throw new ZentiValidationError('El archivo debe ser un objeto YAML válido');
+    }
+    const obj = raw;
+    // Top-level required fields
+    if (!obj.version)
+        throw new ZentiValidationError('Falta el campo requerido: version');
+    if (!obj.name)
+        throw new ZentiValidationError('Falta el campo requerido: name');
+    if (!obj.core)
+        throw new ZentiValidationError('Falta la capa requerida: core');
+    if (!obj.identity)
+        throw new ZentiValidationError('Falta la capa requerida: identity');
+    if (!obj.examples)
+        throw new ZentiValidationError('Falta la capa requerida: examples');
+    if (!obj.guardrails)
+        throw new ZentiValidationError('Falta la capa requerida: guardrails');
+    // Validate core (Big Five)
+    if (typeof obj.core !== 'object' || Array.isArray(obj.core)) {
+        throw new ZentiValidationError('core debe ser un objeto');
+    }
+    const core = obj.core;
+    const validatedCore = {
+        openness: validateNumber(core.openness, 'core.openness'),
+        conscientiousness: validateNumber(core.conscientiousness, 'core.conscientiousness'),
+        extraversion: validateNumber(core.extraversion, 'core.extraversion'),
+        agreeableness: validateNumber(core.agreeableness, 'core.agreeableness'),
+        neuroticism: validateNumber(core.neuroticism, 'core.neuroticism'),
+    };
+    // Validate identity
+    if (typeof obj.identity !== 'object' || Array.isArray(obj.identity)) {
+        throw new ZentiValidationError('identity debe ser un objeto');
+    }
+    const identity = obj.identity;
+    if (!identity.role)
+        throw new ZentiValidationError('Falta el campo requerido: identity.role');
+    if (!identity.backstory)
+        throw new ZentiValidationError('Falta el campo requerido: identity.backstory');
+    if (!identity.communication_style) {
+        throw new ZentiValidationError('Falta el campo requerido: identity.communication_style');
+    }
+    // Validate examples
+    if (typeof obj.examples !== 'object' || Array.isArray(obj.examples)) {
+        throw new ZentiValidationError('examples debe ser un objeto');
+    }
+    const examples = obj.examples;
+    const onBrand = validateExamples(examples.on_brand, 'examples.on_brand');
+    const offBrand = validateExamples(examples.off_brand, 'examples.off_brand');
+    // Validate guardrails
+    if (typeof obj.guardrails !== 'object' || Array.isArray(obj.guardrails)) {
+        throw new ZentiValidationError('guardrails debe ser un objeto');
+    }
+    const guardrails = obj.guardrails;
+    if (!Array.isArray(guardrails.always)) {
+        throw new ZentiValidationError('guardrails.always debe ser un array');
+    }
+    if (!Array.isArray(guardrails.never)) {
+        throw new ZentiValidationError('guardrails.never debe ser un array');
+    }
+    if (!Array.isArray(guardrails.escalate_if)) {
+        throw new ZentiValidationError('guardrails.escalate_if debe ser un array');
+    }
+    return {
+        version: String(obj.version),
+        name: String(obj.name),
+        core: validatedCore,
+        identity: {
+            role: String(identity.role),
+            backstory: String(identity.backstory),
+            communication_style: String(identity.communication_style),
+        },
+        examples: {
+            on_brand: onBrand,
+            off_brand: offBrand,
+        },
+        guardrails: {
+            always: guardrails.always.map(String),
+            never: guardrails.never.map(String),
+            escalate_if: guardrails.escalate_if.map(String),
+        },
+    };
+}
+//# sourceMappingURL=index.js.map