@simpleapps-com/augur-api 0.5.1 → 0.6.0

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

@@ -2,10 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GregorovichClient = void 0;
 const base_client_1 = require("../../core/base-client");
-const healthCheck_1 = require("./schemas/healthCheck");
-const chatGptAsk_1 = require("./schemas/chatGptAsk");
-const documents_1 = require("./schemas/documents");
-const ollamaGenerate_1 = require("./schemas/ollamaGenerate");
+const resources_1 = require("./resources");
 /**
  * Gregorovich AI Service Client
  *
@@ -14,310 +11,60 @@ const ollamaGenerate_1 = require("./schemas/ollamaGenerate");
  *
  * @service gregorovich
  * @domain ai-and-document-management
+ * @discoverable true
+ * @searchTerms ["ai", "chatgpt", "ollama", "documents", "gregorovich", "artificial intelligence"]
+ * @relatedEndpoints ["api.gregorovich.chatGpt.ask.get", "api.gregorovich.ollama.generate.create", "api.gregorovich.documents.list"]
+ * @commonPatterns ["AI conversation", "Document management", "Local AI generation", "AI-powered assistance"]
+ * @workflow ["ai-operations", "document-processing", "conversational-ai"]
+ * @functionalArea "ai-and-document-management"
+ * @example
+ * ```typescript
+ * import { HTTPClient } from '@augur/api-client/core';
+ * import { GregorovichClient } from '@augur/api-client/services/gregorovich';
+ *
+ * const http = new HTTPClient('gregorovich', { siteId: 'your-site-id', bearerToken: 'your-token' });
+ * const gregorovich = new GregorovichClient(http);
+ *
+ * // Check service health
+ * const health = await gregorovich.healthCheck.get();
+ * const healthData = await gregorovich.healthCheckData.get();
+ *
+ * // Ask ChatGPT
+ * const response = await gregorovich.chatGpt.ask.get({ question: 'What is AI?' });
+ * const answer = await gregorovich.chatGptData.ask.get({ question: 'Explain ML' });
+ *
+ * // List documents
+ * const docs = await gregorovich.documents.list();
+ * const docsList = await gregorovich.documentsData.list();
+ *
+ * // Generate with Ollama
+ * const generation = await gregorovich.ollama.generate.create({ model: 'llama2', prompt: 'Write a story' });
+ * const story = await gregorovich.ollamaData.generate.create({ model: 'llama2', prompt: 'Write a poem' });
+ * ```
  */
 class GregorovichClient extends base_client_1.BaseServiceClient {
     constructor(http, baseUrl) {
         super('gregorovich', http, baseUrl || 'https://gregorovich.augur-api.com');
-        /**
-         * Chat GPT endpoints
-         * OpenAPI Path: /chat-gpt/*
-         */
-        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;
-                },
-            },
-        };
-        /**
-         * Documents endpoints
-         * OpenAPI Path: /documents
-         */
-        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;
-            },
-        };
-        /**
-         * Health Check endpoints
-         * OpenAPI Path: /health-check
-         */
-        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;
-            },
-        };
-        /**
-         * Ollama endpoints
-         * OpenAPI Path: /ollama/*
-         */
-        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;
-                },
-            },
+        // Bind executeRequest for resource factories
+        const boundExecuteRequest = (config, params, pathParams) => {
+            if (params !== undefined || config.paramsSchema !== undefined) {
+                return this.executeRequest(config, params, pathParams);
+            }
+            return this.executeRequest(config, undefined, pathParams);
         };
+        // Initialize resources
+        this.healthCheck = (0, resources_1.createHealthCheckResource)(boundExecuteRequest);
+        this.healthCheckData = (0, resources_1.createHealthCheckDataResource)(this.healthCheck);
+        const chatGptAsk = (0, resources_1.createChatGptAskResource)(boundExecuteRequest);
+        const chatGptAskData = (0, resources_1.createChatGptAskDataResource)(chatGptAsk);
+        this.chatGpt = { ask: chatGptAsk };
+        this.chatGptData = { ask: chatGptAskData };
+        this.documents = (0, resources_1.createDocumentsResource)(boundExecuteRequest);
+        this.documentsData = (0, resources_1.createDocumentsDataResource)(this.documents);
+        const ollamaGenerate = (0, resources_1.createOllamaGenerateResource)(boundExecuteRequest);
+        const ollamaGenerateData = (0, resources_1.createOllamaGenerateDataResource)(ollamaGenerate);
+        this.ollama = { generate: ollamaGenerate };
+        this.ollamaData = { generate: ollamaGenerateData };
     }
     getServiceDescription() {
         return 'AI-powered document management and conversational AI service with ChatGPT and Ollama integration';

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;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"}
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../../src/services/gregorovich/client.ts"],"names":[],"mappings":";;;AAAA,wDAA2E;AAE3E,2CAiBqB;AAErB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAa,iBAAkB,SAAQ,+BAAiB;IA0BtD,YAAY,IAAgB,EAAE,OAAgB;QAC5C,KAAK,CAAC,aAAa,EAAE,IAAI,EAAE,OAAO,IAAI,mCAAmC,CAAC,CAAC;QAE3E,6CAA6C;QAC7C,MAAM,mBAAmB,GAAG,CAC1B,MAA0C,EAC1C,MAAgB,EAChB,UAAmC,EACf,EAAE;YACtB,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,CAAC,YAAY,KAAK,SAAS,EAAE,CAAC;gBAC9D,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC;YACzD,CAAC;YACD,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;QAC5D,CAAC,CAAC;QAEF,uBAAuB;QACvB,IAAI,CAAC,WAAW,GAAG,IAAA,qCAAyB,EAAC,mBAAmB,CAAC,CAAC;QAClE,IAAI,CAAC,eAAe,GAAG,IAAA,yCAA6B,EAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAEvE,MAAM,UAAU,GAAG,IAAA,oCAAwB,EAAC,mBAAmB,CAAC,CAAC;QACjE,MAAM,cAAc,GAAG,IAAA,wCAA4B,EAAC,UAAU,CAAC,CAAC;QAChE,IAAI,CAAC,OAAO,GAAG,EAAE,GAAG,EAAE,UAAU,EAAE,CAAC;QACnC,IAAI,CAAC,WAAW,GAAG,EAAE,GAAG,EAAE,cAAc,EAAE,CAAC;QAE3C,IAAI,CAAC,SAAS,GAAG,IAAA,mCAAuB,EAAC,mBAAmB,CAAC,CAAC;QAC9D,IAAI,CAAC,aAAa,GAAG,IAAA,uCAA2B,EAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAEjE,MAAM,cAAc,GAAG,IAAA,wCAA4B,EAAC,mBAAmB,CAAC,CAAC;QACzE,MAAM,kBAAkB,GAAG,IAAA,4CAAgC,EAAC,cAAc,CAAC,CAAC;QAC5E,IAAI,CAAC,MAAM,GAAG,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC;QAC3C,IAAI,CAAC,UAAU,GAAG,EAAE,QAAQ,EAAE,kBAAkB,EAAE,CAAC;IACrD,CAAC;IAES,qBAAqB;QAC7B,OAAO,kGAAkG,CAAC;IAC5G,CAAC;CACF;AA9DD,8CA8DC"}

package/dist/cjs/services/gregorovich/resources/chat-gpt-ask.d.ts

@@ -0,0 +1,83 @@
+import type { ChatGptAskRequestParams, ChatGptAskResponse, ChatGptAskResult } from '../schemas';
+import type { EndpointConfig } from '../../../core/base-client';
+type BoundExecuteRequest = <TParams, TResponse>(config: EndpointConfig<TParams, TResponse>, params?: TParams, pathParams?: Record<string, string>) => Promise<TResponse>;
+/**
+ * Creates the chatGpt.ask resource methods
+ * OpenAPI Path: /chat-gpt/ask → chatGpt.ask.*
+ * @description ChatGPT question and answer functionality
+ */
+export declare function createChatGptAskResource(executeRequest: BoundExecuteRequest): {
+    /**
+     * Ask ChatGPT a question with advanced AI capabilities
+     *
+     * @fullPath api.gregorovich.chatGpt.ask.get
+     * @service gregorovich
+     * @domain ai-conversation
+     * @dataMethod chatGptData.ask.get
+     * @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.chatGptData.ask.get({ 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.chatGptData.ask.get(complexRequest);
+     * console.log(businessPlan.answer); // Detailed business plan
+     * console.log(businessPlan.usage); // Token usage breakdown
+     *
+     * // Continue a conversation
+     * const followUp = await client.chatGptData.ask.get({
+     *   question: 'Can you expand on the marketing strategy section?',
+     *   conversationId: 'conv-123',
+     *   temperature: 0.5
+     * });
+     * ```
+     */
+    get: (params: ChatGptAskRequestParams) => Promise<ChatGptAskResponse>;
+};
+/**
+ * Creates the chatGptData.ask resource methods (data-only versions)
+ */
+export declare function createChatGptAskDataResource(chatGptAsk: ReturnType<typeof createChatGptAskResource>): {
+    /**
+     * Ask ChatGPT a question and return AI response data only
+     * @param params ChatGPT question parameters
+     * @returns Promise<ChatGptAskResult> AI response with answer and metadata
+     */
+    get: (params: ChatGptAskRequestParams) => Promise<ChatGptAskResult>;
+};
+export type ChatGptAskResource = ReturnType<typeof createChatGptAskResource>;
+export type ChatGptAskDataResource = ReturnType<typeof createChatGptAskDataResource>;
+export {};
+//# sourceMappingURL=chat-gpt-ask.d.ts.map

package/dist/cjs/services/gregorovich/resources/chat-gpt-ask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-gpt-ask.d.ts","sourceRoot":"","sources":["../../../../../src/services/gregorovich/resources/chat-gpt-ask.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAChG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEhE,KAAK,mBAAmB,GAAG,CAAC,OAAO,EAAE,SAAS,EAC5C,MAAM,EAAE,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,EAC1C,MAAM,CAAC,EAAE,OAAO,EAChB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAChC,OAAO,CAAC,SAAS,CAAC,CAAC;AAExB;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,cAAc,EAAE,mBAAmB;IAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwDG;kBACiB,uBAAuB,KAAG,OAAO,CAAC,kBAAkB,CAAC;EAY5E;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC;IAGrD;;;;OAIG;kBACiB,uBAAuB,KAAG,OAAO,CAAC,gBAAgB,CAAC;EAK1E;AAED,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC7E,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,OAAO,4BAA4B,CAAC,CAAC"}

package/dist/cjs/services/gregorovich/resources/chat-gpt-ask.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChatGptAskResource = createChatGptAskResource;
+exports.createChatGptAskDataResource = createChatGptAskDataResource;
+const chatGptAsk_1 = require("../schemas/chatGptAsk");
+/**
+ * Creates the chatGpt.ask resource methods
+ * OpenAPI Path: /chat-gpt/ask → chatGpt.ask.*
+ * @description ChatGPT question and answer functionality
+ */
+function createChatGptAskResource(executeRequest) {
+    return {
+        /**
+         * Ask ChatGPT a question with advanced AI capabilities
+         *
+         * @fullPath api.gregorovich.chatGpt.ask.get
+         * @service gregorovich
+         * @domain ai-conversation
+         * @dataMethod chatGptData.ask.get
+         * @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.chatGptData.ask.get({ 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.chatGptData.ask.get(complexRequest);
+         * console.log(businessPlan.answer); // Detailed business plan
+         * console.log(businessPlan.usage); // Token usage breakdown
+         *
+         * // Continue a conversation
+         * const followUp = await client.chatGptData.ask.get({
+         *   question: 'Can you expand on the marketing strategy section?',
+         *   conversationId: 'conv-123',
+         *   temperature: 0.5
+         * });
+         * ```
+         */
+        get: async (params) => {
+            return executeRequest({
+                method: 'GET',
+                path: '/chat-gpt/ask',
+                paramsSchema: chatGptAsk_1.ChatGptAskRequestParamsSchema,
+                responseSchema: chatGptAsk_1.ChatGptAskResponseSchema,
+            }, params);
+        },
+    };
+}
+/**
+ * Creates the chatGptData.ask resource methods (data-only versions)
+ */
+function createChatGptAskDataResource(chatGptAsk) {
+    return {
+        /**
+         * Ask ChatGPT a question and return AI response data only
+         * @param params ChatGPT question parameters
+         * @returns Promise<ChatGptAskResult> AI response with answer and metadata
+         */
+        get: async (params) => {
+            const response = await chatGptAsk.get(params);
+            return response.data;
+        },
+    };
+}
+//# sourceMappingURL=chat-gpt-ask.js.map

package/dist/cjs/services/gregorovich/resources/chat-gpt-ask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-gpt-ask.js","sourceRoot":"","sources":["../../../../../src/services/gregorovich/resources/chat-gpt-ask.ts"],"names":[],"mappings":";;AAeA,4DAuEC;AAKD,oEAcC;AAzGD,sDAAgG;AAUhG;;;;GAIG;AACH,SAAgB,wBAAwB,CAAC,cAAmC;IAC1E,OAAO;QACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAwDG;QACH,GAAG,EAAE,KAAK,EAAE,MAA+B,EAA+B,EAAE;YAC1E,OAAO,cAAc,CACnB;gBACE,MAAM,EAAE,KAAK;gBACb,IAAI,EAAE,eAAe;gBACrB,YAAY,EAAE,0CAA6B;gBAC3C,cAAc,EAAE,qCAAwB;aACzC,EACD,MAAM,CACP,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,4BAA4B,CAC1C,UAAuD;IAEvD,OAAO;QACL;;;;WAIG;QACH,GAAG,EAAE,KAAK,EAAE,MAA+B,EAA6B,EAAE;YACxE,MAAM,QAAQ,GAAG,MAAM,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAC9C,OAAO,QAAQ,CAAC,IAAI,CAAC;QACvB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/cjs/services/gregorovich/resources/documents.d.ts

@@ -0,0 +1,75 @@
+import type { DocumentsResponse, DocumentsResult } from '../schemas';
+import type { EndpointConfig } from '../../../core/base-client';
+type BoundExecuteRequest = <TParams, TResponse>(config: EndpointConfig<TParams, TResponse>, params?: TParams, pathParams?: Record<string, string>) => Promise<TResponse>;
+/**
+ * Creates the documents resource methods
+ * OpenAPI Path: /documents → documents.*
+ * @description Document management and knowledge base access functionality
+ */
+export declare function createDocumentsResource(executeRequest: BoundExecuteRequest): {
+    /**
+     * List available documents in the AI knowledge base
+     *
+     * @fullPath api.gregorovich.documents.list
+     * @service gregorovich
+     * @domain document-management
+     * @dataMethod documentsData.list
+     * @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.documentsData.list();
+     * console.log(documents); // Direct access to document array
+     *
+     * // Process document library
+     * const docs = await client.documentsData.list();
+     * 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: () => Promise<DocumentsResponse>;
+};
+/**
+ * Creates the documentsData resource methods (data-only versions)
+ */
+export declare function createDocumentsDataResource(documents: ReturnType<typeof createDocumentsResource>): {
+    /**
+     * List documents and return documents array data only
+     * @returns Promise<DocumentsResult[]> Array of document objects
+     */
+    list: () => Promise<DocumentsResult[]>;
+};
+export type DocumentsResource = ReturnType<typeof createDocumentsResource>;
+export type DocumentsDataResource = ReturnType<typeof createDocumentsDataResource>;
+export {};
+//# sourceMappingURL=documents.d.ts.map