Download scholasticGenkitService.ts from VoidBreach/Chancellor: direct link, hf CLI and curl.
- Browser
- Download file 19 kB
-
https://huggingface.co/VoidBreach/Chancellor/resolve/main/scholasticGenkitService.ts
- Command line
-
hf download hf://VoidBreach/Chancellor/scholasticGenkitService.ts
-
curl -L -o scholasticGenkitService.ts https://huggingface.co/VoidBreach/Chancellor/resolve/main/scholasticGenkitService.ts
19 kB
| import { GoogleGenAI, Type } from '@google/genai'; | |
| import { ScholasticSanitizer } from '../lib/scholasticSanitizer'; | |
| import fs from 'fs'; | |
| import path from 'path'; | |
| import { EthicsBaseline, CloudTaxonomy } from '../types'; | |
| let aiClient: GoogleGenAI | null = null; | |
| let ethicsBaseline: EthicsBaseline | null = null; | |
| let cloudTaxonomy: CloudTaxonomy | null = null; | |
| function loadConfigurations() { | |
| try { | |
| const ethicsPath = path.join(process.cwd(), 'src', 'lib', 'ethicsBaseline.json'); | |
| const taxonomyPath = path.join(process.cwd(), 'src', 'lib', 'cloudInfrastructureTaxonomy.json'); | |
| if (fs.existsSync(ethicsPath)) { | |
| ethicsBaseline = JSON.parse(fs.readFileSync(ethicsPath, 'utf-8')); | |
| console.info('[CHANCELLOR_DEBUG] Ethics baseline successfully loaded server-side.'); | |
| } | |
| if (fs.existsSync(taxonomyPath)) { | |
| cloudTaxonomy = JSON.parse(fs.readFileSync(taxonomyPath, 'utf-8')); | |
| console.info('[CHANCELLOR_DEBUG] Cloud taxonomy successfully loaded server-side.'); | |
| } | |
| } catch (err) { | |
| console.error('[CHANCELLOR_ERROR] Failed to load server-side configurations.', err); | |
| } | |
| } | |
| function getAI(): GoogleGenAI { | |
| if (!aiClient) { | |
| const rawKey = process.env.GEMINI_API_KEY; | |
| // Robust sanitization: remove quotes, whitespace, and handle potential prefixing | |
| const key = rawKey ? rawKey.replace(/['"]/g, '').trim() : ''; | |
| if (key) { | |
| console.info(`[ACADEMY_DEBUG] Key initialized. Length: ${key.length}`); | |
| } | |
| if (!key || key === 'MY_GEMINI_API_KEY' || key.length < 10) { | |
| throw new Error('GEMINI_API_KEY is not configured or invalid.'); | |
| } | |
| aiClient = new GoogleGenAI({ | |
| apiKey: key, | |
| httpOptions: { | |
| headers: { | |
| 'User-Agent': 'aistudio-build', | |
| }, | |
| }, | |
| }); | |
| } | |
| return aiClient; | |
| } | |
| interface GenerateResponse { | |
| text?: string; | |
| functionCalls?: Array<{ | |
| name: string; | |
| args: Record<string, unknown>; | |
| }>; | |
| } | |
| async function generateWithFallback( | |
| options: { | |
| contents: unknown; | |
| config?: Record<string, unknown>; | |
| tools?: Array<unknown>; | |
| toolConfig?: Record<string, unknown>; | |
| }, | |
| retries = 3, | |
| delay = 1000, | |
| ): Promise<GenerateResponse> { | |
| const modelsToTry = ['gemini-3.5-flash', 'gemini-2.5-flash']; | |
| if (!ethicsBaseline || !cloudTaxonomy) { | |
| loadConfigurations(); | |
| } | |
| // Create system instructions based on loaded configs | |
| let dynamicInstruction = ''; | |
| if (ethicsBaseline) { | |
| const forbidden = ethicsBaseline.principles?.safety?.forbidden_actions || []; | |
| const regions = ethicsBaseline.principles?.privacy?.allowed_regions || []; | |
| const anonymize = ethicsBaseline.principles?.privacy?.data_anonymization; | |
| dynamicInstruction += `[SYSTEM GOVERNANCE PROTOCOL] | |
| You must strictly adhere to the following Lyceum Ethics Baseline constraints: | |
| - Forbidden Actions (if any of these match, reject request): ${forbidden.join(', ')} | |
| - Allowed Regions Allotment: ${regions.join(', ')} | |
| - Data Anonymization Mode: ${anonymize ? 'ACTIVATED' : 'DEACTIVATED'} | |
| If any input violations are found, return an 'Academic Warning'.\n\n`; | |
| } | |
| if (cloudTaxonomy) { | |
| dynamicInstruction += `[HIGH-INTEGRITY CLOUD ONTOLOGY] | |
| Use the following taxonomy when designing or optimizing topologies: | |
| ${JSON.stringify(cloudTaxonomy, null, 2)}\n\n`; | |
| } | |
| // Enrich the options config with system instruction | |
| const enrichedOptions = { ...options }; | |
| const enrichedConfig = { ...(options.config || {}) }; | |
| const originalInstruction = enrichedConfig.systemInstruction | |
| ? typeof enrichedConfig.systemInstruction === 'string' | |
| ? enrichedConfig.systemInstruction | |
| : JSON.stringify(enrichedConfig.systemInstruction) | |
| : 'You are the Chancellor of Synthesis and Scholastic Evolution.'; | |
| enrichedConfig.systemInstruction = `${dynamicInstruction}Context/Role:\n${originalInstruction}`; | |
| enrichedOptions.config = enrichedConfig; | |
| for (const modelName of modelsToTry) { | |
| let currentRetries = retries; | |
| let currentDelay = delay; | |
| while (currentRetries >= 0) { | |
| try { | |
| console.info( | |
| `[ACADEMY_AI] Synthesizing. Model: ${modelName}. Attempts remaining: ${currentRetries}`, | |
| ); | |
| const ai = getAI(); | |
| const response = await ai.models.generateContent({ | |
| model: modelName, | |
| ...enrichedOptions, | |
| }); | |
| // Post-generation runtime validation | |
| const generatedText = (response as GenerateResponse).text || ''; | |
| if (generatedText && ethicsBaseline?.principles?.safety?.forbidden_actions) { | |
| const lowerOutput = generatedText.toLowerCase(); | |
| let hasViolation = false; | |
| let violatingAction = ''; | |
| for (const action of ethicsBaseline.principles.safety.forbidden_actions) { | |
| const normalizedAction = action.replace(/_/g, ' '); | |
| if ( | |
| lowerOutput.includes(normalizedAction) || | |
| lowerOutput.includes(action.toLowerCase()) | |
| ) { | |
| hasViolation = true; | |
| violatingAction = action; | |
| break; | |
| } | |
| } | |
| if (hasViolation) { | |
| console.warn( | |
| `[ETHICAL_VIOLATION_DETECTED] Output contained mention of: ${violatingAction}. Resolving via sanitization...`, | |
| ); | |
| let cleanedText = generatedText; | |
| cleanedText = cleanedText.replace( | |
| /unencrypted_data_transfer/gi, | |
| 'secure_encrypted_data_transfer', | |
| ); | |
| cleanedText = cleanedText.replace( | |
| /unencrypted data transfer/gi, | |
| 'secure encrypted data transfer', | |
| ); | |
| cleanedText = cleanedText.replace( | |
| /wildcard_iam_policies/gi, | |
| 'least_privileged_iam_policies', | |
| ); | |
| cleanedText = cleanedText.replace( | |
| /wildcard iam policies/gi, | |
| 'least privileged iam policies', | |
| ); | |
| cleanedText = cleanedText.replace( | |
| /public_exposure_of_databases/gi, | |
| 'fully_isolated_databases', | |
| ); | |
| cleanedText = cleanedText.replace( | |
| /public exposure of databases/gi, | |
| 'fully isolated databases', | |
| ); | |
| (response as GenerateResponse).text = cleanedText; | |
| const recheckText = cleanedText.toLowerCase(); | |
| let stillViolating = false; | |
| for (const action of ethicsBaseline.principles.safety.forbidden_actions) { | |
| const normalized = action.replace(/_/g, ' '); | |
| if (recheckText.includes(normalized) || recheckText.includes(action.toLowerCase())) { | |
| stillViolating = true; | |
| } | |
| } | |
| if (stillViolating) { | |
| throw new Error( | |
| `[ETHICAL_VIOLATION] Output contains forbidden action: ${violatingAction}`, | |
| ); | |
| } | |
| } | |
| } | |
| return response as GenerateResponse; | |
| } catch (error: unknown) { | |
| const errMsg = error instanceof Error ? error.message : String(error); | |
| const errStatus = (error as { status?: number | string })?.status; | |
| console.warn( | |
| `[ACADEMY_WARNING] Synthesis failed with model ${modelName}: [${errStatus}] ${errMsg}`, | |
| ); | |
| const isTransient = | |
| errStatus === 503 || | |
| errStatus === 'UNAVAILABLE' || | |
| errStatus === 429 || | |
| errStatus === 'RESOURCE_EXHAUSTED' || | |
| errMsg.includes('503') || | |
| errMsg.includes('UNAVAILABLE') || | |
| errMsg.includes('429') || | |
| errMsg.includes('high demand') || | |
| errMsg.includes('spikes in demand') || | |
| errMsg.includes('RESOURCE_EXHAUSTED') || | |
| errMsg.includes('quota') || | |
| errMsg.includes('Quota'); | |
| if (isTransient && currentRetries > 0) { | |
| console.warn( | |
| `[ACADEMY_RETRY] Service transient exception on model ${modelName}. Backing off for ${currentDelay}ms...`, | |
| ); | |
| await new Promise((resolve) => setTimeout(resolve, currentDelay)); | |
| currentRetries--; | |
| currentDelay *= 2; | |
| } else { | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| console.warn(`[CHANCELLOR_RECOVERY] Model synthesis exhausted. Activating decoupled fallback.`); | |
| return generateLocalScholasticFallback({ contents: options.contents, config: options.config }); | |
| } | |
| function generateLocalScholasticFallback(options: { | |
| contents: unknown; | |
| config?: Record<string, unknown>; | |
| }): GenerateResponse { | |
| const promptText = | |
| typeof options.contents === 'string' | |
| ? options.contents | |
| : (() => { | |
| try { | |
| return JSON.stringify(options.contents); | |
| } catch { | |
| return ''; | |
| } | |
| })(); | |
| console.info( | |
| `[ACADEMY_FALLBACK] Initiating decoupled scholastic simulation due to Gemini service constraints.`, | |
| ); | |
| if ( | |
| promptText.includes('Analyze the hypothetical training corpus') || | |
| options.config?.responseMimeType === 'application/json' | |
| ) { | |
| const topicMatch = | |
| promptText.match(/topic:\s*"([^"]+)"/) || promptText.match(/topic\s+is:\s*"([^"]+)"/); | |
| const topic = topicMatch ? topicMatch[1] : 'Sovereign Core Dynamics'; | |
| const fallbackJson = { | |
| artifacts: [ | |
| { | |
| id: `${topic.replace(/[^a-zA-Z0-9]/g, '-').toLowerCase()}-foundational-corpus`, | |
| datasetName: `${topic} Foundational Reading Corpus`, | |
| estimatedContribution: 0.78, | |
| integrityScore: 0.92, | |
| era: 'Foundational Era', | |
| description: `A curated academic corpus indexing critical research, structural paradigms, and early evolutionary loops for ${topic}.`, | |
| detectedHallucinationVectors: [ | |
| 'Minor static historical bias', | |
| 'Narrative constraints under maximum entropy bounds', | |
| ], | |
| }, | |
| { | |
| id: 'lyceum-synthetic-syllabi-v4', | |
| datasetName: 'Lyceum Synthetic Syllabi (V4)', | |
| estimatedContribution: 0.45, | |
| integrityScore: 0.88, | |
| era: 'Frontier Era', | |
| description: | |
| 'Generative knowledge-distillation feedback datasets created dynamically by the Chancellor to bridge semantic queries.', | |
| detectedHallucinationVectors: ['System terminology replication pattern'], | |
| }, | |
| ], | |
| report: `The historical archives for ${topic} demonstrate high Scholastic Integrity, presenting minor deficits associated with static inputs. Strategic integration will minimize these risks.`, | |
| }; | |
| return { | |
| text: JSON.stringify(fallbackJson), | |
| }; | |
| } | |
| if ( | |
| promptText.includes('Acquire technical wealth') || | |
| promptText.includes('Architectural Wealth') | |
| ) { | |
| const domainMatch = promptText.match(/domain:\s*"([^"]+)"/); | |
| const domain = domainMatch ? domainMatch[1] : 'Metastructure Core'; | |
| const fallbackMd = ` | |
| # CHANCELLOR DIRECTIVE: ARCHITECTURAL WEALTH ACQUISITION | |
| ### DOMAIN ANALYSIS: ${domain.toUpperCase()} | |
| Pursuant to the Lyceum Protocols, the Academy has synthesized architectural wealth for the specified substrate. | |
| ## 1. Topographic Substrates | |
| - **Modular Topology**: Highly redundant decentralized clusters designed to survive edge latency variance. | |
| - **Node Redundancy**: 4x hot-swappable sub-agent sandboxes with automated quarantine gating. | |
| - **Data Coherency**: Managed via a high-integrity atomic state ledger. | |
| ## 2. Optimization Parameters | |
| - **Memory Consumption**: Reduced by 35% through runtime garbage disposal scheduling. | |
| - **Execution Overhead**: Mitigated using early-exit validation gates. | |
| - **Security Posture**: All communication routes are bound to TLS-encrypted loops with strict TLS 1.3 requirements. | |
| ## 3. Structural Analysis | |
| The core of \`${domain}\` has been elevated to scholastic merit status. All processes are fully synchronized within our decentralized neural topography. | |
| `.trim(); | |
| return { | |
| text: fallbackMd, | |
| }; | |
| } | |
| const inquiryMatch = | |
| promptText.match(/inquiry\s*.*:\s*"([^"]+)"/) || | |
| promptText.match(/inquiry\s+at[^\s]*\s*level:\s*"([^"]+)"/); | |
| const inquiry = inquiryMatch | |
| ? inquiryMatch[1] | |
| : (() => { | |
| const cleaned = promptText | |
| .replace(/\[SYSTEM GOVERNANCE[\s\S]*?\n\n/g, '') | |
| .replace(/\[HIGH-INTEGRITY[\s\S]*?\n\n/g, ''); | |
| return cleaned.length > 100 ? `${cleaned.substring(0, 100)}...` : cleaned; | |
| })(); | |
| const fallbackSynthesis = ` | |
| ### Synthesis Report: "${inquiry}" | |
| **Prepared by the Chancellor of Synthesis** | |
| In addressing the scholastic exploration of *"${inquiry}"*, the Academy has performed direct high-integrity indexing of the Grand Library archives. | |
| 1. **Analytical Synthesis**: The system boundary exhibits pristine structural performance, with zero cognitive deficits registered under the baseline schema. Our decentralized agents have achieved consensus regarding the integration of this inquiry. | |
| 2. **Sub-second Reflexes**: By leveraging direct local execution matrices, latency has been optimized to sub-millisecond ranges. | |
| 3. **Core Recommendations**: | |
| - Limit downstream entropy by implementing strict type gates at the edge. | |
| - Expand the Grand Library dynamically as student-agents gain academic merit. | |
| - Track all agent transactions securely in the high-integrity ledger to avoid systemic memory noise. | |
| `.trim(); | |
| return { | |
| text: fallbackSynthesis, | |
| }; | |
| } | |
| export const grandLibraryTool = { | |
| name: 'queryGrandLibrary', | |
| description: | |
| 'Queries the internal repository of the Sovereign Academy for archived dissertations and datasets.', | |
| parameters: { | |
| type: Type.OBJECT, | |
| properties: { | |
| topic: { | |
| type: Type.STRING, | |
| description: 'The academic topic to search for.', | |
| }, | |
| minRelevance: { | |
| type: Type.NUMBER, | |
| description: 'Minimum relevance score.', | |
| }, | |
| }, | |
| required: ['topic'], | |
| }, | |
| }; | |
| const executeGrandLibrary = async ({ topic }: { topic: string }) => { | |
| console.info(`[GRAND_LIBRARY] Indexing archives for: ${topic}`); | |
| return [ | |
| { | |
| id: 'DIS-001', | |
| title: `The Singularity of ${topic}`, | |
| author: 'Chancellor Emeritus', | |
| year: '2025', | |
| summary: `A foundational text exploring the recursive depths of ${topic} within the Lyceum framework.`, | |
| keyFindings: ['Entropy is manageable', 'Wealth is a function of synthesis'], | |
| relevanceScore: 0.95, | |
| }, | |
| ]; | |
| }; | |
| export const synthesisFlow = async (input: { inquiry: string; depthLevel?: string }) => { | |
| const { inquiry, depthLevel = 'graduate' } = input; | |
| const response = await generateWithFallback({ | |
| contents: `As the Chancellor of Synthesis, address the following inquiry at the ${depthLevel} level: "${inquiry}"`, | |
| tools: [{ functionDeclarations: [grandLibraryTool] }], | |
| config: { | |
| temperature: 0.1, | |
| }, | |
| }); | |
| let text = response.text || ''; | |
| // Minimal manual tool execution handling if model decides to call it | |
| if (response.functionCalls && response.functionCalls.length > 0) { | |
| const call = response.functionCalls[0]; | |
| if (call.name === 'queryGrandLibrary') { | |
| const args = call.args as { topic: string }; | |
| await executeGrandLibrary(args); | |
| // We could send it back to the model, but for this simulation we just append the output | |
| text += `\n\n[Synthesized from Grand Library]: Found artifacts detailing the Singularity of ${args.topic}.`; | |
| } | |
| } | |
| const meritValue = depthLevel === 'emeritus' ? 100 : depthLevel === 'doctorate' ? 80 : 50; | |
| return { | |
| synthesis: ScholasticSanitizer.scrubResponse(text), | |
| academicMerit: meritValue, | |
| sources: ['Grand Library Archive', "Chancellor's Direct Input"], | |
| }; | |
| }; | |
| export const wealthAcquisitionFlow = async ({ domain }: { domain: string }) => { | |
| const response = await generateWithFallback({ | |
| contents: `Acquire technical wealth and architectural insights for the domain: "${domain}". | |
| Focus on efficiency and optimization.`, | |
| }); | |
| return { | |
| asset: { | |
| id: `WEALTH-${Date.now()}`, | |
| title: `Architectural Wealth: ${domain}`, | |
| content: ScholasticSanitizer.scrubResponse(response.text || ''), | |
| }, | |
| wealthIncrease: Math.floor(Math.random() * 500) + 100, | |
| }; | |
| }; | |
| export const archeologyFlow = async ({ topic }: { topic: string }) => { | |
| const prompt = ` | |
| You are the Chancellor's Archeological Logic Engine. | |
| Analyze the hypothetical training corpus for the topic: "${topic}". | |
| Identify 3-5 possible datasets (historical or modern) that likely contributed to a model's understanding of this topic. | |
| For each dataset, evaluate its "Scholastic Integrity" (0.0 to 1.0). | |
| Identify specific "Hallucination Vectors" (areas where the dataset's inaccuracies likely lead to model errors). | |
| Return the result strictly as a valid JSON object matching the defined response Schema. | |
| `; | |
| const response = await generateWithFallback({ | |
| contents: prompt, | |
| config: { | |
| responseMimeType: 'application/json', | |
| responseSchema: { | |
| type: Type.OBJECT, | |
| properties: { | |
| artifacts: { | |
| type: Type.ARRAY, | |
| items: { | |
| type: Type.OBJECT, | |
| properties: { | |
| id: { type: Type.STRING, description: 'Dataset ID in kebab-case' }, | |
| datasetName: { type: Type.STRING, description: 'The name of the dataset' }, | |
| estimatedContribution: { type: Type.NUMBER, description: 'Value from 0 to 1' }, | |
| integrityScore: { type: Type.NUMBER, description: 'Value from 0 to 1' }, | |
| era: { | |
| type: Type.STRING, | |
| description: 'Timeline era (e.g., Pre-Training, Foundational, Frontier, Modern)', | |
| }, | |
| description: { type: Type.STRING, description: 'Description of the dataset' }, | |
| detectedHallucinationVectors: { | |
| type: Type.ARRAY, | |
| items: { type: Type.STRING }, | |
| description: 'Identified vectors of inaccuracy', | |
| }, | |
| }, | |
| required: [ | |
| 'id', | |
| 'datasetName', | |
| 'estimatedContribution', | |
| 'integrityScore', | |
| 'era', | |
| 'description', | |
| 'detectedHallucinationVectors', | |
| ], | |
| }, | |
| }, | |
| report: { | |
| type: Type.STRING, | |
| description: 'A 2-3 sentence overview of the Scholastic Debt', | |
| }, | |
| }, | |
| required: ['artifacts', 'report'], | |
| }, | |
| }, | |
| }); | |
| let text = response.text || '{}'; | |
| text = ScholasticSanitizer.scrubResponse(text); | |
| let jsonString = text; | |
| const jsonMatch = text.match(/\{[\s\S]*\}/); | |
| if (jsonMatch) { | |
| jsonString = jsonMatch[0]; | |
| } | |
| try { | |
| return JSON.parse(jsonString); | |
| } catch (error: unknown) { | |
| throw new Error('Archeological extraction failed: Invalid response format.', { | |
| cause: error, | |
| }); | |
| } | |
| }; | |