Merge branch 'main' into safety-branch

Updated API key entry instructions and fixed typos.

README.md

@@ -11,20 +11,43 @@ This Minecraft mod allows players, especially new ones, to get real-time assista
 * **Game Version:** 1.21.1
 * **Loader:** [Fabric Loader](https://fabricmc.net/)
 * **Dependencies:** [Fabric API](https://www.curseforge.com/minecraft/mc-mods/fabric-api)
-* **Information**: This mod uses a Cloud-AI. Active Internet connection is required. (No API Keys required)
+* **Information**: This mod uses a self-hosted-AI. Active Internet connection and API key required (no subscription).
+* **API Key**: This Mod requires an API key from [ai.cametendo.org](https://ai.cametendo.org). Steps on how to acquire an API will be listed further down in the README.
 
 ## Usage
-- Command: `/ai <propmpt>`. With this command, you can ask the AI your question.
-- Use this command to talk to your AI Companion at any time during gameplay.
+There are three commands included in this mod:
+- `/ai question`: This will let you communicate with the AI directly from the In-Game Chat
+- `/ai spawn`: This will spawn an actual entity, your 'Companion' (multiple companions can be spawned). It will follow you around and can be interacted with by right-clicking.
+- `/ai kill`: This will kill / remove all companions you spawned
+- `/ai delete-key`: This lets you delete your API-Key, incase you deleted your account on the WebUI or experience other problems, you can use this command to enter a new key.
 - Note: Depending on the question the AI will take 1 - 3 minutes to respond. Please be patient while your companion "thinks"!
 
+## AI Companion Entity 
+The AI Companion doesn't just stand around, he too has his own features:
+
+- `Chat-Window`: Right-clicking the Companion will open a chat window. In this, you will have a chat-interface that keeps your chat until you leave the world.
+- `Follows you`: Instead of just standing around, the companion will ffollow you around wherever you go and walk around the world.
+- `API-Key-Verification`: The first time you play this mod, you may need to use the companion to enter your API key.
+
+
 ## Installation
 1. If not already done, install [Fabric 1.21.1](https://maven.fabricmc.net/net/fabricmc/fabric-installer/1.1.1/fabric-installer-1.1.1.jar). (Click to download the Fabric Installer instantly)
 2. Download the mod from the [Releases](https://github.com/Cametendo/minecraft-ai-companion-EMVs12-Project/releases) Tab.
 3. Place the `.jar` file in your `%appdata%/.minecraft/mods` folder.
-4. Launch the game in your preferred launcher with the Fabric 1.21.1 Profile ([List of Minecraft Launchers](https://github.com/TayouVR/MinecraftLauncherComparison)
+4. Launch the game in your preferred launcher with the Fabric 1.21.1 Profile ([List of Minecraft Launchers](https://github.com/TayouVR/MinecraftLauncherComparison)) <br>
+
 **IMPORTANT**: This Installation Process is strictly for the offical version of Minecraft (including the official Launcher). We are not not responsible for any issues, data loss, or crashes that may occur when using third-party launchers or unofficial versions of the game. Support is only guaranteed for the official Fabric environment.
 
+## API-Key
+This mod requires an API key. To acquire an API key, follow these steps:
+1. Create an account on [ai.cametendo.org](https://ai.cametendo.org)
+2. Press your user profile (bottom-left corner) and switch to the tab "Account".
+3. Find the option "API Keys" and press show. A very long line of dots should appear. This is your API key (hidden by default).
+4. Copy it and start your game (or go back to it if it's already open)
+5. Use /ai question and enter a question. A new window with "Enter your Open-WebUI API-Key" should appear. In the text box, enter your API Key and confirm it by pressing enter.
+6. Alternatively, if that didn't work, use /ai spawn to spawn your AI Companion. THen right-click it and you should see the "Enter your Open-WebUI API-Key" window. Enter it into the text box and confirm it by pressing enter.
+7. If everything worked, you can now send messages to your AI Companion. Have fun!
+
 ## License & Credits
 * **Authors:** [Cametendo](https://www.github.com/Cametendo), [ritonioz](https://www.github.com/ritonioz), [Adam237A](https://www.github.com/Adam237A)
 * **License:** CC0 1.0 (Public Domain). Feel free to include this in any modpack! (Credits are appreciated but not required).

src/client/java/AiCompanion/aicompanion2_0/client/AiChatScreen.java

@@ -0,0 +1,116 @@
+package AiCompanion.aicompanion2_0.client;
+
+import net.minecraft.client.gui.DrawContext;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.client.gui.widget.TextFieldWidget;
+import net.minecraft.text.OrderedText;
+import net.minecraft.text.Text;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AiChatScreen extends Screen {
+
+    private final AiChatSession session;
+    private TextFieldWidget inputField;
+    private int scrollOffset = 0;
+
+    public AiChatScreen(AiChatSession session) {
+        super(Text.literal("AI Companion"));
+        this.session = session;
+    }
+
+    private List<String> displayLines() {
+        return session.getDisplayLines();
+    }
+
+    @Override
+    protected void init() {
+        inputField = new TextFieldWidget(
+            textRenderer, width / 2 - 150, height - 35, 270, 20,
+            Text.literal("Message...")
+        );
+        inputField.setMaxLength(500);
+        inputField.setFocused(true);
+        addDrawableChild(inputField);
+
+        addDrawableChild(ButtonWidget.builder(Text.literal("Send"), btn -> sendMessage())
+            .dimensions(width / 2 + 125, height - 35, 60, 20)
+            .build()
+        );
+
+        addDrawableChild(ButtonWidget.builder(Text.literal("Close"), btn -> close())
+            .dimensions(width / 2 - 30, height - 10, 60, 15)
+            .build()
+        );
+    }
+
+    @Override
+    public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        if (keyCode == 257 || keyCode == 335) { // Enter
+            sendMessage();
+            return true;
+        }
+        return super.keyPressed(keyCode, scanCode, modifiers);
+    }
+
+    private void sendMessage() {
+        String msg = inputField.getText().trim();
+        if (msg.isEmpty()) return;
+        inputField.setText("");
+
+        displayLines().add("§eIch: §f" + msg);
+        displayLines().add("§7[AI thinking about...]");
+        session.sendMessage(msg, response -> {
+            displayLines().remove("§7[AI thinking about...]");
+            displayLines().add("§6AI: §f" + response);
+            // auto-scroll to bottom
+            scrollOffset = 0;
+        });
+    }
+
+    @Override
+    public void render(DrawContext context, int mouseX, int mouseY, float delta) {
+        renderBackground(context);
+
+        // Chat box background
+        context.fill(width / 2 - 155, 10, width / 2 + 155, height - 45, 0xAA000000);
+
+        // Title
+        context.drawCenteredTextWithShadow(textRenderer, "§6AI Companion", width / 2, 15, 0xFFFFFF);
+
+        // Pre-wrap all lines first so we know total height
+        int lineHeight = 11;
+        List<OrderedText> allWrapped = new ArrayList<>();
+        for (String dl : displayLines()) {
+            allWrapped.addAll(textRenderer.wrapLines(Text.literal(dl), 290));
+        }
+
+        int chatAreaHeight = height - 65;
+        int maxLines = chatAreaHeight / lineHeight;
+        int totalLines = allWrapped.size();
+
+        int startIdx = Math.max(0, totalLines - maxLines - scrollOffset);
+        int endIdx = Math.min(totalLines, startIdx + maxLines);
+
+        int y = 25;
+        for (int i = startIdx; i < endIdx; i++) {
+            context.drawTextWithShadow(textRenderer, allWrapped.get(i), width / 2 - 148, y, 0xFFFFFF);
+            y += lineHeight;
+        }
+
+        super.render(context, mouseX, mouseY, delta);
+    }
+
+    @Override
+    public boolean mouseScrolled(double mouseX, double mouseY, double amount) {
+        scrollOffset = Math.max(0, scrollOffset - (int) amount);
+        return true;
+    }
+
+    @Override
+    public boolean shouldPause() {
+        return false;
+    }
+}

src/client/java/AiCompanion/aicompanion2_0/client/AiChatSession.java

@@ -0,0 +1,151 @@
+package AiCompanion.aicompanion2_0.client;
+
+import java.io.*;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
+public class AiChatSession {
+
+    private final String apiBaseUrl;
+    private final String apiKey;
+    private final String model;
+
+    // OpenAI-format message history: alternating user/assistant
+    private final List<String[]> history = new ArrayList<>(); // [role, content]
+    private final List<String> displayLines = new ArrayList<>();
+
+    public AiChatSession(String apiBaseUrl, String apiKey, String model) {
+        this.apiBaseUrl = apiBaseUrl;
+        this.apiKey = apiKey;
+        this.model = model;
+        displayLines.add("§7Start a conversation with your AI companion!");
+    }
+
+    public List<String> getDisplayLines() {
+        return displayLines;
+    }
+
+    public void sendMessage(String userMessage, Consumer<String> onResponse) {
+        history.add(new String[]{"user", userMessage});
+
+        if (AiCompanionClient.tryTriggerArchEasterEgg(userMessage, response -> {
+            history.add(new String[]{"assistant", response});
+            onResponse.accept(response);
+        })) {
+            return;
+        }
+
+        new Thread(() -> {
+            try {
+                String response = callOpenWebUI();
+                history.add(new String[]{"assistant", response});
+                onResponse.accept(response);
+            } catch (Exception e) {
+                onResponse.accept("§cError: " + e.getMessage());
+            }
+        }).start();
+    }
+
+    private String callOpenWebUI() throws Exception {
+        // Build messages array
+        StringBuilder messages = new StringBuilder("[");
+        for (int i = 0; i < history.size(); i++) {
+            String[] msg = history.get(i);
+            messages.append("{\"role\":\"").append(msg[0])
+                    .append("\",\"content\":\"").append(jsonEscape(msg[1]))
+                    .append("\"}");
+            if (i < history.size() - 1) messages.append(",");
+        }
+        messages.append("]");
+
+        String json = "{\"model\":\"" + jsonEscape(model) + "\",\"messages\":" + messages + ",\"stream\":false}";
+        HttpResult primary = postChatCompletion("/api/chat/completions", json);
+        if (primary.status == 200) {
+            return extractAssistantContent(primary.body);
+        }
+
+        if (primary.status >= 500 || primary.status == 404) {
+            HttpResult fallback = postChatCompletion("/v1/chat/completions", json);
+            if (fallback.status == 200) {
+                return extractAssistantContent(fallback.body);
+            }
+            return formatHttpError(fallback.status, fallback.body, "/v1/chat/completions");
+        }
+
+        return formatHttpError(primary.status, primary.body, "/api/chat/completions");
+    }
+
+    private HttpResult postChatCompletion(String path, String json) throws Exception {
+        URL url = new URL(apiBaseUrl + path);
+        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+        conn.setRequestMethod("POST");
+        conn.setRequestProperty("Content-Type", "application/json; charset=utf-8");
+        if (apiKey != null && !apiKey.isBlank()) {
+            conn.setRequestProperty("Authorization", "Bearer " + apiKey);
+        }
+        conn.setDoOutput(true);
+
+        try (OutputStream os = conn.getOutputStream()) {
+            os.write(json.getBytes("utf-8"));
+        }
+
+        int status = conn.getResponseCode();
+        String body = readResponseBody(conn, status >= 400);
+        conn.disconnect();
+        return new HttpResult(status, body);
+    }
+
+    private String readResponseBody(HttpURLConnection conn, boolean error) throws IOException {
+        var stream = error ? conn.getErrorStream() : conn.getInputStream();
+        if (stream == null) return "";
+
+        StringBuilder resp = new StringBuilder();
+        try (BufferedReader br = new BufferedReader(new InputStreamReader(stream, "utf-8"))) {
+            String line;
+            while ((line = br.readLine()) != null) resp.append(line);
+        }
+        return resp.toString();
+    }
+
+    private String extractAssistantContent(String body) {
+        int idx = body.indexOf("\"content\":\"");
+        if (idx >= 0) {
+            int start = idx + 11;
+            int end = body.indexOf("\"", start);
+            while (end > 0 && body.charAt(end - 1) == '\\') {
+                end = body.indexOf("\"", end + 1);
+            }
+            return body.substring(start, end).replace("\\n", "\n").replace("\\\"", "\"");
+        }
+        return body;
+    }
+
+    private String formatHttpError(int status, String body, String path) {
+        if (body == null || body.isBlank()) {
+            return "Error: HTTP " + status + " (" + path + ")";
+        }
+        return "Error: HTTP " + status + " (" + path + ") - " + body;
+    }
+
+    private String jsonEscape(String value) {
+        if (value == null) return "";
+        return value.replace("\\", "\\\\")
+                .replace("\"", "\\\"")
+                .replace("\n", "\\n")
+                .replace("\r", "\\r")
+                .replace("\t", "\\t");
+    }
+
+    private static class HttpResult {
+        private final int status;
+        private final String body;
+
+        private HttpResult(int status, String body) {
+            this.status = status;
+            this.body = body;
+        }
+    }
+}

src/client/java/AiCompanion/aicompanion2_0/client/AiCompanionClient.java

@@ -0,0 +1,187 @@
+package AiCompanion.aicompanion2_0.client;
+
+import AiCompanion.aicompanion2_0.AIEntity;
+import AiCompanion.aicompanion2_0.Aicompanion2_0;
+import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import net.fabricmc.fabric.api.client.rendering.v1.EntityRendererRegistry;
+import net.fabricmc.fabric.api.event.player.UseEntityCallback;
+import net.fabricmc.fabric.api.networking.v1.PacketByteBufs;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.render.entity.BipedEntityRenderer;
+import net.minecraft.client.render.entity.model.EntityModelLayers;
+import net.minecraft.client.render.entity.model.PlayerEntityModel;
+import net.minecraft.text.Text;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Identifier;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.function.Consumer;
+
+public class AiCompanionClient implements ClientModInitializer {
+    private static final Identifier DEFAULT_TEXTURE = new Identifier("aicompanion2_0", "textures/entity/skin.png");
+    private static final Identifier TUX_TEXTURE = new Identifier("aicompanion2_0", "textures/entity/tux-mc.png");
+
+    // One session per world load, shared across all right-clicks
+    private static AiChatSession currentSession = null;
+    private static final Deque<Consumer<String>> pendingArchResponses = new ArrayDeque<>();
+
+    @Override
+    public void onInitializeClient() {
+        // Register renderer
+        EntityRendererRegistry.register(Aicompanion2_0.AI_COMPANION, (context) ->
+            new BipedEntityRenderer<AIEntity, PlayerEntityModel<AIEntity>>(
+                context,
+                new PlayerEntityModel<>(context.getPart(EntityModelLayers.PLAYER), false),
+                0.5f
+            ) {
+                @Override
+                public Identifier getTexture(AIEntity entity) {
+                    return entity.isTuxMode() ? TUX_TEXTURE : DEFAULT_TEXTURE;
+                }
+            }
+        );
+
+        // Clear session when leaving a world
+        ClientPlayConnectionEvents.DISCONNECT.register((handler, client) -> {
+            currentSession = null;
+        });
+
+        ClientPlayNetworking.registerGlobalReceiver(Aicompanion2_0.QUESTION_PACKET_ID, (client, handler, buf, responseSender) -> {
+            String question = buf.readString(32767);
+            client.execute(() -> ensureApiKeyAndRun(client, () -> askQuestion(client, question)));
+        });
+
+        ClientPlayNetworking.registerGlobalReceiver(Aicompanion2_0.DELETE_KEY_PACKET_ID, (client, handler, buf, responseSender) -> {
+            client.execute(() -> {
+                currentSession = null;
+
+                try {
+                    boolean deleted = ClientConfig.deleteApiKey();
+                    if (deleted) {
+                        sendChatMessage(client, Text.literal("§6[AI] §fAPI key deleted."));
+                    } else {
+                        sendChatMessage(client, Text.literal("§6[AI] §fno api key deleted: none found"));
+                    }
+                } catch (Exception e) {
+                    String error = e.getMessage() != null ? e.getMessage() : e.getClass().getSimpleName();
+                    sendChatMessage(client, Text.literal("§c[AI] Could not delete API key: " + error));
+                }
+            });
+        });
+
+        ClientPlayNetworking.registerGlobalReceiver(Aicompanion2_0.ARCH_EASTER_EGG_RESPONSE_PACKET_ID, (client, handler, buf, responseSender) -> {
+            String response = buf.readString(32767);
+            client.execute(() -> finishArchEasterEgg(response));
+        });
+
+        // Open chat GUI on right-click
+        UseEntityCallback.EVENT.register((player, world, hand, entity, hitResult) -> {
+            if (world.isClient() && entity instanceof AIEntity) {
+                MinecraftClient client = MinecraftClient.getInstance();
+
+                client.execute(() -> ensureApiKeyAndRun(client, () -> openChatScreen(client)));
+                return ActionResult.SUCCESS;
+            }
+            return ActionResult.PASS;
+        });
+    }
+
+    private static void ensureApiKeyAndRun(MinecraftClient client, Runnable action) {
+        if (!ClientConfig.hasApiKey()) {
+            currentSession = null;
+            client.setScreen(new ApiKeyScreen(() -> {
+                currentSession = null;
+                action.run();
+            }));
+            return;
+        }
+
+        action.run();
+    }
+
+    public static boolean tryTriggerArchEasterEgg(String message, Consumer<String> onResponse) {
+        if (!isArchEasterEggTrigger(message)) {
+            return false;
+        }
+
+        if (!ClientPlayNetworking.canSend(Aicompanion2_0.ARCH_EASTER_EGG_PACKET_ID)) {
+            onResponse.accept("§cError: The server does not support the Arch easter egg.");
+            return true;
+        }
+
+        pendingArchResponses.addLast(onResponse);
+
+        try {
+            ClientPlayNetworking.send(Aicompanion2_0.ARCH_EASTER_EGG_PACKET_ID, PacketByteBufs.create());
+        } catch (RuntimeException e) {
+            pendingArchResponses.pollLast();
+            String error = e.getMessage() != null ? e.getMessage() : e.getClass().getSimpleName();
+            onResponse.accept("§cError: " + error);
+        }
+
+        return true;
+    }
+
+    private static void askQuestion(MinecraftClient client, String question) {
+        sendChatMessage(client, Text.literal("§6[AI] §fThink about: " + question));
+
+        AiChatSession session = new AiChatSession(
+            Aicompanion2_0.getApiBaseUrl(),
+            ClientConfig.getApiKey(),
+            Aicompanion2_0.getModel()
+        );
+
+        session.sendMessage(question, response -> client.execute(() -> {
+            if (response == null || response.isEmpty()) {
+                return;
+            }
+
+            if (response.startsWith("§cError: ")) {
+                String error = response.substring("§cError: ".length());
+                sendChatMessage(client, Text.literal("§c[AI] Error with /ai question: " + error));
+                return;
+            }
+
+            String answer = response;
+            if (answer.length() > 2000) {
+                answer = answer.substring(0, 2000) + "...";
+            }
+
+            sendChatMessage(client, Text.literal("§6[AI] §fAnswer: " + answer));
+        }));
+    }
+
+    private static void sendChatMessage(MinecraftClient client, Text message) {
+        if (client.player != null) {
+            client.player.sendMessage(message, false);
+        }
+    }
+
+    private static boolean isArchEasterEggTrigger(String message) {
+        String normalized = message.trim().replaceAll("\\s+", " ").toLowerCase();
+        return "i use arch btw".equals(normalized)
+            || "sudo".equals(normalized)
+            || normalized.startsWith("sudo ");
+    }
+
+    private static void finishArchEasterEgg(String response) {
+        Consumer<String> callback = pendingArchResponses.pollFirst();
+        if (callback != null) {
+            callback.accept(response);
+        }
+    }
+
+    private static void openChatScreen(MinecraftClient client) {
+        if (currentSession == null) {
+            currentSession = new AiChatSession(
+                Aicompanion2_0.getApiBaseUrl(),
+                ClientConfig.getApiKey(),
+                Aicompanion2_0.getModel()
+            );
+        }
+        client.setScreen(new AiChatScreen(currentSession));
+    }
+}

src/client/java/AiCompanion/aicompanion2_0/client/ApiKeyScreen.java

@@ -0,0 +1,70 @@
+package AiCompanion.aicompanion2_0.client;
+
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.DrawContext;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.gui.widget.ButtonWidget;
+import net.minecraft.client.gui.widget.TextFieldWidget;
+import net.minecraft.text.Text;
+
+public class ApiKeyScreen extends Screen {
+
+    private TextFieldWidget keyField;
+    private final Runnable onSuccess;
+
+    public ApiKeyScreen(Runnable onSuccess) {
+        super(Text.literal("Enter API Key (available on ai.cametendo.org)"));
+        this.onSuccess = onSuccess;
+    }
+
+    @Override
+    protected void init() {
+        keyField = new TextFieldWidget(
+            textRenderer, width / 2 - 150, height / 2 - 10, 300, 20,
+            Text.literal("API Key...")
+        );
+        keyField.setMaxLength(200);
+        keyField.setFocused(true);
+        addDrawableChild(keyField);
+
+        addDrawableChild(ButtonWidget.builder(Text.literal("Confirm"), btn -> confirm())
+            .dimensions(width / 2 - 75, height / 2 + 20, 150, 20)
+            .build()
+        );
+    }
+
+    @Override
+    public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        if (keyCode == 257 || keyCode == 335) { // Enter
+            confirm();
+            return true;
+        }
+        return super.keyPressed(keyCode, scanCode, modifiers);
+    }
+
+    private void confirm() {
+        String key = keyField.getText().trim();
+        if (key.isEmpty()) return;
+
+        ClientConfig.setApiKey(key);
+        MinecraftClient.getInstance().execute(() -> {
+            close();
+            onSuccess.run();
+        });
+    }
+
+    @Override
+    public void render(DrawContext context, int mouseX, int mouseY, float delta) {
+        renderBackground(context);
+        context.drawCenteredTextWithShadow(textRenderer,
+            "§6Please enter your Open WebUI API key:", width / 2, height / 2 - 30, 0xFFFFFF);
+        context.drawCenteredTextWithShadow(textRenderer,
+            "§7(Stored locally, only required once.)", width / 2, height / 2 - 20, 0xAAAAAA);
+        super.render(context, mouseX, mouseY, delta);
+    }
+
+    @Override
+    public boolean shouldPause() {
+        return false;
+    }
+}

src/client/java/AiCompanion/aicompanion2_0/client/ClientConfig.java

@@ -0,0 +1,98 @@
+package AiCompanion.aicompanion2_0.client;
+
+import java.io.*;
+import java.nio.file.*;
+import java.util.Properties;
+
+public class ClientConfig {
+
+    private static final Path CONFIG_PATH = Path.of("config", "aicompanion2_0_client.properties");
+    private static final Path SHARED_CONFIG_PATH = Path.of("config", "aicompanion2_0.properties");
+    private static String apiKey = null;
+
+    public static String getApiKey() {
+        load();
+        return apiKey;
+    }
+
+    public static void setApiKey(String key) {
+        apiKey = key;
+        save();
+    }
+
+    public static boolean deleteApiKey() throws IOException {
+        boolean deleted = deleteApiKeyFrom(SHARED_CONFIG_PATH, "AI Companion Shared Config");
+        deleted = deleteApiKeyFrom(CONFIG_PATH, "AI Companion Client Config") || deleted;
+        apiKey = null;
+        return deleted;
+    }
+
+    public static boolean hasApiKey() {
+        load();
+        return apiKey != null && !apiKey.isBlank();
+    }
+
+    private static void load() {
+        try {
+            // Prefer shared config so GUI and /ai frage use the same key source.
+            apiKey = loadApiKeyFrom(SHARED_CONFIG_PATH);
+            if (apiKey == null || apiKey.isBlank()) {
+                apiKey = loadApiKeyFrom(CONFIG_PATH);
+            }
+        } catch (IOException e) {
+            apiKey = null;
+            System.out.println("[aicompanion2_0] Could not load Client Config.");
+        }
+    }
+
+    private static void save() {
+        try {
+            saveApiKeyTo(CONFIG_PATH, "AI Companion Client Config");
+            saveApiKeyTo(SHARED_CONFIG_PATH, "AI Companion Shared Config");
+        } catch (IOException e) {
+            System.out.println("[aicompanion2_0] Could not save Client Config.");
+        }
+    }
+
+    private static String loadApiKeyFrom(Path path) throws IOException {
+        if (!Files.exists(path)) return null;
+        Properties props = new Properties();
+        try (FileInputStream in = new FileInputStream(path.toFile())) {
+            props.load(in);
+        }
+        return props.getProperty("api.key", null);
+    }
+
+    private static void saveApiKeyTo(Path path, String comment) throws IOException {
+        Files.createDirectories(path.getParent());
+        Properties props = new Properties();
+        if (Files.exists(path)) {
+            try (FileInputStream in = new FileInputStream(path.toFile())) {
+                props.load(in);
+            }
+        }
+        props.setProperty("api.key", apiKey != null ? apiKey : "");
+        try (FileOutputStream out = new FileOutputStream(path.toFile())) {
+            props.store(out, comment);
+        }
+    }
+
+    private static boolean deleteApiKeyFrom(Path path, String comment) throws IOException {
+        if (!Files.exists(path)) return false;
+
+        Properties props = new Properties();
+        try (FileInputStream in = new FileInputStream(path.toFile())) {
+            props.load(in);
+        }
+
+        String existingKey = props.getProperty("api.key", null);
+        if (existingKey == null || existingKey.isBlank()) return false;
+
+        props.remove("api.key");
+        Files.createDirectories(path.getParent());
+        try (FileOutputStream out = new FileOutputStream(path.toFile())) {
+            props.store(out, comment);
+        }
+        return true;
+    }
+}

src/main/java/AiCompanion/aicompanion2_0/AIEntity.java

@@ -0,0 +1,116 @@
+package AiCompanion.aicompanion2_0;
+
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.ai.goal.*;
+import net.minecraft.entity.ai.pathing.MobNavigation;
+import net.minecraft.entity.attribute.DefaultAttributeContainer;
+import net.minecraft.entity.attribute.EntityAttributes;
+import net.minecraft.entity.data.DataTracker;
+import net.minecraft.entity.data.TrackedData;
+import net.minecraft.entity.data.TrackedDataHandlerRegistry;
+import net.minecraft.entity.damage.DamageSource;
+import net.minecraft.entity.passive.PassiveEntity;
+import net.minecraft.entity.passive.TameableEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.text.Text;
+import net.minecraft.world.EntityView;
+import net.minecraft.world.World;
+import org.jetbrains.annotations.Nullable;
+
+public class AIEntity extends TameableEntity {
+    private static final TrackedData<Boolean> TUX_MODE =
+        DataTracker.registerData(AIEntity.class, TrackedDataHandlerRegistry.BOOLEAN);
+    private int tuxTicksRemaining = 0;
+
+    public AIEntity(EntityType<? extends TameableEntity> entityType, World world) {
+        super(entityType, world);
+        this.setInvulnerable(true);
+        this.setCustomName(Text.translatable("entity.aicompanion2_0.ai_companion"));
+        this.setCustomNameVisible(true);
+        // Ensure navigation is set up for following
+        this.navigation = new MobNavigation(this, world);
+    }
+
+    public static DefaultAttributeContainer.Builder createMobAttributes() {
+        return TameableEntity.createMobAttributes()
+            .add(EntityAttributes.GENERIC_MAX_HEALTH, 20.0)
+            .add(EntityAttributes.GENERIC_MOVEMENT_SPEED, 0.3)
+            .add(EntityAttributes.GENERIC_FOLLOW_RANGE, 32.0);
+    }
+
+    @Override
+    protected void initDataTracker() {
+        super.initDataTracker();
+        this.dataTracker.startTracking(TUX_MODE, false);
+    }
+
+    @Override
+    protected void initGoals() {
+        this.goalSelector.add(1, new FollowOwnerGoal(this, 1.0, 5.0f, 2.0f, false));
+        this.goalSelector.add(2, new WanderAroundFarGoal(this, 0.8));
+        this.goalSelector.add(3, new LookAtEntityGoal(this, PlayerEntity.class, 8.0f));
+        this.goalSelector.add(4, new LookAroundGoal(this));
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+
+        if (!this.getWorld().isClient() && tuxTicksRemaining > 0) {
+            tuxTicksRemaining--;
+
+            if (tuxTicksRemaining == 0) {
+                this.dataTracker.set(TUX_MODE, false);
+            }
+        }
+    }
+
+    @Override
+    public boolean damage(DamageSource source, float amount) {
+        // Allow kill command through, block everything else
+        if (source == this.getDamageSources().outOfWorld()) return super.damage(source, amount);
+        return false;
+    }
+
+    @Override
+    public void kill() {
+        super.kill();
+    }
+
+    @Override
+    public Text getName() {
+        return Text.translatable("entity.aicompanion2_0.ai_companion");
+    }
+
+    @Override
+    public Text getDisplayName() {
+        return Text.translatable("entity.aicompanion2_0.ai_companion");
+    }
+
+    @Override
+    public boolean isBreedingItem(ItemStack stack) {
+        return false;
+    }
+
+    @Nullable
+    @Override
+    public PassiveEntity createChild(ServerWorld world, PassiveEntity entity) {
+        return null;
+    }
+
+    public void activateTuxMode(int durationTicks) {
+        tuxTicksRemaining = Math.max(tuxTicksRemaining, durationTicks);
+        this.dataTracker.set(TUX_MODE, true);
+    }
+
+    public boolean isTuxMode() {
+        return this.dataTracker.get(TUX_MODE);
+    }
+
+    // Bridge method fix
+    public EntityView method_48926() {
+        return (EntityView) this.getWorld();
+    }
+}

src/main/java/AiCompanion/aicompanion2_0/Aicompanion2_0.java

@@ -1,77 +1,202 @@
 package AiCompanion.aicompanion2_0;
 
-import net.fabricmc.api.ModInitializer;
-import net.fabricmc.fabric.api.command.v1.CommandRegistrationCallback;
-import net.minecraft.server.command.CommandManager;
-import net.minecraft.text.Text;
-import com.mojang.brigadier.arguments.StringArgumentType;
-
 import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.net.HttpURLConnection;
 import java.net.URL;
-
-import java.io.FileInputStream;
-import java.io.IOException;
 import java.nio.file.Path;
+import java.nio.file.Files;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Properties;
+import java.util.UUID;
 
+import com.mojang.brigadier.arguments.StringArgumentType;
+
+import net.fabricmc.api.ModInitializer;
+import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
+import net.fabricmc.fabric.api.networking.v1.PacketByteBufs;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
+import net.fabricmc.fabric.api.object.builder.v1.entity.FabricDefaultAttributeRegistry;
+import net.fabricmc.fabric.api.object.builder.v1.entity.FabricEntityTypeBuilder;
+import net.minecraft.entity.EntityDimensions;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.SpawnGroup;
+import net.minecraft.entity.effect.StatusEffectInstance;
+import net.minecraft.entity.effect.StatusEffects;
+import net.minecraft.registry.Registries;
+import net.minecraft.registry.Registry;
+import net.minecraft.server.command.CommandManager;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.text.Text;
+import net.minecraft.util.Identifier;
 
 public class Aicompanion2_0 implements ModInitializer {
 
     public static final String MOD_ID = "aicompanion2_0";
-    private static String API_BASE_URL = "http://ollama.cametendo.org";
-    private static String API_PATH = "/api/generate";
+    private static final String DEFAULT_API_BASE_URL = "https://ai.cametendo.org";
+    private static final String DEFAULT_MODEL = "minecraft-helper";
+    private static final String DEFAULT_API_PATH = "/api/chat/completions";
+    private static String API_BASE_URL = DEFAULT_API_BASE_URL;
+    private static String MODEL = DEFAULT_MODEL;
+    private static String API_KEY = "";
+    private static String API_PATH = DEFAULT_API_PATH;
+    private static final Path SHARED_CONFIG_PATH = Path.of("config", "aicompanion2_0.properties");
+    private static final Path CLIENT_CONFIG_PATH = Path.of("config", "aicompanion2_0_client.properties");
+    private static final long ARCH_EASTER_EGG_COOLDOWN_MS = 15L * 60L * 1000L;
+    private static final int ARCH_EASTER_EGG_BUFF_DURATION_TICKS = 20 * 60;
+    private static final int ARCH_EASTER_EGG_TUX_DURATION_TICKS = 20 * 10;
+    private static final Map<UUID, Long> ARCH_EASTER_EGG_LAST_USED = new HashMap<>();
+    public static final Identifier QUESTION_PACKET_ID = new Identifier(MOD_ID, "question");
+    public static final Identifier DELETE_KEY_PACKET_ID = new Identifier(MOD_ID, "delete_key");
+    public static final Identifier ARCH_EASTER_EGG_PACKET_ID = new Identifier(MOD_ID, "arch_easter_egg");
+    public static final Identifier ARCH_EASTER_EGG_RESPONSE_PACKET_ID = new Identifier(MOD_ID, "arch_easter_egg_response");
+
+    public static final EntityType<AIEntity> AI_COMPANION = Registry.register(
+            Registries.ENTITY_TYPE,
+            new Identifier(MOD_ID, "ai_companion"),
+            FabricEntityTypeBuilder.create(SpawnGroup.CREATURE, AIEntity::new)
+                    .dimensions(EntityDimensions.fixed(0.6f, 1.8f))
+                    .build()
+    );
+
+    // Static getters used by the client side
+    public static String getApiBaseUrl() { return API_BASE_URL; }
+    public static String getModel() { return MODEL; }
 
     @Override
     public void onInitialize() {
+        loadConfig();
         System.out.println("[" + MOD_ID + "] MOD STARTET!");
 
-        CommandRegistrationCallback.EVENT.register((dispatcher, dedicated) -> {
+        FabricDefaultAttributeRegistry.register(AI_COMPANION, AIEntity.createMobAttributes());
+        ServerPlayNetworking.registerGlobalReceiver(ARCH_EASTER_EGG_PACKET_ID, (server, player, handler, buf, responseSender) ->
+            server.execute(() -> sendArchEasterEggResponse(player))
+        );
+
+        CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> {
             System.out.println("[" + MOD_ID + "] Registriere /ai command");
 
             dispatcher.register(
                 CommandManager.literal("ai")
-                            .then(CommandManager.argument("frage", StringArgumentType.greedyString())
+                    // /ai spawn
+                    .then(CommandManager.literal("spawn")
                         .executes(ctx -> {
                             var player = ctx.getSource().getPlayer();
-                                        String frage = StringArgumentType.getString(ctx, "frage");
-
                             if (player != null) {
-                                            player.sendMessage(
-                                                    Text.literal("§6[AI] §fDenke nach über: " + frage),
-                                                    false
-                                            );
+                                AIEntity companion = new AIEntity(AI_COMPANION, player.getWorld());
+                                companion.refreshPositionAndAngles(player.getX(), player.getY(), player.getZ(), 0, 0);
+                                companion.setOwner(player);
+                                companion.setTamed(true);
+                                player.getWorld().spawnEntity(companion);
+                                player.sendMessage(Text.literal("§6[AI] §fThe companion has been called!"), false);
+                            }
+                            return 1;
+                        })
+                    )
+                    // /ai kill
+                    .then(CommandManager.literal("kill")
+                        .executes(ctx -> {
+                            var server = ctx.getSource().getServer();
+                            int removed = 0;
+
+                            for (var world : server.getWorlds()) {
+                                var companions = world.getEntitiesByType(AI_COMPANION, entity -> true);
+                                for (var companion : companions) {
+                                    // Force-remove companion even when invulnerable.
+                                    companion.discard();
+                                    removed++;
+                                }
+                            }
+
+                            final int removedCount = removed;
+                            ctx.getSource().sendFeedback(
+                                () -> Text.literal("§6[AI] §fCompanion removed: " + removedCount), false);
+                            return 1;
+                        })
+                    )
+                    // /ai delete-key
+                    .then(CommandManager.literal("delete-key")
+                        .executes(ctx -> {
+                            var player = ctx.getSource().getPlayer();
+                            if (player != null) {
+                                if (!ServerPlayNetworking.canSend(player, DELETE_KEY_PACKET_ID)) {
+                                    ctx.getSource().sendFeedback(
+                                        () -> Text.literal("§c[AI] delete-key requires the AI Companion client mod."), false);
+                                    return 0;
+                                }
+
+                                ServerPlayNetworking.send(player, DELETE_KEY_PACKET_ID, PacketByteBufs.create());
+                                return 1;
+                            }
+
+                            try {
+                                boolean deleted = deleteStoredApiKey();
+                                if (deleted) {
+                                    ctx.getSource().sendFeedback(
+                                        () -> Text.literal("§6[AI] §fAPI key deleted."), false);
+                                } else {
+                                    ctx.getSource().sendFeedback(
+                                        () -> Text.literal("§6[AI] §fno api key deleted: none found"), false);
+                                }
+                                return 1;
+                            } catch (IOException e) {
+                                String error = e.getMessage() != null ? e.getMessage() : e.getClass().getSimpleName();
+                                ctx.getSource().sendFeedback(
+                                    () -> Text.literal("§c[AI] Could not delete API key: " + error), false);
+                                return 0;
+                            }
+                        })
+                    )
+                    // /ai question <question>
+                    .then(CommandManager.literal("question")
+                        .then(CommandManager.argument("question", StringArgumentType.greedyString())
+                            .executes(ctx -> {
+                                var player = ctx.getSource().getPlayer();
+                                var server = ctx.getSource().getServer();
+                                String frage = StringArgumentType.getString(ctx, "question");
+
+                                if (player != null) {
+                                    if (!ServerPlayNetworking.canSend(player, QUESTION_PACKET_ID)) {
+                                        ctx.getSource().sendFeedback(
+                                            () -> Text.literal("§c[AI] question requires the AI Companion client mod."), false);
+                                        return 0;
+                                    }
+
+                                    var buf = PacketByteBufs.create();
+                                    buf.writeString(frage);
+                                    ServerPlayNetworking.send(player, QUESTION_PACKET_ID, buf);
+                                    return 1;
                                 }
 
-                                        // KI‑Request in neuem Thread, damit der Server nicht hängt
                                 new Thread(() -> {
                                     try {
                                         String antwort = callOllama(frage);
-                                                if (antwort == null || antwort.isEmpty()) {
-                                                    return;
-                                                }
-
-                                                // Antwort etwas kürzen, damit der Chat nicht explodiert
-                                                if (antwort.length() > 2000) {
-                                                    antwort = antwort.substring(0, 2000) + "...";
-                                                }
-
+                                        if (antwort == null || antwort.isEmpty()) return;
+                                        if (antwort.length() > 2000) antwort = antwort.substring(0, 2000) + "...";
                                         if (player != null) {
-                                                    player.sendMessage(
-                                                            Text.literal("§6[AI] §fAntwort: " + antwort),
-                                                            false
-                                                    );
+                                            String finalAntwort = antwort;
+                                            server.execute(() -> player.sendMessage(
+                                                Text.literal("§6[AI] §fAnswer: " + finalAntwort), false));
                                         }
                                     } catch (Exception e) {
                                         e.printStackTrace();
+                                        if (player != null) {
+                                            String error = e.getMessage() != null ? e.getMessage() : e.getClass().getSimpleName();
+                                            server.execute(() -> player.sendMessage(
+                                                Text.literal("§c[AI] Error with /ai question: " + error), false));
+                                        }
                                     }
                                 }).start();
 
                                 return 1;
                             })
                         )
+                    )
             );
         });
 
@@ -81,59 +206,209 @@ public class Aicompanion2_0 implements ModInitializer {
     // Innerhalb deiner Klasse Aicompanion2_0
 
     private String callOllama(String prompt) throws Exception {
-        URL url = new URL(API_BASE_URL + API_PATH);
+        loadConfig();
+
+        String apiBaseUrl = API_BASE_URL;
+        String apiPath = API_PATH;
+        String model = MODEL;
+        String apiKey = API_KEY;
+
+        String json = "{\"model\":\"" + jsonEscape(model) + "\",\"messages\":[{\"role\":\"user\",\"content\":\""
+            + jsonEscape(prompt) + "\"}],\"stream\":false}";
+
+        HttpResult primary = postChatCompletion(apiBaseUrl, apiPath, apiKey, json);
+        if (primary.status == 200) {
+            return extractAssistantContent(primary.body);
+        }
+
+        // Some deployments expose OpenAI-compatible chat under /v1/chat/completions.
+        if ((primary.status >= 500 || primary.status == 404) && !"/v1/chat/completions".equals(apiPath)) {
+            HttpResult fallback = postChatCompletion(apiBaseUrl, "/v1/chat/completions", apiKey, json);
+            if (fallback.status == 200) {
+                return extractAssistantContent(fallback.body);
+            }
+            return formatHttpError(fallback.status, fallback.body, "/v1/chat/completions");
+        }
+
+        return formatHttpError(primary.status, primary.body, apiPath);
+    }
+
+    private HttpResult postChatCompletion(String apiBaseUrl, String path, String apiKey, String json) throws Exception {
+        URL url = new URL(apiBaseUrl + path);
         HttpURLConnection conn = (HttpURLConnection) url.openConnection();
         conn.setRequestMethod("POST");
         conn.setRequestProperty("Content-Type", "application/json; charset=utf-8");
+        if (apiKey != null && !apiKey.isBlank()) {
+            conn.setRequestProperty("Authorization", "Bearer " + apiKey);
+        }
         conn.setDoOutput(true);
 
-        // WICHTIG: "stream": false hinzugefügt
-        String json = """
-                {
-                "model": "gpt-oss:20b",
-                "prompt": "%s",
-                "stream": false
-                }
-                """.formatted(prompt.replace("\"", "\\\""));
-
         try (OutputStream os = conn.getOutputStream()) {
-            byte[] input = json.getBytes("utf-8");
-            os.write(input, 0, input.length);
+            os.write(json.getBytes("utf-8"));
         }
 
-        if (conn.getResponseCode() != 200) return "Fehler: " + conn.getResponseCode();
+        int status = conn.getResponseCode();
+        String body = readResponseBody(conn, status >= 400);
+        conn.disconnect();
+        return new HttpResult(status, body);
+    }
+
+    private String extractAssistantContent(String body) {
+        int idx = body.indexOf("\"content\":\"");
+        if (idx >= 0) {
+            int start = idx + 11;
+            int end = body.indexOf("\"", start);
+            while (end > 0 && body.charAt(end - 1) == '\\') end = body.indexOf("\"", end + 1);
+            return body.substring(start, end).replace("\\n", "\n").replace("\\\"", "\"");
+        }
+        return body;
+    }
+
+    private String formatHttpError(int status, String body, String path) {
+        if (body == null || body.isBlank()) {
+            return "Fehler: HTTP " + status + " (" + path + ")";
+        }
+        return "Fehler: HTTP " + status + " (" + path + ") - " + body;
+    }
+
+    private String readResponseBody(HttpURLConnection conn, boolean error) throws IOException {
+        var stream = error ? conn.getErrorStream() : conn.getInputStream();
+        if (stream == null) return "";
 
         StringBuilder resp = new StringBuilder();
-        try (BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"))) {
+        try (BufferedReader br = new BufferedReader(new InputStreamReader(stream, "utf-8"))) {
             String line;
-            while ((line = br.readLine()) != null) {
-                resp.append(line);
+            while ((line = br.readLine()) != null) resp.append(line);
         }
-        }
-        conn.disconnect();
-
-        // Primitives Parsing der Antwort (ohne externe Library)
-        String fullResponse = resp.toString();
-        if (fullResponse.contains("\"response\":\"")) {
-            int start = fullResponse.indexOf("\"response\":\"") + 12;
-            int end = fullResponse.indexOf("\"", start);
-            return fullResponse.substring(start, end);
+        return resp.toString();
     }
 
-        return fullResponse;
+    private String jsonEscape(String value) {
+        if (value == null) return "";
+        String escaped = value.replace("\\", "\\\\")
+            .replace("\"", "\\\"")
+            .replace("\n", "\\n")
+            .replace("\r", "\\r")
+            .replace("\t", "\\t");
+        return escaped;
     }
 
-private void loadConfig() {
+    private static class HttpResult {
+        private final int status;
+        private final String body;
+
+        private HttpResult(int status, String body) {
+            this.status = status;
+            this.body = body;
+        }
+    }
+
+    private synchronized void loadConfig() {
+        API_BASE_URL = DEFAULT_API_BASE_URL;
+        API_PATH = DEFAULT_API_PATH;
+        MODEL = DEFAULT_MODEL;
+        API_KEY = "";
+
         try {
-        Path configPath = Path.of("config", "aicompanion2_0.properties");
+            if (Files.exists(SHARED_CONFIG_PATH)) {
+                Properties props = new Properties();
+                try (FileInputStream in = new FileInputStream(SHARED_CONFIG_PATH.toFile())) {
+                    props.load(in);
+                }
+                API_BASE_URL = props.getProperty("api.baseUrl", DEFAULT_API_BASE_URL);
+                API_PATH     = props.getProperty("api.path", DEFAULT_API_PATH);
+                MODEL        = props.getProperty("api.model", DEFAULT_MODEL);
+                API_KEY      = props.getProperty("api.key", "").trim();
+            }
+
+            if (API_KEY == null || API_KEY.isBlank()) {
+                String clientFallbackKey = readApiKeyFrom(CLIENT_CONFIG_PATH);
+                if (clientFallbackKey != null && !clientFallbackKey.isBlank()) {
+                    API_KEY = clientFallbackKey;
+                }
+            }
+        } catch (IOException e) {
+            System.out.println("[" + MOD_ID + "] Could not reload config, using defaults.");
+        }
+    }
+
+    private boolean deleteStoredApiKey() throws IOException {
+        boolean deleted = deleteApiKeyFrom(SHARED_CONFIG_PATH, "AI Companion Shared Config");
+        deleted = deleteApiKeyFrom(CLIENT_CONFIG_PATH, "AI Companion Client Config") || deleted;
+        API_KEY = "";
+        return deleted;
+    }
+
+    private String readApiKeyFrom(Path configPath) throws IOException {
+        if (!Files.exists(configPath)) return null;
         Properties props = new Properties();
         try (FileInputStream in = new FileInputStream(configPath.toFile())) {
             props.load(in);
         }
-        API_BASE_URL = props.getProperty("api.baseUrl", API_BASE_URL);
-        API_PATH = props.getProperty("api.path", API_PATH);
-    } catch (IOException e) {
-        System.out.println("[" + MOD_ID + "] Keine Config gefunden, benutze Default-API.");
+        return props.getProperty("api.key", null);
+    }
+
+    private boolean deleteApiKeyFrom(Path configPath, String comment) throws IOException {
+        if (!Files.exists(configPath)) return false;
+
+        Properties props = new Properties();
+        try (FileInputStream in = new FileInputStream(configPath.toFile())) {
+            props.load(in);
+        }
+
+        String existingKey = props.getProperty("api.key", null);
+        if (existingKey == null || existingKey.isBlank()) return false;
+
+        props.remove("api.key");
+        Files.createDirectories(configPath.getParent());
+        try (OutputStream out = Files.newOutputStream(configPath)) {
+            props.store(out, comment);
+        }
+        return true;
+    }
+
+    private void sendArchEasterEggResponse(ServerPlayerEntity player) {
+        if (!ServerPlayNetworking.canSend(player, ARCH_EASTER_EGG_RESPONSE_PACKET_ID)) {
+            return;
+        }
+
+        String response = triggerArchEasterEgg(player);
+        var buf = PacketByteBufs.create();
+        buf.writeString(response);
+        ServerPlayNetworking.send(player, ARCH_EASTER_EGG_RESPONSE_PACKET_ID, buf);
+    }
+
+    private String triggerArchEasterEgg(ServerPlayerEntity player) {
+        long now = System.currentTimeMillis();
+        Long lastUsed = ARCH_EASTER_EGG_LAST_USED.get(player.getUuid());
+
+        if (lastUsed != null) {
+            long remainingMs = ARCH_EASTER_EGG_COOLDOWN_MS - (now - lastUsed);
+            if (remainingMs > 0) {
+                return "Optimization already complete. Cooldown remaining: " + formatCooldown(remainingMs) + ".";
+            }
+        }
+
+        ARCH_EASTER_EGG_LAST_USED.put(player.getUuid(), now);
+        player.addStatusEffect(new StatusEffectInstance(StatusEffects.SPEED, ARCH_EASTER_EGG_BUFF_DURATION_TICKS, 1));
+        player.addStatusEffect(new StatusEffectInstance(StatusEffects.HASTE, ARCH_EASTER_EGG_BUFF_DURATION_TICKS, 1));
+        activateTuxModeForOwnedCompanions(player);
+        return "Optimization complete. Bloatware removed.";
+    }
+
+    private void activateTuxModeForOwnedCompanions(ServerPlayerEntity player) {
+        for (ServerWorld world : player.getServer().getWorlds()) {
+            for (AIEntity companion : world.getEntitiesByType(AI_COMPANION, entity ->
+                player.getUuid().equals(entity.getOwnerUuid()))) {
+                companion.activateTuxMode(ARCH_EASTER_EGG_TUX_DURATION_TICKS);
             }
         }
     }
+
+    private String formatCooldown(long remainingMs) {
+        long totalSeconds = Math.max(1, (remainingMs + 999) / 1000);
+        long minutes = totalSeconds / 60;
+        long seconds = totalSeconds % 60;
+        return minutes + "m " + seconds + "s";
+    }
+}

src/main/resources/aicompanion2_0.mixins.json

@@ -0,0 +1,10 @@
+{
+  "required": true,
+  "minVersion": "0.8",
+  "package": "AiCompanion.aicompanion2_0.mixin",
+  "compatibilityLevel": "JAVA_17",
+  "mixins": [],
+  "injectors": {
+    "defaultRequire": 1
+  }
+}

src/main/resources/assets/aicompanion2_0/lang/de_de.json

@@ -0,0 +1 @@
+{"entity.aicompanion2_0.ai_companion": "KI-Begleiter"}

src/main/resources/assets/aicompanion2_0/lang/en_us.json

@@ -0,0 +1 @@
+{"entity.aicompanion2_0.ai_companion": "AI-Companion"}

src/main/resources/fabric.mod.json

@@ -12,9 +12,14 @@
   "entrypoints": {
     "main": [
       "AiCompanion.aicompanion2_0.Aicompanion2_0"
+    ],
+    "client": [
+      "AiCompanion.aicompanion2_0.client.AiCompanionClient"
     ]
   },
-  "mixins": [],
+  "mixins": [
+    "aicompanion2_0.mixins.json"
+  ],
   "depends": {
     "fabricloader": ">=0.14.0",
     "fabric-api": "*",