@simpleapps-com/augur-api 0.3.0 → 0.3.1

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

@@ -0,0 +1,336 @@
+import { BaseServiceClient } from '../../core/base-client';
+import type { HTTPClient } from '../../core/client';
+import { ChatGptAskRequestParams, ChatGptAskResponse, ChatGptAskResult, DocumentsListResponse, DocumentsListResult, OllamaGenerateRequestParams, OllamaGenerateResult } from './schemas';
+/**
+ * Gregorovich AI Service Client
+ *
+ * Provides access to AI-powered document management and conversational AI endpoints
+ * including ChatGPT integration, Ollama local models, and document processing capabilities.
+ *
+ * @service gregorovich
+ * @domain ai-and-document-management
+ */
+export declare class GregorovichClient extends BaseServiceClient {
+    constructor(http: HTTPClient, baseUrl?: string);
+    protected getServiceDescription(): string;
+    /**
+     * 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
+     * ```
+     */
+    readonly healthCheck: () => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: string;
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    readonly chatGptAsk: (params: ChatGptAskRequestParams) => Promise<ChatGptAskResponse>;
+    /**
+     * 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)
+     * );
+     * ```
+     */
+    readonly documentsList: () => Promise<DocumentsListResponse>;
+    /**
+     * 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
+     * });
+     * ```
+     */
+    readonly ollamaGenerate: (data: import("zod").objectInputType<{
+        model: import("zod").ZodString;
+        prompt: import("zod").ZodString;
+        temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
+        top_p: import("zod").ZodOptional<import("zod").ZodNumber>;
+        top_k: import("zod").ZodOptional<import("zod").ZodNumber>;
+        repeat_penalty: import("zod").ZodOptional<import("zod").ZodNumber>;
+        seed: import("zod").ZodOptional<import("zod").ZodNumber>;
+        max_tokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+        stop: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        stream: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        context: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+        system: import("zod").ZodOptional<import("zod").ZodString>;
+        template: import("zod").ZodOptional<import("zod").ZodString>;
+        format: import("zod").ZodOptional<import("zod").ZodEnum<["json", "text"]>>;
+        raw: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        keep_alive: import("zod").ZodOptional<import("zod").ZodString>;
+        num_predict: import("zod").ZodOptional<import("zod").ZodNumber>;
+        num_ctx: import("zod").ZodOptional<import("zod").ZodNumber>;
+        num_batch: import("zod").ZodOptional<import("zod").ZodNumber>;
+        num_gpu: import("zod").ZodOptional<import("zod").ZodNumber>;
+        main_gpu: import("zod").ZodOptional<import("zod").ZodNumber>;
+        low_vram: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        f16_kv: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        vocab_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        use_mmap: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        use_mlock: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        embedding_only: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        numa: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        sessionId: import("zod").ZodOptional<import("zod").ZodString>;
+        conversationId: import("zod").ZodOptional<import("zod").ZodString>;
+        userId: import("zod").ZodOptional<import("zod").ZodString>;
+        tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        priority: import("zod").ZodOptional<import("zod").ZodEnum<["low", "normal", "high"]>>;
+    }, import("zod").ZodTypeAny, "passthrough">) => Promise<{
+        params: Record<string, unknown> | unknown[];
+        data: {
+            status?: "timeout" | "success" | "error" | "partial" | undefined;
+            response?: string | undefined;
+            timestamp?: string | undefined;
+            requestId?: string | undefined;
+            sessionId?: string | undefined;
+            version?: string | undefined;
+            warnings?: string[] | undefined;
+            model?: string | undefined;
+            context?: number[] | undefined;
+            error?: string | undefined;
+            created_at?: string | undefined;
+            conversationId?: string | undefined;
+            messageId?: string | undefined;
+            done?: boolean | undefined;
+            total_duration?: number | undefined;
+            load_duration?: number | undefined;
+            prompt_eval_count?: number | undefined;
+            prompt_eval_duration?: number | undefined;
+            eval_count?: number | undefined;
+            eval_duration?: number | undefined;
+            finish_reason?: string | undefined;
+            prompt_tokens?: number | undefined;
+            completion_tokens?: number | undefined;
+            total_tokens?: number | undefined;
+            capabilities?: string[] | undefined;
+        } & {
+            [k: string]: unknown;
+        };
+        options: Record<string, unknown> | unknown[];
+        status: number;
+        message: string;
+        count: number;
+        total: number;
+        totalResults: number;
+    }>;
+    /**
+     * Get health check status data only
+     * @returns Promise<string> Health status string
+     */
+    readonly healthCheckData: () => Promise<string>;
+    /**
+     * Ask ChatGPT a question and return AI response data only
+     * @param params ChatGPT question parameters
+     * @returns Promise<ChatGptAskResult> AI response with answer and metadata
+     */
+    readonly chatGptAskData: (params: ChatGptAskRequestParams) => Promise<ChatGptAskResult>;
+    /**
+     * List documents and return documents array data only
+     * @returns Promise<DocumentsListResult[]> Array of document objects
+     */
+    readonly documentsListData: () => Promise<DocumentsListResult[]>;
+    /**
+     * 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
+     */
+    readonly ollamaGenerateData: (params: OllamaGenerateRequestParams) => Promise<OllamaGenerateResult>;
+}
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GregorovichClient = void 0;
+const base_client_1 = require("../../core/base-client");
+const schemas_1 = require("./schemas");
+/**
+ * Gregorovich AI Service Client
+ *
+ * Provides access to AI-powered document management and conversational AI endpoints
+ * including ChatGPT integration, Ollama local models, and document processing capabilities.
+ *
+ * @service gregorovich
+ * @domain ai-and-document-management
+ */
+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
+         * ```
+         */
+        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;
+        };
+        /**
+         * Ask ChatGPT a question and return AI response data only
+         * @param params ChatGPT question parameters
+         * @returns Promise<ChatGptAskResult> AI response with answer and metadata
+         */
+        this.chatGptAskData = async (params) => {
+            const response = await this.chatGptAsk(params);
+            return response.data;
+        };
+        /**
+         * List documents and return documents array data only
+         * @returns Promise<DocumentsListResult[]> Array of document objects
+         */
+        this.documentsListData = async () => {
+            const response = await this.documentsList();
+            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
+         */
+        this.ollamaGenerateData = async (params) => {
+            const response = await this.ollamaGenerate(params);
+            return response.data;
+        };
+    }
+    getServiceDescription() {
+        return 'AI-powered document management and conversational AI service with ChatGPT and Ollama integration';
+    }
+}
+exports.GregorovichClient = GregorovichClient;
+//# sourceMappingURL=client.js.map

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

@@ -0,0 +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"}

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

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

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

@@ -0,0 +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"}

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GregorovichClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "GregorovichClient", { enumerable: true, get: function () { return client_1.GregorovichClient; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/services/gregorovich/index.ts"],"names":[],"mappings":";;;AAAA,mCAA6C;AAApC,2GAAA,iBAAiB,OAAA"}