@office-agents/sdk 0.0.1

package/dist/runtime.js

@@ -0,0 +1,688 @@
+import { Agent, } from "@mariozechner/pi-agent-core";
+import { getModel, getModels, getProviders, streamSimple, } from "@mariozechner/pi-ai";
+import { agentMessagesToChatMessages, deriveStats, extractPartsFromAssistantMessage, generateId, } from "./message-utils";
+import { loadOAuthCredentials, refreshOAuthToken, saveOAuthCredentials, } from "./oauth";
+import { applyProxyToModel, buildCustomModel, loadSavedConfig, saveConfig, } from "./provider-config";
+import { addSkill, getInstalledSkills, removeSkill, syncSkillsToVfs, } from "./skills";
+import { createSession, deleteSession, getOrCreateCurrentSession, getSession, listSessions, loadVfsFiles, saveSession, saveVfsFiles, } from "./storage";
+import { deleteFile, listUploads, resetVfs, restoreVfs, setCustomCommands, setStaticFiles, snapshotVfs, writeFile, } from "./vfs";
+const INITIAL_STATS = { ...deriveStats([]), contextWindow: 0 };
+function thinkingLevelToAgent(level) {
+    return level === "none" ? "off" : level;
+}
+export class AgentRuntime {
+    constructor(adapter) {
+        this.agent = null;
+        this.config = null;
+        this.pendingConfig = null;
+        this.streamingMessageId = null;
+        this.isStreaming = false;
+        this.documentId = null;
+        this.currentSessionId = null;
+        this.sessionLoaded = false;
+        this.followMode = true;
+        this.skills = [];
+        this.listeners = new Set();
+        this.handleAgentEvent = (event) => {
+            console.log("[Runtime] Agent event:", event.type, event);
+            switch (event.type) {
+                case "message_start": {
+                    if (event.message.role === "assistant") {
+                        const id = generateId();
+                        this.streamingMessageId = id;
+                        const parts = extractPartsFromAssistantMessage(event.message);
+                        const chatMessage = {
+                            id,
+                            role: "assistant",
+                            parts,
+                            timestamp: event.message.timestamp,
+                        };
+                        this.updateMessages((msgs) => [...msgs, chatMessage]);
+                    }
+                    break;
+                }
+                case "message_update": {
+                    if (event.message.role === "assistant" && this.streamingMessageId) {
+                        const streamId = this.streamingMessageId;
+                        this.updateMessages((msgs) => {
+                            const messages = [...msgs];
+                            const idx = messages.findIndex((m) => m.id === streamId);
+                            if (idx !== -1) {
+                                const parts = extractPartsFromAssistantMessage(event.message, messages[idx].parts);
+                                messages[idx] = { ...messages[idx], parts };
+                            }
+                            return messages;
+                        });
+                    }
+                    break;
+                }
+                case "message_end": {
+                    if (event.message.role === "assistant") {
+                        const assistantMsg = event.message;
+                        const isError = assistantMsg.stopReason === "error" ||
+                            assistantMsg.stopReason === "aborted";
+                        const streamId = this.streamingMessageId;
+                        this.updateMessages((msgs) => {
+                            const messages = [...msgs];
+                            const idx = messages.findIndex((m) => m.id === streamId);
+                            if (isError) {
+                                if (idx !== -1) {
+                                    messages.splice(idx, 1);
+                                }
+                            }
+                            else if (idx !== -1) {
+                                const parts = extractPartsFromAssistantMessage(event.message, messages[idx].parts);
+                                messages[idx] = { ...messages[idx], parts };
+                            }
+                            return messages;
+                        }, {
+                            error: isError
+                                ? assistantMsg.errorMessage || "Request failed"
+                                : this.state.error,
+                            sessionStats: isError
+                                ? this.state.sessionStats
+                                : {
+                                    ...deriveStats(this.agent?.state.messages ?? []),
+                                    contextWindow: this.state.sessionStats.contextWindow,
+                                },
+                        });
+                        this.streamingMessageId = null;
+                    }
+                    break;
+                }
+                case "tool_execution_start": {
+                    this.updateMessages((msgs) => {
+                        const messages = [...msgs];
+                        for (let i = messages.length - 1; i >= 0; i--) {
+                            const msg = messages[i];
+                            const partIdx = msg.parts.findIndex((p) => p.type === "toolCall" && p.id === event.toolCallId);
+                            if (partIdx !== -1) {
+                                const parts = [...msg.parts];
+                                const part = parts[partIdx];
+                                if (part.type === "toolCall") {
+                                    parts[partIdx] = { ...part, status: "running" };
+                                    messages[i] = { ...msg, parts };
+                                }
+                                break;
+                            }
+                        }
+                        return messages;
+                    });
+                    break;
+                }
+                case "tool_execution_update": {
+                    this.updateMessages((msgs) => {
+                        const messages = [...msgs];
+                        for (let i = messages.length - 1; i >= 0; i--) {
+                            const msg = messages[i];
+                            const partIdx = msg.parts.findIndex((p) => p.type === "toolCall" && p.id === event.toolCallId);
+                            if (partIdx !== -1) {
+                                const parts = [...msg.parts];
+                                const part = parts[partIdx];
+                                if (part.type === "toolCall") {
+                                    let partialText;
+                                    if (typeof event.partialResult === "string") {
+                                        partialText = event.partialResult;
+                                    }
+                                    else if (event.partialResult?.content &&
+                                        Array.isArray(event.partialResult.content)) {
+                                        partialText = event.partialResult.content
+                                            .filter((c) => c.type === "text")
+                                            .map((c) => c.text)
+                                            .join("\n");
+                                    }
+                                    else {
+                                        partialText = JSON.stringify(event.partialResult, null, 2);
+                                    }
+                                    parts[partIdx] = { ...part, result: partialText };
+                                    messages[i] = { ...msg, parts };
+                                }
+                                break;
+                            }
+                        }
+                        return messages;
+                    });
+                    break;
+                }
+                case "tool_execution_end": {
+                    let resultText;
+                    let resultImages;
+                    if (typeof event.result === "string") {
+                        resultText = event.result;
+                    }
+                    else if (event.result?.content &&
+                        Array.isArray(event.result.content)) {
+                        resultText = event.result.content
+                            .filter((c) => c.type === "text")
+                            .map((c) => c.text)
+                            .join("\n");
+                        const images = event.result.content
+                            .filter((c) => c.type === "image")
+                            .map((c) => ({
+                            data: c.data,
+                            mimeType: c.mimeType,
+                        }));
+                        if (images.length > 0)
+                            resultImages = images;
+                    }
+                    else {
+                        resultText = JSON.stringify(event.result, null, 2);
+                    }
+                    if (!event.isError && this.followMode) {
+                        this.adapter.onToolResult?.(event.toolCallId, resultText, false);
+                    }
+                    this.updateMessages((msgs) => {
+                        const messages = [...msgs];
+                        for (let i = messages.length - 1; i >= 0; i--) {
+                            const msg = messages[i];
+                            const partIdx = msg.parts.findIndex((p) => p.type === "toolCall" && p.id === event.toolCallId);
+                            if (partIdx !== -1) {
+                                const parts = [...msg.parts];
+                                const part = parts[partIdx];
+                                if (part.type === "toolCall") {
+                                    parts[partIdx] = {
+                                        ...part,
+                                        status: event.isError ? "error" : "complete",
+                                        result: resultText,
+                                        images: resultImages,
+                                    };
+                                    messages[i] = { ...msg, parts };
+                                }
+                                break;
+                            }
+                        }
+                        return messages;
+                    });
+                    break;
+                }
+                case "agent_end": {
+                    this.isStreaming = false;
+                    this.streamingMessageId = null;
+                    this.update({ isStreaming: false });
+                    this.onStreamingEnd();
+                    break;
+                }
+            }
+        };
+        this.adapter = adapter;
+        const saved = loadSavedConfig();
+        const validConfig = saved?.provider && saved?.apiKey && saved?.model ? saved : null;
+        this.followMode = validConfig?.followMode ?? true;
+        this.state = {
+            messages: [],
+            isStreaming: false,
+            error: null,
+            providerConfig: validConfig,
+            sessionStats: INITIAL_STATS,
+            currentSession: null,
+            sessions: [],
+            nameMap: {},
+            uploads: [],
+            isUploading: false,
+            skills: [],
+        };
+    }
+    getState() {
+        return this.state;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    emit() {
+        for (const listener of this.listeners) {
+            listener(this.state);
+        }
+    }
+    update(partial) {
+        this.state = { ...this.state, ...partial };
+        this.emit();
+    }
+    updateMessages(updater, extra) {
+        this.state = {
+            ...this.state,
+            messages: updater(this.state.messages),
+            ...extra,
+        };
+        this.emit();
+    }
+    setAdapter(adapter) {
+        this.adapter = adapter;
+    }
+    getAvailableProviders() {
+        return getProviders();
+    }
+    getModelsForProvider(provider) {
+        try {
+            return getModels(provider);
+        }
+        catch {
+            return [];
+        }
+    }
+    async getActiveApiKey(config) {
+        if (config.authMethod !== "oauth") {
+            return config.apiKey;
+        }
+        const creds = loadOAuthCredentials(config.provider);
+        if (!creds)
+            return config.apiKey;
+        if (Date.now() < creds.expires) {
+            return creds.access;
+        }
+        const refreshed = await refreshOAuthToken(config.provider, creds.refresh, config.proxyUrl, config.useProxy);
+        saveOAuthCredentials(config.provider, refreshed);
+        return refreshed.access;
+    }
+    applyConfig(config) {
+        let contextWindow = 0;
+        let baseModel;
+        if (config.provider === "custom") {
+            const custom = buildCustomModel(config);
+            if (!custom)
+                return;
+            baseModel = custom;
+        }
+        else {
+            try {
+                baseModel = getModel(config.provider, config.model);
+            }
+            catch {
+                return;
+            }
+        }
+        contextWindow = baseModel.contextWindow;
+        this.config = config;
+        const proxiedModel = applyProxyToModel(baseModel, config);
+        const existingMessages = this.agent?.state.messages ?? [];
+        if (this.agent) {
+            this.agent.abort();
+        }
+        const systemPrompt = this.adapter.buildSystemPrompt(this.skills);
+        const agent = new Agent({
+            initialState: {
+                model: proxiedModel,
+                systemPrompt,
+                thinkingLevel: thinkingLevelToAgent(config.thinking),
+                tools: this.adapter.tools,
+                messages: existingMessages,
+            },
+            streamFn: async (model, context, options) => {
+                const cfg = this.config ?? config;
+                const apiKey = await this.getActiveApiKey(cfg);
+                return streamSimple(model, context, {
+                    ...options,
+                    apiKey,
+                });
+            },
+        });
+        this.agent = agent;
+        agent.subscribe(this.handleAgentEvent);
+        this.pendingConfig = null;
+        this.followMode = config.followMode ?? true;
+        this.update({
+            providerConfig: config,
+            error: null,
+            sessionStats: {
+                ...this.state.sessionStats,
+                contextWindow,
+            },
+        });
+    }
+    setProviderConfig(config) {
+        if (this.isStreaming) {
+            this.pendingConfig = config;
+            this.update({ providerConfig: config });
+            return;
+        }
+        this.applyConfig(config);
+    }
+    abort() {
+        this.agent?.abort();
+        this.isStreaming = false;
+        this.update({ isStreaming: false });
+    }
+    async sendMessage(content, attachments) {
+        if (this.pendingConfig) {
+            this.applyConfig(this.pendingConfig);
+        }
+        const agent = this.agent;
+        if (!agent || !this.state.providerConfig) {
+            this.update({ error: "Please configure your API key first" });
+            return;
+        }
+        const userMessage = {
+            id: generateId(),
+            role: "user",
+            parts: [{ type: "text", text: content }],
+            timestamp: Date.now(),
+        };
+        this.isStreaming = true;
+        this.update({
+            messages: [...this.state.messages, userMessage],
+            isStreaming: true,
+            error: null,
+        });
+        try {
+            let promptContent = content;
+            if (this.adapter.getDocumentMetadata) {
+                try {
+                    const meta = await this.adapter.getDocumentMetadata();
+                    if (meta) {
+                        const tag = this.adapter.metadataTag || "doc_context";
+                        promptContent = `<${tag}>\n${JSON.stringify(meta.metadata, null, 2)}\n</${tag}>\n\n${content}`;
+                        if (meta.nameMap) {
+                            this.update({ nameMap: meta.nameMap });
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error("[Runtime] Failed to get document metadata:", err);
+                }
+            }
+            if (attachments && attachments.length > 0) {
+                const paths = attachments
+                    .map((name) => `/home/user/uploads/${name}`)
+                    .join("\n");
+                promptContent = `<attachments>\n${paths}\n</attachments>\n\n${promptContent}`;
+            }
+            await agent.prompt(promptContent);
+        }
+        catch (err) {
+            console.error("[Runtime] sendMessage error:", err);
+            this.isStreaming = false;
+            this.update({
+                isStreaming: false,
+                error: err instanceof Error ? err.message : "An error occurred",
+            });
+        }
+    }
+    clearMessages() {
+        this.abort();
+        this.agent?.reset();
+        resetVfs();
+        if (this.currentSessionId) {
+            Promise.all([
+                saveSession(this.currentSessionId, []),
+                saveVfsFiles(this.currentSessionId, []),
+            ]).catch(console.error);
+        }
+        this.update({
+            messages: [],
+            error: null,
+            sessionStats: INITIAL_STATS,
+            uploads: [],
+        });
+    }
+    async refreshSessions() {
+        if (!this.documentId)
+            return;
+        const sessions = await listSessions(this.documentId);
+        this.update({ sessions });
+    }
+    async newSession() {
+        if (!this.documentId)
+            return;
+        if (this.isStreaming)
+            return;
+        try {
+            this.agent?.reset();
+            resetVfs();
+            const session = await createSession(this.documentId);
+            this.currentSessionId = session.id;
+            await this.refreshSessions();
+            this.update({
+                messages: [],
+                currentSession: session,
+                error: null,
+                sessionStats: INITIAL_STATS,
+                uploads: [],
+            });
+        }
+        catch (err) {
+            console.error("[Runtime] Failed to create session:", err);
+        }
+    }
+    async switchSession(sessionId) {
+        if (this.currentSessionId === sessionId)
+            return;
+        if (this.isStreaming)
+            return;
+        this.agent?.reset();
+        try {
+            const [session, vfsFiles] = await Promise.all([
+                getSession(sessionId),
+                loadVfsFiles(sessionId),
+            ]);
+            if (!session)
+                return;
+            await restoreVfs(vfsFiles);
+            this.currentSessionId = session.id;
+            if (session.agentMessages.length > 0 && this.agent) {
+                this.agent.replaceMessages(session.agentMessages);
+            }
+            const uploadNames = await listUploads();
+            const stats = deriveStats(session.agentMessages);
+            this.update({
+                messages: agentMessagesToChatMessages(session.agentMessages, this.adapter.metadataTag),
+                currentSession: session,
+                error: null,
+                sessionStats: {
+                    ...stats,
+                    contextWindow: this.state.sessionStats.contextWindow,
+                },
+                uploads: uploadNames.map((name) => ({ name, size: 0 })),
+            });
+        }
+        catch (err) {
+            console.error("[Runtime] Failed to switch session:", err);
+        }
+    }
+    async deleteCurrentSession() {
+        if (!this.currentSessionId || !this.documentId)
+            return;
+        if (this.isStreaming)
+            return;
+        this.agent?.reset();
+        const deletedId = this.currentSessionId;
+        await Promise.all([deleteSession(deletedId), saveVfsFiles(deletedId, [])]);
+        const session = await getOrCreateCurrentSession(this.documentId);
+        this.currentSessionId = session.id;
+        const vfsFiles = await loadVfsFiles(session.id);
+        await restoreVfs(vfsFiles);
+        if (session.agentMessages.length > 0 && this.agent) {
+            this.agent.replaceMessages(session.agentMessages);
+        }
+        await this.refreshSessions();
+        const uploadNames = await listUploads();
+        const stats = deriveStats(session.agentMessages);
+        this.update({
+            messages: agentMessagesToChatMessages(session.agentMessages, this.adapter.metadataTag),
+            currentSession: session,
+            error: null,
+            sessionStats: {
+                ...stats,
+                contextWindow: this.state.sessionStats.contextWindow,
+            },
+            uploads: uploadNames.map((name) => ({ name, size: 0 })),
+        });
+    }
+    async onStreamingEnd() {
+        if (!this.currentSessionId)
+            return;
+        const sessionId = this.currentSessionId;
+        const agentMessages = this.agent?.state.messages ?? [];
+        try {
+            const vfsFiles = await snapshotVfs();
+            await Promise.all([
+                saveSession(sessionId, agentMessages),
+                saveVfsFiles(sessionId, vfsFiles),
+            ]);
+            await this.refreshSessions();
+            const updated = await getSession(sessionId);
+            if (updated) {
+                this.update({ currentSession: updated });
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    async init() {
+        if (this.sessionLoaded)
+            return;
+        this.sessionLoaded = true;
+        if (this.adapter.staticFiles) {
+            setStaticFiles(this.adapter.staticFiles);
+        }
+        if (this.adapter.customCommands) {
+            setCustomCommands(this.adapter.customCommands);
+        }
+        try {
+            const id = await this.adapter.getDocumentId();
+            this.documentId = id;
+            const skills = await getInstalledSkills();
+            this.skills = skills;
+            await syncSkillsToVfs();
+            const saved = loadSavedConfig();
+            if (saved?.provider && saved?.apiKey && saved?.model) {
+                this.applyConfig(saved);
+            }
+            const session = await getOrCreateCurrentSession(id);
+            this.currentSessionId = session.id;
+            const [sessions, vfsFiles] = await Promise.all([
+                listSessions(id),
+                loadVfsFiles(session.id),
+            ]);
+            if (vfsFiles.length > 0) {
+                await restoreVfs(vfsFiles);
+            }
+            if (session.agentMessages.length > 0 && this.agent) {
+                this.agent.replaceMessages(session.agentMessages);
+            }
+            const uploadNames = await listUploads();
+            const stats = deriveStats(session.agentMessages);
+            this.update({
+                messages: agentMessagesToChatMessages(session.agentMessages, this.adapter.metadataTag),
+                currentSession: session,
+                sessions,
+                skills,
+                sessionStats: {
+                    ...stats,
+                    contextWindow: this.state.sessionStats.contextWindow,
+                },
+                uploads: uploadNames.map((name) => ({ name, size: 0 })),
+            });
+        }
+        catch (err) {
+            console.error("[Runtime] Failed to load session:", err);
+        }
+    }
+    async uploadFiles(files) {
+        if (files.length === 0)
+            return;
+        this.update({ isUploading: true });
+        try {
+            for (const file of files) {
+                await writeFile(file.name, file.data);
+                const uploads = [...this.state.uploads];
+                const exists = uploads.findIndex((u) => u.name === file.name);
+                if (exists !== -1) {
+                    uploads[exists] = { name: file.name, size: file.size };
+                }
+                else {
+                    uploads.push({ name: file.name, size: file.size });
+                }
+                this.update({ uploads });
+            }
+            if (this.currentSessionId) {
+                const snapshot = await snapshotVfs();
+                await saveVfsFiles(this.currentSessionId, snapshot);
+            }
+        }
+        catch (err) {
+            console.error("Failed to upload file:", err);
+        }
+        finally {
+            this.update({ isUploading: false });
+        }
+    }
+    async removeUpload(name) {
+        try {
+            await deleteFile(name);
+            this.update({
+                uploads: this.state.uploads.filter((u) => u.name !== name),
+            });
+            if (this.currentSessionId) {
+                const snapshot = await snapshotVfs();
+                await saveVfsFiles(this.currentSessionId, snapshot);
+            }
+        }
+        catch (err) {
+            console.error("Failed to delete file:", err);
+            this.update({
+                uploads: this.state.uploads.filter((u) => u.name !== name),
+            });
+        }
+    }
+    async refreshSkillsAndRebuildAgent() {
+        this.skills = await getInstalledSkills();
+        this.update({ skills: this.skills });
+        if (this.state.providerConfig) {
+            this.applyConfig(this.state.providerConfig);
+        }
+    }
+    async installSkill(inputs) {
+        if (inputs.length === 0)
+            return;
+        try {
+            await addSkill(inputs);
+            await this.refreshSkillsAndRebuildAgent();
+        }
+        catch (err) {
+            console.error("[Runtime] Failed to install skill:", err);
+            this.update({
+                error: err instanceof Error ? err.message : "Failed to install skill",
+            });
+        }
+    }
+    async uninstallSkill(name) {
+        try {
+            await removeSkill(name);
+            await this.refreshSkillsAndRebuildAgent();
+        }
+        catch (err) {
+            console.error("[Runtime] Failed to uninstall skill:", err);
+        }
+    }
+    toggleFollowMode() {
+        if (!this.state.providerConfig)
+            return;
+        const newFollowMode = !this.state.providerConfig.followMode;
+        this.followMode = newFollowMode;
+        const newConfig = {
+            ...this.state.providerConfig,
+            followMode: newFollowMode,
+        };
+        saveConfig(newConfig);
+        this.update({ providerConfig: newConfig });
+    }
+    toggleExpandToolCalls() {
+        if (!this.state.providerConfig)
+            return;
+        const newConfig = {
+            ...this.state.providerConfig,
+            expandToolCalls: !this.state.providerConfig.expandToolCalls,
+        };
+        saveConfig(newConfig);
+        this.update({ providerConfig: newConfig });
+    }
+    getName(id) {
+        return this.state.nameMap[id];
+    }
+    dispose() {
+        this.agent?.abort();
+        this.listeners.clear();
+    }
+}
+//# sourceMappingURL=runtime.js.map