@x12i/ai-gateway 7.9.1

package/dist-cjs/object-types-library.cjs

@@ -0,0 +1,215 @@
+"use strict";
+/**
+ * Object Types Library
+ *
+ * Standard object type definitions for AI Gateway structured outputs.
+ * Each agent type has corresponding object types with JSON schemas.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OBJECT_TYPES_LIBRARY = void 0;
+exports.getObjectType = getObjectType;
+exports.getObjectTypesForAgent = getObjectTypesForAgent;
+exports.OBJECT_TYPES_LIBRARY = {
+    /**
+     * AI Reasoner - General reasoning and analysis
+     */
+    'reasoning-result': {
+        type: 'reasoning-result',
+        whenToUse: 'For general reasoning and analysis tasks',
+        description: 'Structured reasoning output with analysis and conclusion',
+        schema: {
+            analysis: '<string> Detailed analysis of the problem',
+            reasoning: [
+                '<string> Step-by-step reasoning process'
+            ],
+            conclusion: '<string> Final conclusion or recommendation',
+            confidence: '<number> Confidence score (0-1)'
+        }
+    },
+    /**
+     * AI Auditor - Code and process auditing
+     */
+    'audit-report': {
+        type: 'audit-report',
+        whenToUse: 'For auditing code, processes, or compliance',
+        description: 'Structured audit findings and recommendations',
+        schema: {
+            summary: '<string> Executive summary of audit findings',
+            findings: [
+                '<object> Audit finding with structure:\n{\n  "severity": "<string> critical|high|medium|low|info",\n  "category": "<string> Category of the finding",\n  "description": "<string> Description of the finding",\n  "location": "<string> Location where the finding was identified",\n  "recommendation": "<string> Recommended action to address the finding"\n}'
+            ],
+            overallScore: '<number> Overall audit score (0-100)',
+            recommendations: [
+                '<string> Recommended action or improvement'
+            ]
+        }
+    },
+    /**
+     * AI Scoper - Project scoping and requirements
+     */
+    'scope-definition': {
+        type: 'scope-definition',
+        whenToUse: 'For defining project scope and requirements',
+        description: 'Structured project scope with requirements and constraints',
+        schema: {
+            projectName: '<string> Name of the project',
+            objectives: [
+                '<string> Project objective'
+            ],
+            requirements: {
+                functional: [
+                    '<string> Functional requirement'
+                ],
+                nonFunctional: [
+                    '<string> Non-functional requirement'
+                ],
+                technical: [
+                    '<string> Technical requirement'
+                ]
+            },
+            constraints: [
+                '<object> Constraint with structure:\n{\n  "type": "<string> Type of constraint",\n  "description": "<string> Description of the constraint"\n}'
+            ],
+            estimatedEffort: {
+                hours: '<number> Estimated hours',
+                complexity: '<string> low|medium|high|very-high'
+            }
+        }
+    },
+    /**
+     * AI Discovery - Research and information discovery
+     */
+    'discovery-findings': {
+        type: 'discovery-findings',
+        whenToUse: 'For research and information discovery tasks',
+        description: 'Structured discovery results with insights and sources',
+        schema: {
+            topic: '<string> Topic of the discovery',
+            keyFindings: [
+                '<object> Key finding with structure:\n{\n  "finding": "<string> The finding",\n  "importance": "<string> critical|high|medium|low",\n  "source": "<string> Source of the finding",\n  "confidence": "<number> Confidence score (0-1)"\n}'
+            ],
+            insights: [
+                '<string> Insight or observation'
+            ],
+            relatedTopics: [
+                '<string> Related topic'
+            ],
+            nextSteps: [
+                '<string> Recommended next step'
+            ]
+        }
+    },
+    /**
+     * AI Planner - Planning and strategy
+     */
+    'action-plan': {
+        type: 'action-plan',
+        whenToUse: 'For creating action plans and strategies',
+        description: 'Structured action plan with tasks and timeline',
+        schema: {
+            goal: '<string> Goal of the action plan',
+            strategy: '<string> Strategy to achieve the goal',
+            phases: [
+                '<object> Phase with structure:\n{\n  "name": "<string> Phase name",\n  "description": "<string> Phase description",\n  "duration": "<string> Estimated duration",\n  "tasks": [\n    "<object> Task with structure:\n    {\n      \"id\": \"<string> Task ID\",\n      \"title\": \"<string> Task title\",\n      \"description\": \"<string> Task description\",\n      \"priority\": \"<string> critical|high|medium|low\",\n      \"estimatedHours\": \"<number> Estimated hours\",\n      \"dependencies\": [\"<string> Task ID dependency\"]\n    }"\n  ]\n}'
+            ],
+            risks: [
+                '<object> Risk with structure:\n{\n  "risk": "<string> Description of the risk",\n  "impact": "<string> high|medium|low",\n  "mitigation": "<string> Mitigation strategy"\n}'
+            ],
+            successCriteria: [
+                '<string> Success criterion'
+            ]
+        }
+    },
+    /**
+     * AI Executor - Task execution
+     */
+    'execution-result': {
+        type: 'execution-result',
+        whenToUse: 'For task execution and implementation results',
+        description: 'Structured execution results with status and outputs',
+        schema: {
+            taskId: '<string> Task identifier',
+            status: '<string> completed|partial|failed|blocked',
+            outputs: [
+                '<object> Output with structure:\n{\n  "type": "<string> Type of output",\n  "description": "<string> Description of the output",\n  "content": "<string> Output content",\n  "metadata": "<object> Additional metadata"\n}'
+            ],
+            stepsCompleted: [
+                '<object> Completed step with structure:\n{\n  "step": "<string> Step name",\n  "status": "<string> Step status",\n  "timestamp": "<string> Timestamp",\n  "notes": "<string> Additional notes"\n}'
+            ],
+            errors: [
+                '<object> Error with structure:\n{\n  "code": "<string> Error code",\n  "message": "<string> Error message",\n  "severity": "<string> Error severity"\n}'
+            ],
+            nextActions: [
+                '<string> Recommended next action'
+            ]
+        }
+    },
+    /**
+     * Common: Classification
+     */
+    'classification': {
+        type: 'classification',
+        whenToUse: 'For classification and categorization tasks',
+        description: 'Classification result with classes and confidence scores',
+        schema: {
+            classes: [
+                '<string> Classification class'
+            ],
+            confidence: '<object> Confidence scores for each class (key-value pairs)',
+            primaryClass: '<string> Primary classification class'
+        }
+    },
+    /**
+     * Common: Extraction
+     */
+    'extraction': {
+        type: 'extraction',
+        whenToUse: 'For extracting structured data from text',
+        description: 'Extracted structured data with metadata',
+        schema: {
+            extracted: '<object> Extracted key-value pairs',
+            metadata: {
+                source: '<string> Source of the extracted data',
+                confidence: '<number> Confidence score of the extraction'
+            }
+        }
+    },
+    /**
+     * Common: Question-Answer
+     */
+    'question-answer': {
+        type: 'question-answer',
+        whenToUse: 'For answering questions',
+        description: 'Question answer with reasoning and sources',
+        schema: {
+            answer: '<string> Answer to the question',
+            reasoning: '<string> Reasoning behind the answer',
+            sources: [
+                '<string> Source reference'
+            ],
+            confidence: '<number> Confidence score (0-1)'
+        }
+    }
+};
+/**
+ * Get object type definition by name
+ */
+function getObjectType(typeName) {
+    return exports.OBJECT_TYPES_LIBRARY[typeName];
+}
+/**
+ * Get all object types for a specific agent type
+ */
+function getObjectTypesForAgent(agentType) {
+    const mapping = {
+        'ai-reasoner': ['reasoning-result', 'classification', 'question-answer'],
+        'ai-auditor': ['audit-report'],
+        'ai-scoper': ['scope-definition'],
+        'ai-discovery': ['discovery-findings'],
+        'ai-planner': ['action-plan'],
+        'ai-executor': ['execution-result'],
+        'chat': [] // Chat doesn't use structured outputs
+    };
+    const typeNames = mapping[agentType] || [];
+    return typeNames.map(name => exports.OBJECT_TYPES_LIBRARY[name]);
+}

package/dist-cjs/object-types-library.d.ts

@@ -0,0 +1,351 @@
+/**
+ * Object Types Library
+ *
+ * Standard object type definitions for AI Gateway structured outputs.
+ * Each agent type has corresponding object types with JSON schemas.
+ */
+export declare const OBJECT_TYPES_LIBRARY: {
+    /**
+     * AI Reasoner - General reasoning and analysis
+     */
+    readonly 'reasoning-result': {
+        readonly type: "reasoning-result";
+        readonly whenToUse: "For general reasoning and analysis tasks";
+        readonly description: "Structured reasoning output with analysis and conclusion";
+        readonly schema: {
+            readonly analysis: "<string> Detailed analysis of the problem";
+            readonly reasoning: readonly ["<string> Step-by-step reasoning process"];
+            readonly conclusion: "<string> Final conclusion or recommendation";
+            readonly confidence: "<number> Confidence score (0-1)";
+        };
+    };
+    /**
+     * AI Auditor - Code and process auditing
+     */
+    readonly 'audit-report': {
+        readonly type: "audit-report";
+        readonly whenToUse: "For auditing code, processes, or compliance";
+        readonly description: "Structured audit findings and recommendations";
+        readonly schema: {
+            readonly summary: "<string> Executive summary of audit findings";
+            readonly findings: readonly ["<object> Audit finding with structure:\n{\n  \"severity\": \"<string> critical|high|medium|low|info\",\n  \"category\": \"<string> Category of the finding\",\n  \"description\": \"<string> Description of the finding\",\n  \"location\": \"<string> Location where the finding was identified\",\n  \"recommendation\": \"<string> Recommended action to address the finding\"\n}"];
+            readonly overallScore: "<number> Overall audit score (0-100)";
+            readonly recommendations: readonly ["<string> Recommended action or improvement"];
+        };
+    };
+    /**
+     * AI Scoper - Project scoping and requirements
+     */
+    readonly 'scope-definition': {
+        readonly type: "scope-definition";
+        readonly whenToUse: "For defining project scope and requirements";
+        readonly description: "Structured project scope with requirements and constraints";
+        readonly schema: {
+            readonly projectName: "<string> Name of the project";
+            readonly objectives: readonly ["<string> Project objective"];
+            readonly requirements: {
+                readonly functional: readonly ["<string> Functional requirement"];
+                readonly nonFunctional: readonly ["<string> Non-functional requirement"];
+                readonly technical: readonly ["<string> Technical requirement"];
+            };
+            readonly constraints: readonly ["<object> Constraint with structure:\n{\n  \"type\": \"<string> Type of constraint\",\n  \"description\": \"<string> Description of the constraint\"\n}"];
+            readonly estimatedEffort: {
+                readonly hours: "<number> Estimated hours";
+                readonly complexity: "<string> low|medium|high|very-high";
+            };
+        };
+    };
+    /**
+     * AI Discovery - Research and information discovery
+     */
+    readonly 'discovery-findings': {
+        readonly type: "discovery-findings";
+        readonly whenToUse: "For research and information discovery tasks";
+        readonly description: "Structured discovery results with insights and sources";
+        readonly schema: {
+            readonly topic: "<string> Topic of the discovery";
+            readonly keyFindings: readonly ["<object> Key finding with structure:\n{\n  \"finding\": \"<string> The finding\",\n  \"importance\": \"<string> critical|high|medium|low\",\n  \"source\": \"<string> Source of the finding\",\n  \"confidence\": \"<number> Confidence score (0-1)\"\n}"];
+            readonly insights: readonly ["<string> Insight or observation"];
+            readonly relatedTopics: readonly ["<string> Related topic"];
+            readonly nextSteps: readonly ["<string> Recommended next step"];
+        };
+    };
+    /**
+     * AI Planner - Planning and strategy
+     */
+    readonly 'action-plan': {
+        readonly type: "action-plan";
+        readonly whenToUse: "For creating action plans and strategies";
+        readonly description: "Structured action plan with tasks and timeline";
+        readonly schema: {
+            readonly goal: "<string> Goal of the action plan";
+            readonly strategy: "<string> Strategy to achieve the goal";
+            readonly phases: readonly ["<object> Phase with structure:\n{\n  \"name\": \"<string> Phase name\",\n  \"description\": \"<string> Phase description\",\n  \"duration\": \"<string> Estimated duration\",\n  \"tasks\": [\n    \"<object> Task with structure:\n    {\n      \"id\": \"<string> Task ID\",\n      \"title\": \"<string> Task title\",\n      \"description\": \"<string> Task description\",\n      \"priority\": \"<string> critical|high|medium|low\",\n      \"estimatedHours\": \"<number> Estimated hours\",\n      \"dependencies\": [\"<string> Task ID dependency\"]\n    }\"\n  ]\n}"];
+            readonly risks: readonly ["<object> Risk with structure:\n{\n  \"risk\": \"<string> Description of the risk\",\n  \"impact\": \"<string> high|medium|low\",\n  \"mitigation\": \"<string> Mitigation strategy\"\n}"];
+            readonly successCriteria: readonly ["<string> Success criterion"];
+        };
+    };
+    /**
+     * AI Executor - Task execution
+     */
+    readonly 'execution-result': {
+        readonly type: "execution-result";
+        readonly whenToUse: "For task execution and implementation results";
+        readonly description: "Structured execution results with status and outputs";
+        readonly schema: {
+            readonly taskId: "<string> Task identifier";
+            readonly status: "<string> completed|partial|failed|blocked";
+            readonly outputs: readonly ["<object> Output with structure:\n{\n  \"type\": \"<string> Type of output\",\n  \"description\": \"<string> Description of the output\",\n  \"content\": \"<string> Output content\",\n  \"metadata\": \"<object> Additional metadata\"\n}"];
+            readonly stepsCompleted: readonly ["<object> Completed step with structure:\n{\n  \"step\": \"<string> Step name\",\n  \"status\": \"<string> Step status\",\n  \"timestamp\": \"<string> Timestamp\",\n  \"notes\": \"<string> Additional notes\"\n}"];
+            readonly errors: readonly ["<object> Error with structure:\n{\n  \"code\": \"<string> Error code\",\n  \"message\": \"<string> Error message\",\n  \"severity\": \"<string> Error severity\"\n}"];
+            readonly nextActions: readonly ["<string> Recommended next action"];
+        };
+    };
+    /**
+     * Common: Classification
+     */
+    readonly classification: {
+        readonly type: "classification";
+        readonly whenToUse: "For classification and categorization tasks";
+        readonly description: "Classification result with classes and confidence scores";
+        readonly schema: {
+            readonly classes: readonly ["<string> Classification class"];
+            readonly confidence: "<object> Confidence scores for each class (key-value pairs)";
+            readonly primaryClass: "<string> Primary classification class";
+        };
+    };
+    /**
+     * Common: Extraction
+     */
+    readonly extraction: {
+        readonly type: "extraction";
+        readonly whenToUse: "For extracting structured data from text";
+        readonly description: "Extracted structured data with metadata";
+        readonly schema: {
+            readonly extracted: "<object> Extracted key-value pairs";
+            readonly metadata: {
+                readonly source: "<string> Source of the extracted data";
+                readonly confidence: "<number> Confidence score of the extraction";
+            };
+        };
+    };
+    /**
+     * Common: Question-Answer
+     */
+    readonly 'question-answer': {
+        readonly type: "question-answer";
+        readonly whenToUse: "For answering questions";
+        readonly description: "Question answer with reasoning and sources";
+        readonly schema: {
+            readonly answer: "<string> Answer to the question";
+            readonly reasoning: "<string> Reasoning behind the answer";
+            readonly sources: readonly ["<string> Source reference"];
+            readonly confidence: "<number> Confidence score (0-1)";
+        };
+    };
+};
+/**
+ * Get object type definition by name
+ */
+export declare function getObjectType(typeName: keyof typeof OBJECT_TYPES_LIBRARY): {
+    readonly type: "reasoning-result";
+    readonly whenToUse: "For general reasoning and analysis tasks";
+    readonly description: "Structured reasoning output with analysis and conclusion";
+    readonly schema: {
+        readonly analysis: "<string> Detailed analysis of the problem";
+        readonly reasoning: readonly ["<string> Step-by-step reasoning process"];
+        readonly conclusion: "<string> Final conclusion or recommendation";
+        readonly confidence: "<number> Confidence score (0-1)";
+    };
+} | {
+    readonly type: "audit-report";
+    readonly whenToUse: "For auditing code, processes, or compliance";
+    readonly description: "Structured audit findings and recommendations";
+    readonly schema: {
+        readonly summary: "<string> Executive summary of audit findings";
+        readonly findings: readonly ["<object> Audit finding with structure:\n{\n  \"severity\": \"<string> critical|high|medium|low|info\",\n  \"category\": \"<string> Category of the finding\",\n  \"description\": \"<string> Description of the finding\",\n  \"location\": \"<string> Location where the finding was identified\",\n  \"recommendation\": \"<string> Recommended action to address the finding\"\n}"];
+        readonly overallScore: "<number> Overall audit score (0-100)";
+        readonly recommendations: readonly ["<string> Recommended action or improvement"];
+    };
+} | {
+    readonly type: "scope-definition";
+    readonly whenToUse: "For defining project scope and requirements";
+    readonly description: "Structured project scope with requirements and constraints";
+    readonly schema: {
+        readonly projectName: "<string> Name of the project";
+        readonly objectives: readonly ["<string> Project objective"];
+        readonly requirements: {
+            readonly functional: readonly ["<string> Functional requirement"];
+            readonly nonFunctional: readonly ["<string> Non-functional requirement"];
+            readonly technical: readonly ["<string> Technical requirement"];
+        };
+        readonly constraints: readonly ["<object> Constraint with structure:\n{\n  \"type\": \"<string> Type of constraint\",\n  \"description\": \"<string> Description of the constraint\"\n}"];
+        readonly estimatedEffort: {
+            readonly hours: "<number> Estimated hours";
+            readonly complexity: "<string> low|medium|high|very-high";
+        };
+    };
+} | {
+    readonly type: "discovery-findings";
+    readonly whenToUse: "For research and information discovery tasks";
+    readonly description: "Structured discovery results with insights and sources";
+    readonly schema: {
+        readonly topic: "<string> Topic of the discovery";
+        readonly keyFindings: readonly ["<object> Key finding with structure:\n{\n  \"finding\": \"<string> The finding\",\n  \"importance\": \"<string> critical|high|medium|low\",\n  \"source\": \"<string> Source of the finding\",\n  \"confidence\": \"<number> Confidence score (0-1)\"\n}"];
+        readonly insights: readonly ["<string> Insight or observation"];
+        readonly relatedTopics: readonly ["<string> Related topic"];
+        readonly nextSteps: readonly ["<string> Recommended next step"];
+    };
+} | {
+    readonly type: "action-plan";
+    readonly whenToUse: "For creating action plans and strategies";
+    readonly description: "Structured action plan with tasks and timeline";
+    readonly schema: {
+        readonly goal: "<string> Goal of the action plan";
+        readonly strategy: "<string> Strategy to achieve the goal";
+        readonly phases: readonly ["<object> Phase with structure:\n{\n  \"name\": \"<string> Phase name\",\n  \"description\": \"<string> Phase description\",\n  \"duration\": \"<string> Estimated duration\",\n  \"tasks\": [\n    \"<object> Task with structure:\n    {\n      \"id\": \"<string> Task ID\",\n      \"title\": \"<string> Task title\",\n      \"description\": \"<string> Task description\",\n      \"priority\": \"<string> critical|high|medium|low\",\n      \"estimatedHours\": \"<number> Estimated hours\",\n      \"dependencies\": [\"<string> Task ID dependency\"]\n    }\"\n  ]\n}"];
+        readonly risks: readonly ["<object> Risk with structure:\n{\n  \"risk\": \"<string> Description of the risk\",\n  \"impact\": \"<string> high|medium|low\",\n  \"mitigation\": \"<string> Mitigation strategy\"\n}"];
+        readonly successCriteria: readonly ["<string> Success criterion"];
+    };
+} | {
+    readonly type: "execution-result";
+    readonly whenToUse: "For task execution and implementation results";
+    readonly description: "Structured execution results with status and outputs";
+    readonly schema: {
+        readonly taskId: "<string> Task identifier";
+        readonly status: "<string> completed|partial|failed|blocked";
+        readonly outputs: readonly ["<object> Output with structure:\n{\n  \"type\": \"<string> Type of output\",\n  \"description\": \"<string> Description of the output\",\n  \"content\": \"<string> Output content\",\n  \"metadata\": \"<object> Additional metadata\"\n}"];
+        readonly stepsCompleted: readonly ["<object> Completed step with structure:\n{\n  \"step\": \"<string> Step name\",\n  \"status\": \"<string> Step status\",\n  \"timestamp\": \"<string> Timestamp\",\n  \"notes\": \"<string> Additional notes\"\n}"];
+        readonly errors: readonly ["<object> Error with structure:\n{\n  \"code\": \"<string> Error code\",\n  \"message\": \"<string> Error message\",\n  \"severity\": \"<string> Error severity\"\n}"];
+        readonly nextActions: readonly ["<string> Recommended next action"];
+    };
+} | {
+    readonly type: "classification";
+    readonly whenToUse: "For classification and categorization tasks";
+    readonly description: "Classification result with classes and confidence scores";
+    readonly schema: {
+        readonly classes: readonly ["<string> Classification class"];
+        readonly confidence: "<object> Confidence scores for each class (key-value pairs)";
+        readonly primaryClass: "<string> Primary classification class";
+    };
+} | {
+    readonly type: "extraction";
+    readonly whenToUse: "For extracting structured data from text";
+    readonly description: "Extracted structured data with metadata";
+    readonly schema: {
+        readonly extracted: "<object> Extracted key-value pairs";
+        readonly metadata: {
+            readonly source: "<string> Source of the extracted data";
+            readonly confidence: "<number> Confidence score of the extraction";
+        };
+    };
+} | {
+    readonly type: "question-answer";
+    readonly whenToUse: "For answering questions";
+    readonly description: "Question answer with reasoning and sources";
+    readonly schema: {
+        readonly answer: "<string> Answer to the question";
+        readonly reasoning: "<string> Reasoning behind the answer";
+        readonly sources: readonly ["<string> Source reference"];
+        readonly confidence: "<number> Confidence score (0-1)";
+    };
+};
+/**
+ * Get all object types for a specific agent type
+ */
+export declare function getObjectTypesForAgent(agentType: string): Array<typeof OBJECT_TYPES_LIBRARY[keyof typeof OBJECT_TYPES_LIBRARY]>;
+/**
+ * Type definitions for object type results
+ */
+export type ReasoningResult = {
+    analysis: string;
+    reasoning?: string[];
+    conclusion: string;
+    confidence?: number;
+};
+export type AuditReport = {
+    summary: string;
+    findings: Array<{
+        severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
+        category?: string;
+        description: string;
+        location?: string;
+        recommendation?: string;
+    }>;
+    overallScore?: number;
+    recommendations?: string[];
+};
+export type ScopeDefinition = {
+    projectName: string;
+    objectives: string[];
+    requirements: {
+        functional?: string[];
+        nonFunctional?: string[];
+        technical?: string[];
+    };
+    constraints?: Array<{
+        type: string;
+        description: string;
+    }>;
+    estimatedEffort?: {
+        hours: number;
+        complexity: 'low' | 'medium' | 'high' | 'very-high';
+    };
+};
+export type DiscoveryFindings = {
+    topic: string;
+    keyFindings: Array<{
+        finding: string;
+        importance: 'critical' | 'high' | 'medium' | 'low';
+        source?: string;
+        confidence?: number;
+    }>;
+    insights?: string[];
+    relatedTopics?: string[];
+    nextSteps?: string[];
+};
+export type ActionPlan = {
+    goal: string;
+    strategy?: string;
+    phases: Array<{
+        name: string;
+        description?: string;
+        duration?: string;
+        tasks: Array<{
+            id: string;
+            title: string;
+            description?: string;
+            priority: 'critical' | 'high' | 'medium' | 'low';
+            estimatedHours?: number;
+            dependencies?: string[];
+        }>;
+    }>;
+    risks?: Array<{
+        risk: string;
+        impact: 'high' | 'medium' | 'low';
+        mitigation?: string;
+    }>;
+    successCriteria?: string[];
+};
+export type ExecutionResult = {
+    taskId: string;
+    status: 'completed' | 'partial' | 'failed' | 'blocked';
+    outputs: Array<{
+        type: string;
+        description: string;
+        content?: string;
+        metadata?: Record<string, unknown>;
+    }>;
+    stepsCompleted?: Array<{
+        step: string;
+        status: string;
+        timestamp?: string;
+        notes?: string;
+    }>;
+    errors?: Array<{
+        code: string;
+        message: string;
+        severity?: string;
+    }>;
+    nextActions?: string[];
+};

package/dist-cjs/output-auditor.cjs

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * Output Structure Auditor
+ *
+ * Audits the structure of parsed output against the expected schema.
+ * Provides detailed analysis of what fields are present, missing, or extra.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditOutputStructure = auditOutputStructure;
+/**
+ * Audits the structure of parsed output against the expected schema
+ *
+ * @param parsedOutput - The parsed output object to audit
+ * @param schema - The JSON schema to compare against
+ * @returns Audit result with detailed structure analysis
+ */
+function auditOutputStructure(parsedOutput, schema) {
+    // Only audit if we have both parsedOutput and schema
+    if (!parsedOutput || !schema) {
+        return undefined;
+    }
+    // Only audit objects (not arrays or primitives)
+    if (typeof parsedOutput !== 'object' || Array.isArray(parsedOutput) || parsedOutput === null) {
+        return undefined;
+    }
+    const output = parsedOutput;
+    const schemaProperties = schema?.properties || {};
+    const requiredFields = schema?.required || [];
+    // Get all fields from response
+    const responseFields = new Set(Object.keys(output));
+    // Get all fields from schema
+    const schemaFields = new Set(Object.keys(schemaProperties));
+    // Find missing required fields
+    const missingRequired = requiredFields.filter((field) => !responseFields.has(field));
+    // Find extra fields (in response but not in schema)
+    const extra = Array.from(responseFields).filter(field => !schemaFields.has(field));
+    // Find matching fields (in both response and schema)
+    const matching = Array.from(responseFields).filter(field => schemaFields.has(field));
+    // Check if structure matches
+    const hasAllRequired = missingRequired.length === 0;
+    const hasNoExtra = extra.length === 0;
+    const structureMatches = hasAllRequired && hasNoExtra;
+    return {
+        hasAllRequiredFields: hasAllRequired,
+        missingRequiredFields: missingRequired.length > 0 ? missingRequired : undefined,
+        extraFields: extra.length > 0 ? extra : undefined,
+        matchingFields: matching.length > 0 ? matching : undefined,
+        responseFieldCount: responseFields.size,
+        schemaFieldCount: schemaFields.size,
+        structureMatches
+    };
+}

package/dist-cjs/output-auditor.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Output Structure Auditor
+ *
+ * Audits the structure of parsed output against the expected schema.
+ * Provides detailed analysis of what fields are present, missing, or extra.
+ */
+export interface OutputAuditResult {
+    /**
+     * Whether all required fields from schema are present
+     */
+    hasAllRequiredFields: boolean;
+    /**
+     * Missing required fields (if any)
+     */
+    missingRequiredFields?: string[];
+    /**
+     * Fields present in response but not in schema (extra fields)
+     */
+    extraFields?: string[];
+    /**
+     * Fields present in both response and schema
+     */
+    matchingFields?: string[];
+    /**
+     * Total number of fields in the response
+     */
+    responseFieldCount: number;
+    /**
+     * Total number of fields expected in schema
+     */
+    schemaFieldCount: number;
+    /**
+     * Whether the structure matches the schema exactly (all required fields present, no extra fields)
+     */
+    structureMatches: boolean;
+}
+/**
+ * Audits the structure of parsed output against the expected schema
+ *
+ * @param parsedOutput - The parsed output object to audit
+ * @param schema - The JSON schema to compare against
+ * @returns Audit result with detailed structure analysis
+ */
+export declare function auditOutputStructure(parsedOutput: unknown, schema: Record<string, unknown>): OutputAuditResult | undefined;