@kispace-io/extension-ai-system 0.8.0

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@kispace-io/extension-ai-system",
+  "version": "0.8.0",
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "dependencies": {
+    "@kispace-io/core": "*",
+    "@kispace-io/extension-in-browser-ml": "*",
+    "marked": "^12.0.0 || ^16.4.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}

package/src/agents/agent-registry.ts

@@ -0,0 +1,65 @@
+import { contributionRegistry } from "@kispace-io/core";
+import type { ExecutionContext } from "@kispace-io/core";
+import type { AgentContribution } from "../core/interfaces";
+import { CID_AGENTS } from "../core/constants";
+
+export class AgentRegistry {
+    getAgentContributions(): AgentContribution[] {
+        return contributionRegistry.getContributions(CID_AGENTS) as AgentContribution[];
+    }
+
+    filterAndSortAgents(
+        contributions: AgentContribution[],
+        context: ExecutionContext
+    ): AgentContribution[] {
+        return contributions
+            .filter(contrib => {
+                if (contrib.canHandle) {
+                    return contrib.canHandle(context);
+                }
+                return true;
+            })
+            .sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    }
+
+    getMatchingAgents(
+        context: ExecutionContext,
+        roles?: string[]
+    ): AgentContribution[] {
+        const contributions = this.getAgentContributions();
+        
+        if (contributions.length === 0) {
+            throw new Error('No agents are registered. The App Support agent should be available from the AI system extension.');
+        }
+        
+        let activeContributions = contributions.filter(contrib => {
+            if (roles && !roles.includes(contrib.role)) {
+                return false;
+            }
+            if (contrib.canHandle) {
+                return contrib.canHandle(context);
+            }
+            return true;
+        });
+        
+        if (roles && roles.length > 0) {
+            activeContributions = activeContributions.sort(
+                (a, b) => (b.priority || 0) - (a.priority || 0)
+            );
+            
+            if (activeContributions.length === 0) {
+                const requestedRoles = roles.join(', ');
+                throw new Error(`No agents found for requested roles: ${requestedRoles}. Available agents: ${contributions.map(c => c.role).join(', ')}`);
+            }
+        } else {
+            activeContributions = this.filterAndSortAgents(activeContributions, context);
+            
+            if (activeContributions.length === 0) {
+                throw new Error(`No agents can handle the current context. Available agents: ${contributions.map(c => c.role).join(', ')}`);
+            }
+        }
+
+        return activeContributions;
+    }
+}
+

package/src/agents/index.ts

@@ -0,0 +1,4 @@
+export * from "./agent-registry";
+export * from "./prompt-builder";
+export * from "./message-processor";
+

package/src/agents/message-processor.ts

@@ -0,0 +1,50 @@
+import type { ExecutionContext } from "@kispace-io/core";
+import type { ChatMessage, UserAttentionRequest } from "../core/types";
+import type { MessageProcessor as IMessageProcessor, AgentContribution } from "../core/interfaces";
+
+export class MessageProcessorService {
+    private processors: IMessageProcessor[] = [];
+
+    addProcessor(processor: IMessageProcessor): void {
+        this.processors.push(processor);
+    }
+
+    private getSortedProcessors(): IMessageProcessor[] {
+        return [...this.processors].sort(
+            (a, b) => (b.priority || 0) - (a.priority || 0)
+        );
+    }
+
+    async process(
+        message: ChatMessage,
+        contribution: AgentContribution,
+        context: ExecutionContext
+    ): Promise<ChatMessage> {
+        let processedMessage = { ...message };
+
+        const allProcessors = [
+            ...(contribution.messageProcessors || []),
+            ...this.processors
+        ].sort((a, b) => (b.priority || 0) - (a.priority || 0));
+
+        for (const processor of allProcessors) {
+            processedMessage = await processor.process(processedMessage, context);
+        }
+
+        const requiresAttention = processedMessage.actions?.some(a => a.requiresAttention) || 
+                                  processedMessage.attentionRequests?.some(r => r.requiresAction) ||
+                                  false;
+
+        return {
+            ...processedMessage,
+            requiresAttention
+        };
+    }
+
+    private checkRequiresAttention(message: ChatMessage): boolean {
+        return message.actions?.some(a => a.requiresAttention) || 
+               message.attentionRequests?.some(r => r.requiresAction) ||
+               false;
+    }
+}
+

package/src/agents/prompt-builder.ts

@@ -0,0 +1,167 @@
+import type { ExecutionContext } from "@kispace-io/core";
+import type { ChatMessage, ApiMessage } from "../core/types";
+import type { PromptEnhancer, AgentContribution, AgentToolsConfig, PromptEnhancerContribution } from "../core/interfaces";
+import { ToolRegistry } from "../tools/tool-registry";
+import { contributionRegistry } from "@kispace-io/core";
+import { CID_PROMPT_ENHANCERS } from "../core/constants";
+import { toolDetector } from "../utils/tool-detector";
+
+export class PromptBuilder {
+    private toolRegistry = new ToolRegistry();
+    private enhancers: PromptEnhancer[] = [];
+
+    addEnhancer(enhancer: PromptEnhancer): void {
+        this.enhancers.push(enhancer);
+    }
+
+    private async getSysPrompt(
+        contribution: AgentContribution,
+        context: ExecutionContext
+    ): Promise<string> {
+        let sysPrompt = contribution.sysPrompt;
+        if (typeof sysPrompt === "function") {
+            sysPrompt = sysPrompt();
+        }
+        
+        // The App Support agent should always have a sysPrompt
+        if (!sysPrompt || typeof sysPrompt !== 'string') {
+            throw new Error(`Agent "${contribution.role}" (${contribution.label}) is missing a system prompt. All agents must provide a sysPrompt.`);
+        }
+
+        // Apply prompt enhancers to system prompt instead of user prompt
+        // This keeps contextual information in the system prompt (instructions/context)
+        // and keeps the user prompt clean (just the user's request)
+        const allEnhancers = [
+            ...(contribution.promptEnhancers || []),
+            ...this.enhancers,
+            ...this.getContributedEnhancers()
+        ].sort((a, b) => (b.priority || 0) - (a.priority || 0));
+
+        let enhancedSysPrompt = sysPrompt;
+        for (const enhancer of allEnhancers) {
+            try {
+                enhancedSysPrompt = await enhancer.enhance(enhancedSysPrompt, context);
+                // Ensure enhancer returns a string
+                if (!enhancedSysPrompt || typeof enhancedSysPrompt !== 'string') {
+                    enhancedSysPrompt = sysPrompt; // Fallback to original if enhancer returns invalid value
+                }
+            } catch (err) {
+                // If an enhancer fails, log the error but continue with the current prompt
+                console.warn(`[PromptBuilder] Enhancer failed:`, err);
+                // Continue with the current enhancedSysPrompt value
+            }
+        }
+
+        return enhancedSysPrompt;
+    }
+
+    private rewriteChatHistoryForAgent(
+        history: ApiMessage[],
+        targetRole: string
+    ): ApiMessage[] {
+        return history.map(m => {
+            if (m.role === "user") {
+                return { role: m.role, content: m.content };
+            }
+            if (m.role === targetRole) {
+                return { role: "assistant", content: m.content };
+            }
+            return {
+                role: "user",
+                content: `***Agent '${m.role}' replied:***\n${m.content}`
+            };
+        });
+    }
+
+    private getContributedEnhancers(): PromptEnhancer[] {
+        const contributions = contributionRegistry.getContributions(CID_PROMPT_ENHANCERS) as PromptEnhancerContribution[];
+        return contributions.map(contrib => ({
+            ...contrib.enhancer,
+            priority: contrib.priority ?? contrib.enhancer.priority
+        }));
+    }
+
+    // Removed enhancePrompt method - prompt enhancers now enhance the system prompt instead
+    // This keeps contextual information in system prompts and user prompts clean
+
+    async build(
+        contribution: AgentContribution,
+        messages: ChatMessage[],
+        context: ExecutionContext,
+        hooks?: { beforeSend?: (messages: ChatMessage[], context: ExecutionContext) => Promise<void> }
+    ): Promise<{ messages: ApiMessage[]; userPromptIndex: number; tools?: import("../core/types").ToolDefinition[] }> {
+        if (hooks?.beforeSend) {
+            await hooks.beforeSend(messages, context);
+        }
+
+        const sanitizedMessages = this.sanitizeMessagesForAPI(messages);
+        const messagesCopy = this.rewriteChatHistoryForAgent(sanitizedMessages, contribution.role);
+
+        // Resolve tools config if it's a function
+        let toolsConfig = contribution.tools;
+        if (typeof toolsConfig === 'function') {
+            toolsConfig = await toolsConfig();
+        }
+
+        let tools: import("../core/types").ToolDefinition[] | undefined;
+        if (toolsConfig?.enabled) {
+            // If smart tool detection is enabled, check if the prompt needs tools
+            if (toolsConfig.smartToolDetection) {
+                const lastUserMessage = messages[messages.length - 1];
+                const userPrompt = lastUserMessage?.content || '';
+                
+                // Use ML model to detect if tools are needed
+                const needsTools = await toolDetector.needsTools(userPrompt);
+                
+                if (needsTools) {
+                    tools = this.toolRegistry.getAvailableTools(
+                        context,
+                        toolsConfig.commandFilter
+                    );
+                }
+                // If not needed, tools remains undefined (no tools provided)
+            } else {
+                // Default behavior: always provide tools if enabled
+                tools = this.toolRegistry.getAvailableTools(
+                    context,
+                    toolsConfig.commandFilter
+                );
+            }
+        }
+
+        // Enhance system prompt with contextual information (app state, language context, etc.)
+        // Keep user prompt clean - just the user's actual request
+        const sysPrompt = await this.getSysPrompt(contribution, context);
+        messagesCopy.unshift({
+            role: "system",
+            content: sysPrompt
+        });
+
+        // Calculate userPromptIndex AFTER adding system message (system is at index 0, user is at index 1)
+        const lastUserPromptIndex = messagesCopy.length - 1;
+
+        return { messages: messagesCopy, userPromptIndex: lastUserPromptIndex, tools };
+    }
+
+    private sanitizeMessageForAPI(message: ChatMessage | ApiMessage): ApiMessage {
+        const apiMessage: ApiMessage = {
+            role: message.role,
+            content: message.content
+        };
+        
+        if ('tool_call_id' in message && message.tool_call_id) {
+            apiMessage.tool_call_id = message.tool_call_id;
+        }
+        
+        if ('tool_calls' in message && (message as any).tool_calls) {
+            apiMessage.tool_calls = (message as any).tool_calls;
+        }
+        
+        return apiMessage;
+    }
+
+    private sanitizeMessagesForAPI(messages: (ChatMessage | ApiMessage)[]): ApiMessage[] {
+        return messages.map(msg => this.sanitizeMessageForAPI(msg));
+    }
+}
+

package/src/ai-system-extension.ts

@@ -0,0 +1,104 @@
+import { html } from "lit";
+import { rootContext } from "@kispace-io/core";
+import { aiService } from "./service/ai-service";
+import { contributionRegistry, HTMLContribution } from "@kispace-io/core";
+import { editorRegistry, EditorInput } from "@kispace-io/core";
+import { registerAll } from "@kispace-io/core";
+import { TOOLBAR_BOTTOM, TOOLBAR_MAIN_RIGHT, SIDEBAR_AUXILIARY } from "@kispace-io/core";
+import { CID_AGENTS, KEY_AI_CONFIG } from "./core/constants";
+import type { AgentContribution, AgentToolsConfig } from "./core/interfaces";
+import type { AIConfig } from "./core/types";
+import { appSettings } from "@kispace-io/core";
+import { i18n } from "@kispace-io/core";
+import GENERAL_SYS_PROMPT from "./general-assistant-prompt.txt?raw";
+import "./chat-provider-contributions";
+import "./prompt-enhancer-contributions";
+import "./view/k-aiview";
+import "./view/k-token-usage";
+import "./view/components/k-ai-config-editor";
+import aisystemBundle from "./aisystem.json";
+import { SYSTEM_LANGUAGE_BUNDLES } from "@kispace-io/core";
+
+import { t } from "./translation";
+
+// Register language bundle as early as possible to avoid race conditions
+contributionRegistry.registerContribution(SYSTEM_LANGUAGE_BUNDLES, aisystemBundle as any);
+
+contributionRegistry.registerContribution(SIDEBAR_AUXILIARY, {
+    name: "aiview",
+    label: t('SIDEBAR_LABEL'),
+    icon: "robot",
+    component: (id: string) => html`<k-aiview id="${id}"></k-aiview>`
+});
+
+// Register default App Support agent with general assistant prompt
+// Apps can enhance this prompt using prompt enhancers
+// smartToolDetection is read from AIConfig dynamically
+contributionRegistry.registerContribution(CID_AGENTS, {
+    label: t('APP_SUPPORT'),
+    description: t('APP_SUPPORT_DESC'),
+    role: "appsupport",
+    priority: 100,
+    icon: "question-circle",
+    sysPrompt: GENERAL_SYS_PROMPT,
+    tools: () => {
+        // Read smartToolDetection setting from AIConfig synchronously
+        // This will be resolved in the prompt builder
+        return appSettings.get(KEY_AI_CONFIG).then((config: AIConfig | undefined) => {
+            const smartToolDetection = config?.smartToolDetection ?? false;
+            return {
+                enabled: true,
+                smartToolDetection
+            } as AgentToolsConfig;
+        });
+    }
+} as AgentContribution);
+
+contributionRegistry.registerContribution(TOOLBAR_BOTTOM, {
+    target: TOOLBAR_BOTTOM,
+    label: t('TOKEN_USAGE'),
+    html: `<k-token-usage></k-token-usage>`
+} as HTMLContribution);
+
+editorRegistry.registerEditorInputHandler({
+    ranking: 1000,
+    canHandle: (input: EditorInput) => {
+        return input.key === '.system.ai-config';
+    },
+    handle: async (input: EditorInput) => {
+        input.editorId = "ai-config-editor";
+        input.widgetFactory = () => html`
+                <k-ai-config-editor .input=${input}></k-ai-config-editor>
+            `;
+        return input;
+    }
+});
+
+registerAll({
+    command: {
+        "id": "open_ai_config",
+        "name": t('OPEN_AI_CONFIG'),
+        "description": t('OPEN_AI_CONFIG_DESC'),
+        "parameters": []
+    },
+    handler: {
+        execute: _context => {
+            const editorInput = {
+                title: t('AI_SETTINGS'),
+                data: {},
+                key: ".system.ai-config",
+                icon: "robot",
+                state: {},
+            } as EditorInput;
+            editorRegistry.loadEditor(editorInput).then();
+        }
+    },
+    contribution: {
+        target: TOOLBAR_MAIN_RIGHT,
+        icon: "robot",
+        label: t('AI_CONFIG'),
+    }
+});
+
+rootContext.put("aiService", aiService);
+

package/src/aisystem.json

@@ -0,0 +1,154 @@
+{
+    "namespace": "aisystem",
+    "en": {
+        "APP_SUPPORT": "App Support",
+        "APP_SUPPORT_DESC": "General app support",
+        "SIDEBAR_LABEL": "AI",
+        "TOKEN_USAGE": "Token Usage",
+        "OPEN_AI_CONFIG": "Open AI Config",
+        "OPEN_AI_CONFIG_DESC": "Opens the AI settings editor",
+        "AI_SETTINGS": "AI Settings",
+        "AI_CONFIG": "AI Config",
+        "NO_PROVIDER_CONFIGURED": "No AI provider configured",
+        "CLICK_SETTINGS_TO_CONFIGURE": "Click the settings button to configure",
+        "TYPE_MESSAGE_ENTER": "Type your message and press Enter...",
+        "STOP": "Stop",
+        "SETTINGS": "Settings",
+        "CLOSE": "Close",
+        "ARCHIVED_SESSIONS": "Archived Sessions",
+        "RESTORE": "Restore",
+        "DELETE_ALL_ARCHIVED": "Delete All Archived",
+        "DELETE_ALL_CONFIRM": "Are you sure you want to permanently delete all {count} archived session{plural}?",
+        "NEW_CHAT": "New Chat",
+        "CHAT": "Chat",
+        "CANCEL": "Cancel",
+        "APPROVE": "Approve",
+        "TOOL_APPROVAL_REQUEST": "Tool Approval Request",
+        "TOOL_CALLS": "Tool Calls",
+        "TOOL_APPROVAL_MESSAGE": "The AI wants to execute {toolCount} tool call{plural}: {toolList}",
+        "COPY": "Copy",
+        "AI_ASSISTANT": "AI Assistant",
+        "MULTIPLE_AGENTS": "Multiple Agents",
+        "QUICK_ACTIONS": "Quick Actions",
+        "TOKEN_USAGE_STATS": "Token Usage Statistics",
+        "TOTAL_USAGE": "Total Usage",
+        "TOTAL": "Total",
+        "PROMPT": "Prompt",
+        "COMPLETION": "Completion",
+        "REQUESTS": "Requests",
+        "BY_PROVIDER": "By Provider",
+        "RESET_STATISTICS": "Reset Statistics",
+        "RESET_CONFIRM": "Reset all token usage statistics?",
+        "TOKENS": "tokens",
+        "LOADING_MODELS": "Loading models...",
+        "SELECT_MODEL": "Select a model",
+        "TOOL_EXECUTION_PENDING": "Tool execution pending: {toolCount} tool{plural} ({toolName}{more})",
+        "AGENT_WANTS_TO_EXECUTE": "Agent \"{role}\" wants to execute the following tools:",
+        "ALWAYS_ALLOW": "Always allow",
+        "COPY_CODE": "Copy code",
+        "REQUIRES_ATTENTION": "Requires attention",
+        "RESEND": "Resend",
+        "CONFIRM": "Confirm",
+        "REJECT": "Reject",
+        "ENTER_RESPONSE": "Enter your response...",
+        "SUBMIT": "Submit",
+        "CONTINUE_WORKFLOW": "Continue Workflow",
+        "PROVIDERS": "Providers",
+        "ADD_PROVIDER": "Add Provider",
+        "DEFAULT": "Default",
+        "NAME": "Name",
+        "MODEL": "Model",
+        "API_ENDPOINT": "API Endpoint",
+        "API_KEY": "API Key",
+        "OCR_ENDPOINT": "OCR Endpoint",
+        "OCR_MODEL": "OCR Model",
+        "ACTIONS": "Actions",
+        "DELETE_PROVIDER": "Delete",
+        "DELETE_PROVIDER_CONFIRM": "Delete provider \"{name}\"?",
+        "NO_PROVIDERS_CONFIGURED": "No providers configured. Click \"Add Provider\" to get started.",
+        "TOOL_APPROVALS": "Tool Approvals",
+        "REQUIRE_APPROVAL_BEFORE_EXECUTING": "Require approval before executing tools",
+        "SMART_TOOL_DETECTION": "Use smart tool detection (reduces token usage)",
+        "SMART_TOOL_DETECTION_HINT": "When enabled, a small ML model running in your browser will detect if a prompt needs tools. This reduces token usage for simple queries like greetings. Note: The model (approximately 60-80MB quantized) will be downloaded on first use, which may take some time.",
+        "APPROVED_COMMANDS": "Approved Commands",
+        "SELECT_COMMANDS_WITHOUT_APPROVAL": "Select commands that can be executed without approval:",
+        "COMMANDS_AUTO_APPROVED": "These commands will be approved automatically when approval is enabled:",
+        "OPTIONAL": "Optional"
+    },
+    "de": {
+        "APP_SUPPORT": "App-Unterstützung",
+        "APP_SUPPORT_DESC": "Allgemeine App-Unterstützung",
+        "SIDEBAR_LABEL": "KI",
+        "TOKEN_USAGE": "Token-Verbrauch",
+        "OPEN_AI_CONFIG": "KI-Konfiguration öffnen",
+        "OPEN_AI_CONFIG_DESC": "Öffnet den KI-Einstellungseditor",
+        "AI_SETTINGS": "KI-Einstellungen",
+        "AI_CONFIG": "KI-Konfiguration",
+        "NO_PROVIDER_CONFIGURED": "Kein KI-Anbieter konfiguriert",
+        "CLICK_SETTINGS_TO_CONFIGURE": "Klicken Sie auf die Einstellungsschaltfläche zum Konfigurieren",
+        "TYPE_MESSAGE_ENTER": "Geben Sie Ihre Nachricht ein und drücken Sie Enter...",
+        "STOP": "Stopp",
+        "SETTINGS": "Einstellungen",
+        "CLOSE": "Schließen",
+        "ARCHIVED_SESSIONS": "Archivierte Sitzungen",
+        "RESTORE": "Wiederherstellen",
+        "DELETE_ALL_ARCHIVED": "Alle archivierten löschen",
+        "DELETE_ALL_CONFIRM": "Möchten Sie wirklich alle {count} archivierte Sitzung{plural} dauerhaft löschen?",
+        "NEW_CHAT": "Neuer Chat",
+        "CHAT": "Chat",
+        "CANCEL": "Abbrechen",
+        "APPROVE": "Genehmigen",
+        "TOOL_APPROVAL_REQUEST": "Werkzeug-Genehmigungsanfrage",
+        "TOOL_CALLS": "Werkzeugaufrufe",
+        "TOOL_APPROVAL_MESSAGE": "Die KI möchte {toolCount} Werkzeugaufruf{plural} ausführen: {toolList}",
+        "COPY": "Kopieren",
+        "AI_ASSISTANT": "KI-Assistent",
+        "MULTIPLE_AGENTS": "Mehrere Agenten",
+        "QUICK_ACTIONS": "Schnellaktionen",
+        "TOKEN_USAGE_STATS": "Token-Verbrauchsstatistiken",
+        "TOTAL_USAGE": "Gesamtverbrauch",
+        "TOTAL": "Gesamt",
+        "PROMPT": "Eingabeaufforderung",
+        "COMPLETION": "Vervollständigung",
+        "REQUESTS": "Anfragen",
+        "BY_PROVIDER": "Nach Anbieter",
+        "RESET_STATISTICS": "Statistiken zurücksetzen",
+        "RESET_CONFIRM": "Alle Token-Verbrauchsstatistiken zurücksetzen?",
+        "TOKENS": "Tokens",
+        "LOADING_MODELS": "Modelle werden geladen...",
+        "SELECT_MODEL": "Modell auswählen",
+        "TOOL_EXECUTION_PENDING": "Werkzeugausführung ausstehend: {toolCount} Werkzeug{plural} ({toolName}{more})",
+        "AGENT_WANTS_TO_EXECUTE": "Agent \"{role}\" möchte die folgenden Werkzeuge ausführen:",
+        "ALWAYS_ALLOW": "Immer erlauben",
+        "COPY_CODE": "Code kopieren",
+        "REQUIRES_ATTENTION": "Erfordert Aufmerksamkeit",
+        "RESEND": "Erneut senden",
+        "CONFIRM": "Bestätigen",
+        "REJECT": "Ablehnen",
+        "ENTER_RESPONSE": "Geben Sie Ihre Antwort ein...",
+        "SUBMIT": "Absenden",
+        "CONTINUE_WORKFLOW": "Workflow fortsetzen",
+        "PROVIDERS": "Anbieter",
+        "ADD_PROVIDER": "Anbieter hinzufügen",
+        "DEFAULT": "Standard",
+        "NAME": "Name",
+        "MODEL": "Modell",
+        "API_ENDPOINT": "API-Endpunkt",
+        "API_KEY": "API-Schlüssel",
+        "OCR_ENDPOINT": "OCR-Endpunkt",
+        "OCR_MODEL": "OCR-Modell",
+        "ACTIONS": "Aktionen",
+        "DELETE_PROVIDER": "Löschen",
+        "DELETE_PROVIDER_CONFIRM": "Anbieter \"{name}\" löschen?",
+        "NO_PROVIDERS_CONFIGURED": "Keine Anbieter konfiguriert. Klicken Sie auf \"Anbieter hinzufügen\", um zu beginnen.",
+        "TOOL_APPROVALS": "Werkzeug-Genehmigungen",
+        "REQUIRE_APPROVAL_BEFORE_EXECUTING": "Genehmigung vor der Ausführung von Werkzeugen erforderlich",
+        "SMART_TOOL_DETECTION": "Intelligente Werkzeugerkennung verwenden (reduziert Token-Verbrauch)",
+        "SMART_TOOL_DETECTION_HINT": "Wenn aktiviert, erkennt ein kleines ML-Modell in Ihrem Browser, ob eine Eingabeaufforderung Werkzeuge benötigt. Dies reduziert den Token-Verbrauch bei einfachen Abfragen wie Begrüßungen. Hinweis: Das Modell (ca. 60-80MB quantisiert) wird bei der ersten Verwendung heruntergeladen, was einige Zeit dauern kann.",
+        "APPROVED_COMMANDS": "Genehmigte Befehle",
+        "SELECT_COMMANDS_WITHOUT_APPROVAL": "Wählen Sie Befehle aus, die ohne Genehmigung ausgeführt werden können:",
+        "COMMANDS_AUTO_APPROVED": "Diese Befehle werden automatisch genehmigt, wenn die Genehmigung aktiviert ist:",
+        "OPTIONAL": "Optional"
+    }
+}
+

package/src/chat-provider-contributions.ts

@@ -0,0 +1,95 @@
+import { contributionRegistry } from '@kispace-io/core';
+import { CID_CHAT_PROVIDERS, ChatProviderContribution } from './core';
+
+contributionRegistry.registerContribution<ChatProviderContribution>(CID_CHAT_PROVIDERS, {
+    target: CID_CHAT_PROVIDERS,
+    label: "Ollama (Local)",
+    provider: {
+        name: "ollama",
+        model: "gemma3:12b",
+        chatApiEndpoint: "https://<your-server>/v1/chat/completions",
+        apiKey: ""
+    }
+});
+
+contributionRegistry.registerContribution<ChatProviderContribution>(CID_CHAT_PROVIDERS, {
+    target: CID_CHAT_PROVIDERS,
+    label: "OpenWebUI (Self Hosted)",
+    provider: {
+        name: "openwebui",
+        model: "gemma3:12b",
+        chatApiEndpoint: "https://<your-server>/api/v1/chat/completion",
+        apiKey: ""
+    }
+});
+
+contributionRegistry.registerContribution<ChatProviderContribution>(CID_CHAT_PROVIDERS, {
+    target: CID_CHAT_PROVIDERS,
+    label: "OpenAI",
+    provider: {
+        name: "openai",
+        model: "gpt-4.1",
+        chatApiEndpoint: "https://api.openai.com/v1/chat/completions",
+        apiKey: "<your api key>"
+    }
+});
+
+contributionRegistry.registerContribution<ChatProviderContribution>(CID_CHAT_PROVIDERS, {
+    target: CID_CHAT_PROVIDERS,
+    label: "Groq",
+    provider: {
+        name: "groq",
+        model: "llama-3.1-8b-instant",
+        chatApiEndpoint: "https://api.groq.com/openai/v1/chat/completions",
+        apiKey: "<your api key>"
+    }
+});
+
+contributionRegistry.registerContribution<ChatProviderContribution>(CID_CHAT_PROVIDERS, {
+    target: CID_CHAT_PROVIDERS,
+    label: "Cerebras",
+    provider: {
+        name: "cerebras",
+        model: "llama3.1-8b",
+        chatApiEndpoint: "https://api.cerebras.ai/v1/chat/completions",
+        apiKey: "<your api key>"
+    }
+});
+
+contributionRegistry.registerContribution<ChatProviderContribution>(CID_CHAT_PROVIDERS, {
+    target: CID_CHAT_PROVIDERS,
+    label: "WebLLM",
+    provider: {
+        name: "webllm",
+        model: "gemma-2-9b-it-q4f16_1-MLC",
+        chatApiEndpoint: "",
+        apiKey: "",
+        parameters: {
+            context_window_size: 4096
+        }
+    }
+});
+
+contributionRegistry.registerContribution<ChatProviderContribution>(CID_CHAT_PROVIDERS, {
+    target: CID_CHAT_PROVIDERS,
+    label: "Mistral",
+    provider: {
+        name: "mistral",
+        model: "mistral-large-latest",
+        chatApiEndpoint: "https://api.mistral.ai/v1/chat/completions",
+        apiKey: "<your api key>",
+        ocrApiEndpoint: "https://api.mistral.ai/v1/ocr",
+        ocrModel: "mistral-ocr-latest"
+    }
+});
+
+contributionRegistry.registerContribution<ChatProviderContribution>(CID_CHAT_PROVIDERS, {
+    target: CID_CHAT_PROVIDERS,
+    label: "LiteLLM",
+    provider: {
+        name: "litellm",
+        model: "gpt-3.5-turbo",
+        chatApiEndpoint: "https://<your-server>/v1/chat/completions",
+        apiKey: "<your api key>"
+    }
+});