fullstacked 0.12.1-1370 → 0.12.2-1380

package/fullstacked_modules/@fullstacked/ai-agent/package.json

@@ -1,28 +0,0 @@
-{
-  "dependencies": {
-    "@fullstacked/codemirror-view": "git+https://github.com:fullstackedorg/codemirror-view",
-    "@google/genai": "^1.27.0",
-    "@langchain/anthropic": "^1.0.0",
-    "@langchain/core": "^1.0.1",
-    "@langchain/deepseek": "^1.0.0",
-    "@langchain/google-genai": "^1.0.0",
-    "@langchain/mistralai": "^1.0.0",
-    "@langchain/ollama": "^1.0.0",
-    "@langchain/xai": "^1.0.0",
-    "@mistralai/mistralai": "^1.10.0",
-    "langchain": "^1.0.1",
-    "ollama": "^0.6.0",
-    "openai": "^6.7.0",
-    "streaming-markdown": "^0.2.15",
-    "zod": "^4.1.12"
-  },
-  "devDependencies": {
-    "@codemirror/theme-one-dark": "^6.1.3"
-  },
-  "main": "./src/index.ts",
-  "name": "@fullstacked/ai-agent",
-  "version": "0.0.0",
-  "exports": {
-    ".": "./ai-agent.js"
-  }
-}

package/fullstacked_modules/@fullstacked/ai-agent/src/conversation.ts

@@ -1,227 +0,0 @@
-import {
-    AIMessageChunk,
-    BaseMessage,
-    HumanMessage,
-    mapChatMessagesToStoredMessages,
-    mapStoredMessagesToChatMessages,
-    StoredMessage,
-    ToolMessage,
-    AIMessage,
-} from "@langchain/core/messages";
-import { createHumanInput } from "./input";
-import { createMarkdownStreamRenderer } from "./markdown";
-import { tool } from "@langchain/core/tools";
-import { ToolCall } from "@langchain/core/messages/tool";
-import { z } from "zod";
-import { Provider } from "./providers/interface";
-import { Extension } from "@codemirror/state";
-import { Runnable } from "@langchain/core/runnables";
-import { BaseLanguageModelInput } from "@langchain/core/language_models/base";
-import { BaseChatModelCallOptions } from "@langchain/core/language_models/chat_models";
-
-type ConversationOptions = {
-    model: string;
-    provider: Provider;
-    messages?: StoredMessage[];
-    tools?: ReturnType<typeof createTool>[];
-    codemirrorViewExtension?: Extension[];
-    onStateChange?: (state: "STREAMING" | "IDLE" | "ERROR") => void;
-};
-
-export function createTool<T extends z.ZodSchema>(opts: {
-    name: string;
-    description: string;
-    schema: T;
-    fn(args: z.infer<T>): any;
-    message?(args: z.infer<T>): string;
-}) {
-    return {
-        tool: tool(opts.fn, {
-            name: opts.name,
-            description: opts.description,
-            schema: opts.schema as any,
-        }),
-        message: opts.message,
-    };
-}
-
-function classForMessageType(message: BaseMessage) {
-    if (message instanceof HumanMessage) {
-        return "human";
-    } else if (
-        message instanceof AIMessage ||
-        message instanceof AIMessageChunk
-    ) {
-        return "ai";
-    } else if (message instanceof ToolMessage) {
-        return "tool";
-    }
-}
-
-export function createConversation(opts: ConversationOptions) {
-    let chatModel: Runnable<
-        BaseLanguageModelInput,
-        AIMessageChunk,
-        BaseChatModelCallOptions
-    >;
-    const updateChatModel = (provider: Provider, model: string) => {
-        const client = provider.client(model);
-        chatModel = opts.tools
-            ? client.bindTools(opts.tools.map(({ tool }) => tool))
-            : client;
-    };
-
-    updateChatModel(opts.provider, opts.model);
-
-    const element = document.createElement("div");
-    element.classList.add("conversation");
-
-    const conversation: BaseMessage[] = mapStoredMessagesToChatMessages(
-        opts.messages || [],
-    );
-    const messagesContainer = document.createElement("div");
-    messagesContainer.classList.add("messages");
-
-    const renderMessage = (message: BaseMessage) => {
-        const messageContainer = document.createElement("div");
-        messageContainer.classList.add(classForMessageType(message));
-        messagesContainer.append(messageContainer);
-        const renderer = createMarkdownStreamRenderer(
-            messageContainer,
-            opts.codemirrorViewExtension,
-        );
-        renderer.write(
-            message.response_metadata["user-defined-message"] ||
-                (message.content as string),
-        );
-        renderer.end();
-    };
-
-    conversation.forEach(renderMessage);
-
-    const onToolRequest = async (toolCall: ToolCall) => {
-        const t = opts.tools.find(
-            ({ tool: { name } }) => name === toolCall.name,
-        );
-
-        const container = document.createElement("div");
-        const userDefinedMessage =
-            t.message?.(toolCall.args) || `Using tool ${toolCall.name}`;
-        messagesContainer.append(container);
-
-        const renderer = createMarkdownStreamRenderer(
-            container,
-            opts.codemirrorViewExtension,
-        );
-        renderer.write(userDefinedMessage);
-        renderer.end();
-
-        const toolResponse: ToolMessage = await t.tool.invoke(toolCall);
-        toolResponse.response_metadata["user-defined-message"] =
-            userDefinedMessage;
-        conversation.push(toolResponse);
-
-        return !!toolResponse.content;
-    };
-
-    const onHumanPrompt = (text: string) => {
-        const humanMessage = new HumanMessage(text);
-        conversation.push(humanMessage);
-        renderMessage(humanMessage);
-        promptAgent();
-    };
-
-    const promptAgent = async () => {
-        let done = false;
-        const aiMessageContainer = document.createElement("div");
-        messagesContainer.append(aiMessageContainer);
-
-        const responseContainer = document.createElement("div");
-        const loadingContainer = document.createElement("div");
-        const loadingDisplayInterval = setInterval(() => {
-            if (done) {
-                clearInterval(loadingDisplayInterval);
-                loadingContainer.remove();
-            } else {
-                const dotCount = loadingContainer.innerText.length;
-                loadingContainer.innerText = new Array((dotCount % 3) + 1)
-                    .fill(".")
-                    .join("");
-            }
-        }, 250);
-
-        aiMessageContainer.append(responseContainer, loadingContainer);
-
-        opts.onStateChange?.("STREAMING");
-        const renderer = createMarkdownStreamRenderer(
-            responseContainer,
-            opts.codemirrorViewExtension,
-        );
-        let stream: Awaited<ReturnType<typeof chatModel.stream>>;
-        try {
-            stream = await chatModel.stream(conversation);
-        } catch (e) {
-            renderer.write(e.toString());
-            opts.onStateChange?.("ERROR");
-            done = true;
-            renderer.end();
-            return;
-        }
-        let messageIndex: number = null;
-        for await (const chunk of stream) {
-            if (messageIndex === null) {
-                messageIndex = conversation.length;
-                conversation.push(chunk);
-                aiMessageContainer.classList.add(classForMessageType(chunk));
-            } else {
-                conversation[messageIndex] = (
-                    conversation[messageIndex] as AIMessageChunk
-                ).concat(chunk);
-            }
-
-            if (typeof chunk.content === "string") {
-                renderer.write(chunk.content);
-            }
-        }
-        renderer.end();
-
-        const aiMessage = conversation.at(messageIndex) as AIMessageChunk;
-        const toolPromises = aiMessage.tool_calls.map((t) => onToolRequest(t));
-        const awaitedToolPromises = await Promise.all(toolPromises);
-
-        done = true;
-
-        if (toolPromises.length) {
-            return promptAgent();
-        }
-        opts.onStateChange?.("IDLE");
-    };
-
-    const humanInput = createHumanInput({
-        onSubmit: onHumanPrompt,
-    });
-
-    element.append(messagesContainer, humanInput);
-
-    const serialize = () => mapChatMessagesToStoredMessages(conversation);
-
-    return {
-        element,
-        serialize,
-        updateChatModel,
-        prompt: onHumanPrompt,
-        generateConversationTitle: async () => {
-            const response = await chatModel.invoke([
-                ...conversation,
-                new HumanMessage(
-                    "Without thinking, generate a title for this conversation with a 1 to 3 words.",
-                ),
-            ]);
-            return response.content
-                .toString()
-                .replace(/<think>(.|\s)*<\/think>\s*/g, "") // remove ollama think tags
-                .replace(/(\*|\"|\')*/g, "") // remove any md formatting
-                .trim();
-        },
-    };
-}

package/fullstacked_modules/@fullstacked/ai-agent/src/default.scss

@@ -1,23 +0,0 @@
-.conversation {
-    height: 100%;
-    width: 100%;
-    position: relative;
-    overflow: hidden;
-
-    display: flex;
-    flex-direction: column;
-
-    .messages {
-        width: 100%;
-        flex: 1;
-        overflow: auto;
-
-        .human {
-            text-align: right;
-        }
-    }
-
-    .input {
-        margin: 5px;
-    }
-}

package/fullstacked_modules/@fullstacked/ai-agent/src/index.ts

@@ -1,2 +0,0 @@
-export * from "./conversation";
-export * from "./providers";

package/fullstacked_modules/@fullstacked/ai-agent/src/input.ts

@@ -1,36 +0,0 @@
-type HumanInputOptions = {
-    placeholderText: string;
-    onSubmit(text: string): void;
-};
-
-export function createHumanInput(opts?: Partial<HumanInputOptions>) {
-    const placeholder = opts?.placeholderText || "Ask me anything...";
-    const input = document.createElement("div");
-    input.classList.add("input");
-    input.contentEditable = "true";
-    input.innerText = placeholder;
-
-    input.addEventListener("focus", () => {
-        if (input.innerText !== placeholder) return;
-        input.innerText = "";
-    });
-
-    input.addEventListener("blur", () => {
-        if (input.innerText !== "") return;
-        input.innerText = placeholder;
-    });
-
-    input.addEventListener("keydown", async (e) => {
-        if (e.shiftKey || e.key !== "Enter") return;
-        e.preventDefault();
-        e.stopPropagation();
-
-        const text = input.innerText;
-        opts.onSubmit(text);
-
-        input.innerText = "";
-        input.blur();
-    });
-
-    return input;
-}

package/fullstacked_modules/@fullstacked/ai-agent/src/markdown.ts

@@ -1,50 +0,0 @@
-import * as smd from "streaming-markdown";
-import { createCodeMirrorView } from "@fullstacked/codemirror-view";
-import { SupportedLanguage } from "@fullstacked/codemirror-view/languages";
-import { Extension } from "@codemirror/state";
-
-export function createMarkdownStreamRenderer(
-    el: HTMLElement,
-    cmExtensions?: Extension[],
-) {
-    const renderer = smd.default_renderer(el);
-    const defaultAddToken = renderer.add_token;
-    renderer.add_token = function (data: any, type: any) {
-        if (type !== 9 && type !== 10) {
-            return defaultAddToken(data, type);
-        }
-
-        let parent = data.nodes[data.index];
-        const codeView = createCodeMirrorView({
-            extensions: cmExtensions || [],
-        }) as ReturnType<typeof createCodeMirrorView> & {
-            setAttribute(attr: string, value: string): void;
-            appendChild(text: Text): void;
-        };
-        codeView.editing.lock();
-        codeView.setAttribute = async function (attr, value) {
-            if (attr !== "class") return;
-            codeView.setLanguage(value as SupportedLanguage);
-        };
-        codeView.appendChild = (text) => {
-            codeView.editorView.dispatch({
-                changes: {
-                    from: codeView.editorView.state.doc.length,
-                    insert: text.wholeText,
-                },
-            });
-        };
-        parent = parent.appendChild(codeView.element);
-
-        data.nodes[++data.index] = codeView;
-    };
-    const parser = smd.parser(renderer);
-    return {
-        write(md: string) {
-            smd.parser_write(parser, md);
-        },
-        end() {
-            smd.parser_end(parser);
-        },
-    };
-}

package/fullstacked_modules/@fullstacked/ai-agent/src/providers/anthropic.ts

@@ -1,50 +0,0 @@
-import Anthropic from "@anthropic-ai/sdk";
-import { ChatAnthropic } from "@langchain/anthropic";
-import { ProviderInfo } from "./interface";
-import { core_fetch2 } from "fetch";
-import { Provider } from "@fullstacked/ai-agent/src/providers/interface";
-
-export const AnthropicInfo: ProviderInfo<{
-    apiKey: {
-        title: "API Key";
-        type: "string";
-        value: string;
-    };
-}> = {
-    id: "anthropic",
-    title: "Anthropic",
-    configs: {
-        apiKey: {
-            title: "API Key",
-            type: "string",
-            value: "",
-        },
-    },
-};
-
-async function models(apiKey: string) {
-    const anthropicClient = new Anthropic({
-        apiKey: apiKey,
-        fetch: core_fetch2,
-        dangerouslyAllowBrowser: true,
-    });
-
-    const models = await anthropicClient.models.list();
-    return models.data.map(({ id }) => id);
-}
-
-export function createClaude(opts?: typeof AnthropicInfo.configs): Provider {
-    const apiKey = opts?.apiKey?.value || "";
-
-    return {
-        models: () => models(apiKey),
-        client: (model) =>
-            new ChatAnthropic({
-                model,
-                apiKey,
-                clientOptions: {
-                    fetch: core_fetch2,
-                },
-            }),
-    };
-}

package/fullstacked_modules/@fullstacked/ai-agent/src/providers/deepseek.ts

@@ -1,50 +0,0 @@
-import { core_fetch2 } from "fetch";
-import { Provider, ProviderInfo } from "./interface";
-import openai from "openai";
-import { ChatDeepSeek } from "@langchain/deepseek";
-
-export const DeepSeekInfo: ProviderInfo<{
-    apiKey: {
-        title: "API Key";
-        type: "string";
-        value: string;
-    };
-}> = {
-    id: "deepseek",
-    title: "DeepSeek",
-    configs: {
-        apiKey: {
-            title: "API Key",
-            type: "string",
-            value: "",
-        },
-    },
-};
-
-async function models(apiKey: string) {
-    const client = new openai({
-        apiKey,
-        baseURL: "https://api.deepseek.com",
-        fetch: core_fetch2,
-        dangerouslyAllowBrowser: true,
-    });
-
-    const models = await client.models.list();
-    return models.data.map(({ id }) => id);
-}
-
-export function createDeepSeek(opts?: typeof DeepSeekInfo.configs): Provider {
-    const apiKey = opts?.apiKey?.value || "";
-
-    return {
-        models: () => models(apiKey),
-        client: (model) =>
-            new ChatDeepSeek({
-                model,
-                apiKey,
-                configuration: {
-                    fetch: core_fetch2,
-                },
-            }),
-    };
-}

package/fullstacked_modules/@fullstacked/ai-agent/src/providers/google.ts

@@ -1,44 +0,0 @@
-import { ChatGoogleGenerativeAI } from "@langchain/google-genai";
-import { GoogleGenAI } from "@google/genai";
-import { Provider } from "@fullstacked/ai-agent/src/providers/interface";
-import { ProviderInfo } from "./interface";
-
-export const GoogleInfo: ProviderInfo<{
-    apiKey: {
-        title: "API Key";
-        type: "string";
-        value: string;
-    };
-}> = {
-    id: "google",
-    title: "Google",
-    configs: {
-        apiKey: {
-            title: "API Key",
-            type: "string",
-            value: "",
-        },
-    },
-};
-
-async function models(apiKey: string) {
-    const googleClient = new GoogleGenAI({
-        apiKey,
-    });
-
-    const models = await googleClient.models.list();
-    return models.page.map(({ name }) => name.slice("models/".length));
-}
-
-export function createGemini(opts?: typeof GoogleInfo.configs): Provider {
-    const apiKey = opts?.apiKey?.value || "";
-
-    return {
-        models: () => models(apiKey),
-        client: (model) =>
-            new ChatGoogleGenerativeAI({
-                model,
-                apiKey,
-            }),
-    };
-}

package/fullstacked_modules/@fullstacked/ai-agent/src/providers/index.ts

@@ -1,39 +0,0 @@
-import { ProviderInfo } from "./interface";
-import { OpenAIInfo, createOpenAI } from "./openai";
-import { OllamaInfo, createOllama } from "./ollama";
-import { Provider } from "./interface";
-import { AnthropicInfo, createClaude } from "./anthropic";
-import { GoogleInfo, createGemini } from "./google";
-import { createGrok, xAIInfo } from "./xai";
-import { DeepSeekInfo, createDeepSeek } from "./deepseek";
-import { MistralInfo, createMistral } from "./mistral";
-
-export const providersInfo = {
-    ollama: OllamaInfo,
-    openai: OpenAIInfo,
-    antropic: AnthropicInfo,
-    google: GoogleInfo,
-    xai: xAIInfo,
-    deepseek: DeepSeekInfo,
-    mistral: MistralInfo,
-} as const;
-
-export function getProvider(providerInfo: ProviderInfo<any>) {
-    switch (providerInfo.id) {
-        case "ollama":
-            return createOllama(providerInfo.configs);
-        case "openai":
-            return createOpenAI(providerInfo.configs);
-        case "anthropic":
-            return createClaude(providerInfo.configs);
-        case "google":
-            return createGemini(providerInfo.configs);
-        case "xai":
-            return createGrok(providerInfo.configs);
-        case "deepseek":
-            return createDeepSeek(providerInfo.configs);
-        case "mistral":
-            return createMistral(providerInfo.configs);
-    }
-    return null;
-}

package/fullstacked_modules/@fullstacked/ai-agent/src/providers/interface.ts

@@ -1,29 +0,0 @@
-import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-
-type ConfigType =
-    | {
-          type: "string";
-          value: string;
-      }
-    | {
-          type: "key-value";
-          value: [string, string][];
-      };
-
-export type ProviderInfo<
-    C extends Record<
-        string,
-        ConfigType & {
-            title: string;
-        }
-    >,
-> = {
-    id: string;
-    title?: string;
-    configs: C;
-};
-
-export interface Provider {
-    models(): Promise<string[]>;
-    client(model: string): BaseChatModel;
-}

package/fullstacked_modules/@fullstacked/ai-agent/src/providers/mistral.ts

@@ -1,51 +0,0 @@
-import { core_fetch2 } from "fetch";
-import { Provider, ProviderInfo } from "./interface";
-import { ChatMistralAI } from "@langchain/mistralai";
-import { HTTPClient } from "@mistralai/mistralai/lib/http";
-import { Mistral } from "@mistralai/mistralai";
-
-export const MistralInfo: ProviderInfo<{
-    apiKey: {
-        title: "API Key";
-        type: "string";
-        value: string;
-    };
-}> = {
-    id: "mistral",
-    title: "Mistral AI",
-    configs: {
-        apiKey: {
-            title: "API Key",
-            type: "string",
-            value: "",
-        },
-    },
-};
-
-async function models(apiKey: string) {
-    const mistralClient = new Mistral({
-        apiKey: apiKey,
-        httpClient: {
-            request: (r) => core_fetch2(r),
-        } as HTTPClient,
-    });
-
-    const models = await mistralClient.models.list();
-    return models.data.map(({ id }) => id);
-}
-
-export function createMistral(opts?: typeof MistralInfo.configs): Provider {
-    const apiKey = opts?.apiKey?.value || "";
-
-    return {
-        models: () => models(apiKey),
-        client: (model) =>
-            new ChatMistralAI({
-                model,
-                apiKey,
-                httpClient: {
-                    request: (r) => core_fetch2(r),
-                } as HTTPClient,
-            }),
-    };
-}