@simpleapps-com/augur-api 0.3.3 → 0.4.0

package/dist/cjs/services/gregorovich/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/services/gregorovich/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAGL,uBAAuB,EAEvB,kBAAkB,EAClB,gBAAgB,EAEhB,qBAAqB,EACrB,mBAAmB,EAEnB,2BAA2B,EAE3B,oBAAoB,EACrB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;GAQG;AACH,qBAAa,iBAAkB,SAAQ,iBAAiB;gBAC1C,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,MAAM;IAI9C,SAAS,CAAC,qBAAqB,IAAI,MAAM;IAIzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,QAAQ,CAAC,WAAW;;;;;;;;;OAA2D;IAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwDG;IACH,QAAQ,CAAC,UAAU,GAAU,QAAQ,uBAAuB,KAAG,OAAO,CAAC,kBAAkB,CAAC,CAUxF;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACH,QAAQ,CAAC,aAAa,QAAa,OAAO,CAAC,qBAAqB,CAAC,CAM/D;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwEG;IACH,QAAQ,CAAC,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAIrB;IAIF;;;OAGG;IACH,QAAQ,CAAC,eAAe,QAAa,OAAO,CAAC,MAAM,CAAC,CAGlD;IAEF;;;;OAIG;IACH,QAAQ,CAAC,cAAc,GAAU,QAAQ,uBAAuB,KAAG,OAAO,CAAC,gBAAgB,CAAC,CAG1F;IAEF;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,QAAa,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAGnE;IAEF;;;;OAIG;IACH,QAAQ,CAAC,kBAAkB,GACzB,QAAQ,2BAA2B,KAClC,OAAO,CAAC,oBAAoB,CAAC,CAG9B;CACH"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/services/gregorovich/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAEL,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAEhB,iBAAiB,EACjB,eAAe,EAEf,2BAA2B,EAC3B,oBAAoB,EACrB,MAAM,WAAW,CAAC;AASnB;;;;;;;;GAQG;AACH,qBAAa,iBAAkB,SAAQ,iBAAiB;gBAC1C,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,MAAM;IAI9C,SAAS,CAAC,qBAAqB,IAAI,MAAM;IAIzC;;;OAGG;IACH,QAAQ,CAAC,OAAO;QACd;;;WAGG;;YAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAwDG;0BACiB,uBAAuB,KAAG,OAAO,CAAC,kBAAkB,CAAC;YAYzE;;;;eAIG;8BACqB,uBAAuB,KAAG,OAAO,CAAC,gBAAgB,CAAC;;MAK7E;IAEF;;;OAGG;IACH,QAAQ,CAAC,SAAS;QAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDG;oBACa,OAAO,CAAC,iBAAiB,CAAC;QAQ1C;;;WAGG;uBACgB,OAAO,CAAC,eAAe,EAAE,CAAC;MAI7C;IAEF;;;OAGG;IACH,QAAQ,CAAC,WAAW;QAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCG;;;;;;;;;;;QAGH;;;WAGG;uBACgB,OAAO,CAAC,MAAM,CAAC;MAIlC;IAEF;;;OAGG;IACH,QAAQ,CAAC,MAAM;QACb;;;WAGG;;YAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAwEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAOH;;;;eAIG;8BACqB,2BAA2B,KAAG,OAAO,CAAC,oBAAoB,CAAC;;MAKrF;CACH"}

package/dist/cjs/services/gregorovich/client.js

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GregorovichClient = void 0;
 const base_client_1 = require("../../core/base-client");
-const schemas_1 = require("./schemas");
+const healthCheck_1 = require("./schemas/healthCheck");
+const chatGptAsk_1 = require("./schemas/chatGptAsk");
+const documents_1 = require("./schemas/documents");
+const ollamaGenerate_1 = require("./schemas/ollamaGenerate");
 /**
  * Gregorovich AI Service Client
  *
@@ -16,269 +19,304 @@ class GregorovichClient extends base_client_1.BaseServiceClient {
     constructor(http, baseUrl) {
         super('gregorovich', http, baseUrl || 'https://gregorovich.augur-api.com');
         /**
-         * Check service health and availability
-         *
-         * @fullPath api.gregorovich.healthCheck.get
-         * @service gregorovich
-         * @domain system-health
-         * @dataMethod healthCheckData
-         * @discoverable true
-         * @searchTerms ["health", "status", "availability", "ping", "check", "ai service"]
-         * @relatedEndpoints ["api.gregorovich.chatGpt.ask", "api.gregorovich.documents.list", "api.gregorovich.ollama.generate", "api.agrWork.healthCheck.get"]
-         * @commonPatterns ["Health check", "Service status", "AI service availability", "System monitoring"]
-         * @workflow ["system-monitoring", "health-checks", "service-discovery", "ai-service-verification"]
-         * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header"]
-         * @nextSteps ["Use AI endpoints if healthy", "Verify AI service connectivity", "Monitor service metrics"]
-         * @businessRules ["Returns service status and basic info", "Requires standard authentication", "Standard health check format"]
-         * @functionalArea "system-monitoring"
-         * @caching "No caching - real-time status required"
-         * @performance "Fast response, minimal processing, use for AI service monitoring"
-         *
-         * @returns Promise<HealthCheckResponse> Service health status
-         *
-         * @example
-         * ```typescript
-         * // Check if AI service is healthy
-         * const response = await client.healthCheck();
-         * console.log(response.data); // Health status string
-         * console.log(response.status); // HTTP status code
-         *
-         * // Get just the health status
-         * const status = await client.healthCheckData();
-         * console.log(status); // Direct string access
-         * ```
+         * Chat GPT endpoints
+         * OpenAPI Path: /chat-gpt/*
          */
-        this.healthCheck = this.createHealthCheckMethod(schemas_1.HealthCheckResponseSchema);
-        /**
-         * Ask ChatGPT a question with advanced AI capabilities
-         *
-         * @fullPath api.gregorovich.chatGpt.ask
-         * @service gregorovich
-         * @domain ai-conversation
-         * @dataMethod chatGptAskData
-         * @discoverable true
-         * @searchTerms ["chatgpt", "ai", "question", "ask", "conversation", "gpt", "openai", "assistant", "chat"]
-         * @relatedEndpoints ["api.gregorovich.ollama.generate", "api.gregorovich.documents.list", "api.agrSite.ai.transcripts.create", "api.p21Pim.ai.suggestions.get"]
-         * @commonPatterns ["Ask AI question", "Get AI assistance", "Conversational AI", "AI-powered help", "Question answering", "AI consultation"]
-         * @workflow ["ai-conversation", "customer-support", "content-generation", "decision-support", "knowledge-retrieval"]
-         * @prerequisites ["Valid authentication token", "x-site-id header", "Question parameter", "ChatGPT service availability"]
-         * @nextSteps ["Process AI response", "Continue conversation", "Store conversation history", "Analyze AI recommendations"]
-         * @businessRules ["Requires question parameter", "Supports conversation context", "Token usage tracking", "Response quality metrics", "Configurable AI parameters"]
-         * @functionalArea "ai-and-automation"
-         * @crossSite "Multi-site AI conversation support"
-         * @caching "Cache responses for 1 hour for identical questions, AI responses are generally stable"
-         * @performance "Response time varies by question complexity, use streaming for long responses"
-         *
-         * @param params ChatGPT question parameters including question text and AI configuration options
-         * @returns Promise<ChatGptAskResponse> Complete AI response with answer, metadata, and usage information
-         *
-         * @example
-         * ```typescript
-         * // Ask a simple question
-         * const aiResponse = await client.chatGptAsk({ question: 'What is the weather like today?' });
-         * console.log(aiResponse.data.answer); // AI generated answer
-         * console.log(aiResponse.data.tokens); // Token usage information
-         *
-         * // Get just the AI answer
-         * const answer = await client.chatGptAskData({ question: 'Explain quantum computing' });
-         * console.log(answer.answer); // Direct access to AI response
-         *
-         * // Advanced AI configuration
-         * const complexRequest = {
-         *   question: 'Write a business plan for a tech startup',
-         *   temperature: 0.7,
-         *   maxTokens: 2000,
-         *   format: 'markdown' as const,
-         *   systemPrompt: 'You are a business consultant with 20 years of experience',
-         *   conversationId: 'conv-123',
-         *   language: 'english'
-         * };
-         *
-         * const businessPlan = await client.chatGptAskData(complexRequest);
-         * console.log(businessPlan.answer); // Detailed business plan
-         * console.log(businessPlan.usage); // Token usage breakdown
-         *
-         * // Continue a conversation
-         * const followUp = await client.chatGptAskData({
-         *   question: 'Can you expand on the marketing strategy section?',
-         *   conversationId: 'conv-123',
-         *   temperature: 0.5
-         * });
-         * ```
-         */
-        this.chatGptAsk = async (params) => {
-            return this.executeRequest({
-                method: 'GET',
-                path: '/chat-gpt/ask',
-                paramsSchema: schemas_1.ChatGptAskRequestParamsSchema,
-                responseSchema: schemas_1.ChatGptAskResponseSchema,
-            }, params);
-        };
-        /**
-         * List available documents in the AI knowledge base
-         *
-         * @fullPath api.gregorovich.documents.list
-         * @service gregorovich
-         * @domain document-management
-         * @dataMethod documentsListData
-         * @discoverable true
-         * @searchTerms ["documents", "files", "knowledge", "library", "content", "resources", "papers", "manuals"]
-         * @relatedEndpoints ["api.gregorovich.chatGpt.ask", "api.joomla.content.list", "api.agrSite.content.search", "api.items.faq.list"]
-         * @commonPatterns ["List documents", "Browse knowledge base", "Find resources", "Document library", "Content discovery", "Knowledge management"]
-         * @workflow ["document-discovery", "knowledge-management", "research", "content-organization", "ai-training-data"]
-         * @prerequisites ["Public bearer token", "x-site-id header", "Document access permissions"]
-         * @nextSteps ["Select document for AI processing", "Use document content for AI questions", "Organize document library", "Analyze document metadata"]
-         * @businessRules ["Returns accessible documents only", "Supports document filtering", "Includes metadata and status", "Permissions-based access", "Searchable content"]
-         * @functionalArea "content-and-knowledge-management"
-         * @crossSite "Multi-site document library support"
-         * @caching "Cache for 15 minutes, document lists change infrequently"
-         * @performance "Optimize with pagination for large document sets, supports filtering and search"
-         *
-         * @returns Promise<DocumentsListResponse> Complete list of available documents with metadata and organization information
-         *
-         * @example
-         * ```typescript
-         * // List all available documents
-         * const docsResponse = await client.documentsList();
-         * console.log(docsResponse.data); // Array of document objects
-         * console.log(docsResponse.total); // Total document count
-         *
-         * // Get just the documents array
-         * const documents = await client.documentsListData();
-         * console.log(documents); // Direct access to document array
-         *
-         * // Process document library
-         * const docs = await client.documentsListData();
-         * const publishedDocs = docs.filter(doc => doc.status === 'published');
-         * const categories = [...new Set(docs.map(doc => doc.category))];
-         *
-         * console.log(`Found ${publishedDocs.length} published documents`);
-         * console.log(`Available categories: ${categories.join(', ')}`);
-         *
-         * // Find specific document types
-         * const manuals = docs.filter(doc =>
-         *   doc.type === 'manual' || doc.tags?.includes('manual')
-         * );
-         * const recentDocs = docs.filter(doc =>
-         *   new Date(doc.updatedAt || 0) > new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
-         * );
-         * ```
-         */
-        this.documentsList = async () => {
-            return this.executeRequest({
-                method: 'GET',
-                path: '/documents',
-                responseSchema: schemas_1.DocumentsListResponseSchema,
-            });
-        };
-        /**
-         * Generate content using local Ollama AI models
-         *
-         * @fullPath api.gregorovich.ollama.generate
-         * @service gregorovich
-         * @domain ai-generation
-         * @dataMethod ollamaGenerateData
-         * @discoverable true
-         * @searchTerms ["ollama", "generate", "ai", "local", "llm", "model", "text", "completion", "generation"]
-         * @relatedEndpoints ["api.gregorovich.chatGpt.ask", "api.p21Pim.ai.suggestions.get", "api.agrSite.ai.transcripts.create", "api.gregorovich.documents.list"]
-         * @commonPatterns ["Generate AI content", "Local AI processing", "Text completion", "AI writing assistant", "Custom model inference", "Private AI generation"]
-         * @workflow ["content-generation", "ai-assistance", "text-processing", "creative-writing", "code-generation", "document-analysis"]
-         * @prerequisites ["Public bearer token", "x-site-id header", "Model name", "Generation prompt", "Ollama service availability"]
-         * @nextSteps ["Process generated content", "Refine generation parameters", "Chain multiple generations", "Store generation results"]
-         * @businessRules ["Requires model and prompt parameters", "Supports local model execution", "Configurable generation parameters", "Token and context management", "Performance monitoring"]
-         * @functionalArea "ai-and-automation"
-         * @crossSite "Multi-site AI generation support"
-         * @caching "Cache responses for 30 minutes for identical prompts and parameters"
-         * @performance "Local processing, faster than external APIs but depends on model size and complexity"
-         *
-         * @param params Ollama generation parameters including model, prompt, and generation configuration
-         * @returns Promise<OllamaGenerateResponse> Complete AI generation result with content, metadata, and performance metrics
-         *
-         * @example
-         * ```typescript
-         * // Simple text generation
-         * const generation = await client.ollamaGenerate({
-         *   model: 'llama2',
-         *   prompt: 'Write a short story about a robot learning to paint'
-         * });
-         * console.log(generation.data.response); // Generated story
-         * console.log(generation.data.total_duration); // Generation time
-         *
-         * // Get just the generated content
-         * const story = await client.ollamaGenerateData({
-         *   model: 'codellama',
-         *   prompt: 'Create a Python function to calculate fibonacci numbers'
-         * });
-         * console.log(story.response); // Direct access to generated code
-         *
-         * // Advanced generation with parameters
-         * const technicalDoc = await client.ollamaGenerateData({
-         *   model: 'mistral',
-         *   prompt: 'Explain machine learning algorithms for beginners',
-         *   temperature: 0.3,
-         *   max_tokens: 1500,
-         *   system: 'You are a patient teacher who explains complex topics simply',
-         *   format: 'json',
-         *   top_p: 0.9,
-         *   seed: 42
-         * });
-         *
-         * // Creative writing with higher randomness
-         * const creativeContent = await client.ollamaGenerateData({
-         *   model: 'neural-chat',
-         *   prompt: 'Write a product description for a smart home device',
-         *   temperature: 0.8,
-         *   top_k: 40,
-         *   repeat_penalty: 1.1,
-         *   stop: ['\\n\\n', 'END'],
-         *   sessionId: 'creative-session-1'
-         * });
-         *
-         * // Conversation with context
-         * const conversational = await client.ollamaGenerateData({
-         *   model: 'llama2-chat',
-         *   prompt: 'What are the benefits of renewable energy?',
-         *   context: previousContext, // Array of context tokens
-         *   conversationId: 'energy-discussion',
-         *   num_predict: 200
-         * });
-         * ```
-         */
-        this.ollamaGenerate = this.createCreateMethod('/ollama/generate', schemas_1.OllamaGenerateRequestParamsSchema, schemas_1.OllamaGenerateResponseSchema);
-        // Data-only methods for direct access to response data
-        /**
-         * Get health check status data only
-         * @returns Promise<string> Health status string
-         */
-        this.healthCheckData = async () => {
-            const response = await this.healthCheck();
-            return response.data;
+        this.chatGpt = {
+            /**
+             * Ask endpoints
+             * OpenAPI Path: /chat-gpt/ask
+             */
+            ask: {
+                /**
+                 * Ask ChatGPT a question with advanced AI capabilities
+                 *
+                 * @fullPath api.gregorovich.chatGpt.ask.get
+                 * @service gregorovich
+                 * @domain ai-conversation
+                 * @dataMethod chatGptAskData
+                 * @discoverable true
+                 * @searchTerms ["chatgpt", "ai", "question", "ask", "conversation", "gpt", "openai", "assistant", "chat"]
+                 * @relatedEndpoints ["api.gregorovich.ollama.generate.create", "api.gregorovich.documents.list", "api.agrSite.ai.transcripts.create", "api.p21Pim.ai.suggestions.get"]
+                 * @commonPatterns ["Ask AI question", "Get AI assistance", "Conversational AI", "AI-powered help", "Question answering", "AI consultation"]
+                 * @workflow ["ai-conversation", "customer-support", "content-generation", "decision-support", "knowledge-retrieval"]
+                 * @prerequisites ["Valid authentication token", "x-site-id header", "Question parameter", "ChatGPT service availability"]
+                 * @nextSteps ["Process AI response", "Continue conversation", "Store conversation history", "Analyze AI recommendations"]
+                 * @businessRules ["Requires question parameter", "Supports conversation context", "Token usage tracking", "Response quality metrics", "Configurable AI parameters"]
+                 * @functionalArea "ai-and-automation"
+                 * @crossSite "Multi-site AI conversation support"
+                 * @caching "Cache responses for 1 hour for identical questions, AI responses are generally stable"
+                 * @performance "Response time varies by question complexity, use streaming for long responses"
+                 *
+                 * @param params ChatGPT question parameters including question text and AI configuration options
+                 * @returns Promise<ChatGptAskResponse> Complete AI response with answer, metadata, and usage information
+                 *
+                 * @example
+                 * ```typescript
+                 * // Ask a simple question
+                 * const aiResponse = await client.chatGpt.ask.get({ question: 'What is the weather like today?' });
+                 * console.log(aiResponse.data.answer); // AI generated answer
+                 * console.log(aiResponse.data.tokens); // Token usage information
+                 *
+                 * // Get just the AI answer
+                 * const answer = await client.chatGpt.ask.getData({ question: 'Explain quantum computing' });
+                 * console.log(answer.answer); // Direct access to AI response
+                 *
+                 * // Advanced AI configuration
+                 * const complexRequest = {
+                 *   question: 'Write a business plan for a tech startup',
+                 *   temperature: 0.7,
+                 *   maxTokens: 2000,
+                 *   format: 'markdown' as const,
+                 *   systemPrompt: 'You are a business consultant with 20 years of experience',
+                 *   conversationId: 'conv-123',
+                 *   language: 'english'
+                 * };
+                 *
+                 * const businessPlan = await client.chatGpt.ask.getData(complexRequest);
+                 * console.log(businessPlan.answer); // Detailed business plan
+                 * console.log(businessPlan.usage); // Token usage breakdown
+                 *
+                 * // Continue a conversation
+                 * const followUp = await client.chatGpt.ask.getData({
+                 *   question: 'Can you expand on the marketing strategy section?',
+                 *   conversationId: 'conv-123',
+                 *   temperature: 0.5
+                 * });
+                 * ```
+                 */
+                get: async (params) => {
+                    return this.executeRequest({
+                        method: 'GET',
+                        path: '/chat-gpt/ask',
+                        paramsSchema: chatGptAsk_1.ChatGptAskRequestParamsSchema,
+                        responseSchema: chatGptAsk_1.ChatGptAskResponseSchema,
+                    }, params);
+                },
+                /**
+                 * Ask ChatGPT a question and return AI response data only
+                 * @param params ChatGPT question parameters
+                 * @returns Promise<ChatGptAskResult> AI response with answer and metadata
+                 */
+                getData: async (params) => {
+                    const response = await this.chatGpt.ask.get(params);
+                    return response.data;
+                },
+            },
         };
         /**
-         * Ask ChatGPT a question and return AI response data only
-         * @param params ChatGPT question parameters
-         * @returns Promise<ChatGptAskResult> AI response with answer and metadata
+         * Documents endpoints
+         * OpenAPI Path: /documents
          */
-        this.chatGptAskData = async (params) => {
-            const response = await this.chatGptAsk(params);
-            return response.data;
+        this.documents = {
+            /**
+             * List available documents in the AI knowledge base
+             *
+             * @fullPath api.gregorovich.documents.list
+             * @service gregorovich
+             * @domain document-management
+             * @dataMethod documentsData
+             * @discoverable true
+             * @searchTerms ["documents", "files", "knowledge", "library", "content", "resources", "papers", "manuals"]
+             * @relatedEndpoints ["api.gregorovich.chatGpt.ask.get", "api.joomla.content.list", "api.agrSite.content.search", "api.items.faq.list"]
+             * @commonPatterns ["List documents", "Browse knowledge base", "Find resources", "Document library", "Content discovery", "Knowledge management"]
+             * @workflow ["document-discovery", "knowledge-management", "research", "content-organization", "ai-training-data"]
+             * @prerequisites ["Public bearer token", "x-site-id header", "Document access permissions"]
+             * @nextSteps ["Select document for AI processing", "Use document content for AI questions", "Organize document library", "Analyze document metadata"]
+             * @businessRules ["Returns accessible documents only", "Supports document filtering", "Includes metadata and status", "Permissions-based access", "Searchable content"]
+             * @functionalArea "content-and-knowledge-management"
+             * @crossSite "Multi-site document library support"
+             * @caching "Cache for 15 minutes, document lists change infrequently"
+             * @performance "Optimize with pagination for large document sets, supports filtering and search"
+             *
+             * @returns Promise<DocumentsResponse> Complete list of available documents with metadata and organization information
+             *
+             * @example
+             * ```typescript
+             * // List all available documents
+             * const docsResponse = await client.documents.list();
+             * console.log(docsResponse.data); // Array of document objects
+             * console.log(docsResponse.total); // Total document count
+             *
+             * // Get just the documents array
+             * const documents = await client.documents.getData();
+             * console.log(documents); // Direct access to document array
+             *
+             * // Process document library
+             * const docs = await client.documents.getData();
+             * const publishedDocs = docs.filter(doc => doc.status === 'published');
+             * const categories = [...new Set(docs.map(doc => doc.category))];
+             *
+             * console.log(`Found ${publishedDocs.length} published documents`);
+             * console.log(`Available categories: ${categories.join(', ')}`);
+             *
+             * // Find specific document types
+             * const manuals = docs.filter(doc =>
+             *   doc.type === 'manual' || doc.tags?.includes('manual')
+             * );
+             * const recentDocs = docs.filter(doc =>
+             *   new Date(doc.updatedAt || 0) > new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
+             * );
+             * ```
+             */
+            list: async () => {
+                return this.executeRequest({
+                    method: 'GET',
+                    path: '/documents',
+                    responseSchema: documents_1.DocumentsResponseSchema,
+                });
+            },
+            /**
+             * List documents and return documents array data only
+             * @returns Promise<DocumentsResult[]> Array of document objects
+             */
+            getData: async () => {
+                const response = await this.documents.list();
+                return response.data;
+            },
         };
         /**
-         * List documents and return documents array data only
-         * @returns Promise<DocumentsListResult[]> Array of document objects
+         * Health Check endpoints
+         * OpenAPI Path: /health-check
          */
-        this.documentsListData = async () => {
-            const response = await this.documentsList();
-            return response.data;
+        this.healthCheck = {
+            /**
+             * Check service health and availability
+             *
+             * @fullPath api.gregorovich.healthCheck.get
+             * @service gregorovich
+             * @domain system-health
+             * @dataMethod healthCheckData
+             * @discoverable true
+             * @searchTerms ["health", "status", "availability", "ping", "check", "ai service"]
+             * @relatedEndpoints ["api.gregorovich.chatGpt.ask.get", "api.gregorovich.documents.list", "api.gregorovich.ollama.generate.create", "api.agrWork.healthCheck.get"]
+             * @commonPatterns ["Health check", "Service status", "AI service availability", "System monitoring"]
+             * @workflow ["system-monitoring", "health-checks", "service-discovery", "ai-service-verification"]
+             * @prerequisites ["Service is running", "Valid authentication token", "x-site-id header"]
+             * @nextSteps ["Use AI endpoints if healthy", "Verify AI service connectivity", "Monitor service metrics"]
+             * @businessRules ["Returns service status and basic info", "Requires standard authentication", "Standard health check format"]
+             * @functionalArea "system-monitoring"
+             * @caching "No caching - real-time status required"
+             * @performance "Fast response, minimal processing, use for AI service monitoring"
+             *
+             * @returns Promise<HealthCheckResponse> Service health status
+             *
+             * @example
+             * ```typescript
+             * // Check if AI service is healthy
+             * const response = await client.healthCheck.get();
+             * console.log(response.data); // Health status string
+             * console.log(response.status); // HTTP status code
+             *
+             * // Get just the health status
+             * const status = await client.healthCheck.getData();
+             * console.log(status); // Direct string access
+             * ```
+             */
+            get: this.createHealthCheckMethod(healthCheck_1.HealthCheckResponseSchema),
+            /**
+             * Get health check status data only
+             * @returns Promise<string> Health status string
+             */
+            getData: async () => {
+                const response = await this.healthCheck.get();
+                return response.data;
+            },
         };
         /**
-         * Generate content with Ollama and return generation result data only
-         * @param params Ollama generation parameters
-         * @returns Promise<OllamaGenerateResult> Generated content with metadata and performance metrics
+         * Ollama endpoints
+         * OpenAPI Path: /ollama/*
          */
-        this.ollamaGenerateData = async (params) => {
-            const response = await this.ollamaGenerate(params);
-            return response.data;
+        this.ollama = {
+            /**
+             * Generate endpoints
+             * OpenAPI Path: /ollama/generate
+             */
+            generate: {
+                /**
+                 * Generate content using local Ollama AI models
+                 *
+                 * @fullPath api.gregorovich.ollama.generate.create
+                 * @service gregorovich
+                 * @domain ai-generation
+                 * @dataMethod ollamaGenerateData
+                 * @discoverable true
+                 * @searchTerms ["ollama", "generate", "ai", "local", "llm", "model", "text", "completion", "generation"]
+                 * @relatedEndpoints ["api.gregorovich.chatGpt.ask.get", "api.p21Pim.ai.suggestions.get", "api.agrSite.ai.transcripts.create", "api.gregorovich.documents.list"]
+                 * @commonPatterns ["Generate AI content", "Local AI processing", "Text completion", "AI writing assistant", "Custom model inference", "Private AI generation"]
+                 * @workflow ["content-generation", "ai-assistance", "text-processing", "creative-writing", "code-generation", "document-analysis"]
+                 * @prerequisites ["Public bearer token", "x-site-id header", "Model name", "Generation prompt", "Ollama service availability"]
+                 * @nextSteps ["Process generated content", "Refine generation parameters", "Chain multiple generations", "Store generation results"]
+                 * @businessRules ["Requires model and prompt parameters", "Supports local model execution", "Configurable generation parameters", "Token and context management", "Performance monitoring"]
+                 * @functionalArea "ai-and-automation"
+                 * @crossSite "Multi-site AI generation support"
+                 * @caching "Cache responses for 30 minutes for identical prompts and parameters"
+                 * @performance "Local processing, faster than external APIs but depends on model size and complexity"
+                 *
+                 * @param params Ollama generation parameters including model, prompt, and generation configuration
+                 * @returns Promise<OllamaGenerateResponse> Complete AI generation result with content, metadata, and performance metrics
+                 *
+                 * @example
+                 * ```typescript
+                 * // Simple text generation
+                 * const generation = await client.ollama.generate.create({
+                 *   model: 'llama2',
+                 *   prompt: 'Write a short story about a robot learning to paint'
+                 * });
+                 * console.log(generation.data.response); // Generated story
+                 * console.log(generation.data.total_duration); // Generation time
+                 *
+                 * // Get just the generated content
+                 * const story = await client.ollama.generate.getData({
+                 *   model: 'codellama',
+                 *   prompt: 'Create a Python function to calculate fibonacci numbers'
+                 * });
+                 * console.log(story.response); // Direct access to generated code
+                 *
+                 * // Advanced generation with parameters
+                 * const technicalDoc = await client.ollama.generate.getData({
+                 *   model: 'mistral',
+                 *   prompt: 'Explain machine learning algorithms for beginners',
+                 *   temperature: 0.3,
+                 *   max_tokens: 1500,
+                 *   system: 'You are a patient teacher who explains complex topics simply',
+                 *   format: 'json',
+                 *   top_p: 0.9,
+                 *   seed: 42
+                 * });
+                 *
+                 * // Creative writing with higher randomness
+                 * const creativeContent = await client.ollama.generate.getData({
+                 *   model: 'neural-chat',
+                 *   prompt: 'Write a product description for a smart home device',
+                 *   temperature: 0.8,
+                 *   top_k: 40,
+                 *   repeat_penalty: 1.1,
+                 *   stop: ['\\n\\n', 'END'],
+                 *   sessionId: 'creative-session-1'
+                 * });
+                 *
+                 * // Conversation with context
+                 * const conversational = await client.ollama.generate.getData({
+                 *   model: 'llama2-chat',
+                 *   prompt: 'What are the benefits of renewable energy?',
+                 *   context: previousContext, // Array of context tokens
+                 *   conversationId: 'energy-discussion',
+                 *   num_predict: 200
+                 * });
+                 * ```
+                 */
+                create: this.createCreateMethod('/ollama/generate', ollamaGenerate_1.OllamaGenerateRequestParamsSchema, ollamaGenerate_1.OllamaGenerateResponseSchema),
+                /**
+                 * Generate content with Ollama and return generation result data only
+                 * @param params Ollama generation parameters
+                 * @returns Promise<OllamaGenerateResult> Generated content with metadata and performance metrics
+                 */
+                getData: async (params) => {
+                    const response = await this.ollama.generate.create(params);
+                    return response.data;
+                },
+            },
         };
     }
     getServiceDescription() {

package/dist/cjs/services/gregorovich/client.js.map

@@ -1 +1 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../src/services/gregorovich/client.ts"],"names":[],"mappings":";;;AAAA,wDAA2D;AAE3D,uCAcmB;AAEnB;;;;;;;;GAQG;AACH,MAAa,iBAAkB,SAAQ,+BAAiB;IACtD,YAAY,IAAgB,EAAE,OAAgB;QAC5C,KAAK,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,IAAI,mCAAmC,CAAC,CAAC;QAO7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgCG;QACM,gBAAW,GAAG,IAAI,CAAC,uBAAuB,CAAC,mCAAyB,CAAC,CAAC;QAE/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAwDG;QACM,eAAU,GAAG,KAAK,EAAE,MAA+B,EAA+B,EAAE;YAC3F,OAAO,IAAI,CAAC,cAAc,CACxB;gBACE,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,eAAe;gBACrB,YAAY,EAAE,uCAA6B;gBAC3C,cAAc,EAAE,kCAAwB;aACzC,EACD,MAAM,CACP,CAAC;QACJ,CAAC,CAAC;QAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDG;QACM,kBAAa,GAAG,KAAK,IAAoC,EAAE;YAClE,OAAO,IAAI,CAAC,cAAc,CAAC;gBACzB,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,YAAY;gBAClB,cAAc,EAAE,qCAA2B;aAC5C,CAAC,CAAC;QACL,CAAC,CAAC;QAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAwEG;QACM,mBAAc,GAAG,IAAI,CAAC,kBAAkB,CAC/C,kBAAkB,EAClB,2CAAiC,EACjC,sCAA4B,CAC7B,CAAC;QAEF,uDAAuD;QAEvD;;;WAGG;QACM,oBAAe,GAAG,KAAK,IAAqB,EAAE;YACrD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;YAC1C,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC,CAAC;QAEF;;;;WAIG;QACM,mBAAc,GAAG,KAAK,EAAE,MAA+B,EAA6B,EAAE;YAC7F,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAC/C,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC,CAAC;QAEF;;;WAGG;QACM,sBAAiB,GAAG,KAAK,IAAoC,EAAE;YACtE,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;YAC5C,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC,CAAC;QAEF;;;;WAIG;QACM,uBAAkB,GAAG,KAAK,EACjC,MAAmC,EACJ,EAAE;YACjC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;YACnD,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC,CAAC;IA/RF,CAAC;IAES,qBAAqB;QAC7B,OAAO,kGAAkG,CAAC;IAC5G,CAAC;CA4RF;AAnSD,8CAmSC"}
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../src/services/gregorovich/client.ts"],"names":[],"mappings":";;;AAAA,wDAA2D;AAc3D,uDAAkE;AAClE,qDAA+F;AAC/F,mDAA8D;AAC9D,6DAGkC;AAElC;;;;;;;;GAQG;AACH,MAAa,iBAAkB,SAAQ,+BAAiB;IACtD,YAAY,IAAgB,EAAE,OAAgB;QAC5C,KAAK,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,IAAI,mCAAmC,CAAC,CAAC;QAO7E;;;WAGG;QACM,YAAO,GAAG;YACjB;;;eAGG;YACH,GAAG,EAAE;gBACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAwDG;gBACH,GAAG,EAAE,KAAK,EAAE,MAA+B,EAA+B,EAAE;oBAC1E,OAAO,IAAI,CAAC,cAAc,CACxB;wBACE,MAAM,EAAE,KAAK;wBACb,IAAI,EAAE,eAAe;wBACrB,YAAY,EAAE,0CAA6B;wBAC3C,cAAc,EAAE,qCAAwB;qBACzC,EACD,MAAM,CACP,CAAC;gBACJ,CAAC;gBAED;;;;mBAIG;gBACH,OAAO,EAAE,KAAK,EAAE,MAA+B,EAA6B,EAAE;oBAC5E,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;oBACpD,OAAO,QAAQ,CAAC,IAAI,CAAC;gBACvB,CAAC;aACF;SACF,CAAC;QAEF;;;WAGG;QACM,cAAS,GAAG;YACnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAiDG;YACH,IAAI,EAAE,KAAK,IAAgC,EAAE;gBAC3C,OAAO,IAAI,CAAC,cAAc,CAAC;oBACzB,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,YAAY;oBAClB,cAAc,EAAE,mCAAuB;iBACxC,CAAC,CAAC;YACL,CAAC;YAED;;;eAGG;YACH,OAAO,EAAE,KAAK,IAAgC,EAAE;gBAC9C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;gBAC7C,OAAO,QAAQ,CAAC,IAAI,CAAC;YACvB,CAAC;SACF,CAAC;QAEF;;;WAGG;QACM,gBAAW,GAAG;YACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAgCG;YACH,GAAG,EAAE,IAAI,CAAC,uBAAuB,CAAC,uCAAyB,CAAC;YAE5D;;;eAGG;YACH,OAAO,EAAE,KAAK,IAAqB,EAAE;gBACnC,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC;gBAC9C,OAAO,QAAQ,CAAC,IAAI,CAAC;YACvB,CAAC;SACF,CAAC;QAEF;;;WAGG;QACM,WAAM,GAAG;YAChB;;;eAGG;YACH,QAAQ,EAAE;gBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAwEG;gBACH,MAAM,EAAE,IAAI,CAAC,kBAAkB,CAC7B,kBAAkB,EAClB,kDAAiC,EACjC,6CAA4B,CAC7B;gBAED;;;;mBAIG;gBACH,OAAO,EAAE,KAAK,EAAE,MAAmC,EAAiC,EAAE;oBACpF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;oBAC3D,OAAO,QAAQ,CAAC,IAAI,CAAC;gBACvB,CAAC;aACF;SACF,CAAC;IA/TF,CAAC;IAES,qBAAqB;QAC7B,OAAO,kGAAkG,CAAC;IAC5G,CAAC;CA4TF;AAnUD,8CAmUC"}

package/dist/cjs/services/gregorovich/index.d.ts

@@ -1,3 +1,3 @@
 export { GregorovichClient } from './client';
-export type { HealthCheckResponse, ChatGptAskRequestParams, ChatGptAskResponse, ChatGptAskResult, DocumentsListResponse, DocumentsListResult, OllamaGenerateRequestParams, OllamaGenerateResponse, OllamaGenerateResult, } from './schemas';
+export type { HealthCheckResponse, ChatGptAskRequestParams, ChatGptAskResponse, ChatGptAskResult, DocumentsResponse, DocumentsResult, OllamaGenerateRequestParams, OllamaGenerateResponse, OllamaGenerateResult, } from './schemas';
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/services/gregorovich/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/gregorovich/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,YAAY,EAEV,mBAAmB,EAEnB,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAEhB,qBAAqB,EACrB,mBAAmB,EAEnB,2BAA2B,EAC3B,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/gregorovich/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,YAAY,EAEV,mBAAmB,EAEnB,uBAAuB,EACvB,kBAAkB,EAClB,gBAAgB,EAEhB,iBAAiB,EACjB,eAAe,EAEf,2BAA2B,EAC3B,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,WAAW,CAAC"}