fix(markdown): restore document creation and updates

ts/packages/agents/markdown/src/agent/documentOperations.ts

@@ -0,0 +1,167 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import type {
+    ContentItem,
+    DocumentOperation,
+} from "./markdownOperationSchema.js";
+
+export function applyDocumentOperations(
+    content: string,
+    operations: DocumentOperation[],
+): string {
+    return operations.reduce(
+        (updatedContent, operation) =>
+            applyDocumentOperation(updatedContent, operation),
+        content,
+    );
+}
+
+function applyDocumentOperation(
+    content: string,
+    operation: DocumentOperation,
+): string {
+    switch (operation.type) {
+        case "insert": {
+            const position = clampPosition(operation.position, content.length);
+            return (
+                content.slice(0, position) +
+                contentItemsToText(operation.content) +
+                content.slice(position)
+            );
+        }
+        case "replace": {
+            const [from, to] = clampRange(
+                operation.from,
+                operation.to,
+                content.length,
+            );
+            return (
+                content.slice(0, from) +
+                contentItemsToText(operation.content) +
+                content.slice(to)
+            );
+        }
+        case "delete": {
+            const [from, to] = clampRange(
+                operation.from,
+                operation.to,
+                content.length,
+            );
+            return content.slice(0, from) + content.slice(to);
+        }
+        case "format":
+            throw new Error(
+                "Format operations cannot be applied to markdown text",
+            );
+    }
+}
+
+function contentItemsToText(items: ContentItem[]): string {
+    return items.map((item) => contentItemToText(item)).join("");
+}
+
+function contentItemToText(item: ContentItem): string {
+    const text = getPlainText(item);
+    switch (item.type) {
+        case "heading": {
+            if (/^#{1,6}\s/.test(text)) {
+                return ensureBlockSeparator(text);
+            }
+            const attrs = item.attrs as { level?: number } | undefined;
+            const requestedLevel = attrs?.level;
+            const level =
+                requestedLevel !== undefined &&
+                Number.isInteger(requestedLevel) &&
+                requestedLevel >= 1 &&
+                requestedLevel <= 6
+                    ? requestedLevel
+                    : 1;
+            return `${"#".repeat(level)} ${text}\n\n`;
+        }
+        case "paragraph":
+            return ensureBlockSeparator(text);
+        case "bullet_list":
+            return serializeList(item, "-");
+        case "ordered_list":
+            return serializeList(item, "1.");
+        case "code_block":
+            return `\`\`\`\n${text}\n\`\`\`\n\n`;
+        case "blockquote":
+            return `${text
+                .split("\n")
+                .map((line) => `> ${line}`)
+                .join("\n")}\n\n`;
+        case "horizontal_rule":
+            return "---\n\n";
+        case "hard_break":
+            return "  \n";
+        case "text":
+            return applyMarks(text, item);
+        default:
+            return text;
+    }
+}
+
+function getPlainText(item: ContentItem): string {
+    if (item.text !== undefined) {
+        return item.text;
+    }
+    return item.content ? item.content.map(getPlainText).join("") : "";
+}
+
+function ensureBlockSeparator(text: string): string {
+    return text.endsWith("\n\n") ? text : `${text}\n\n`;
+}
+
+function serializeList(item: ContentItem, marker: string): string {
+    const lines =
+        item.content?.map(
+            (child) => `${marker} ${getPlainText(child).trim()}`,
+        ) ?? [];
+    return `${lines.join("\n")}\n\n`;
+}
+
+function applyMarks(text: string, item: ContentItem): string {
+    return (item.marks ?? []).reduce((markedText, mark) => {
+        switch (mark.type) {
+            case "strong":
+                return `**${markedText}**`;
+            case "em":
+                return `*${markedText}*`;
+            case "code":
+                return `\`${markedText}\``;
+            case "link": {
+                const attrs = mark.attrs as { href?: string } | undefined;
+                return attrs?.href
+                    ? `[${markedText}](${attrs.href})`
+                    : markedText;
+            }
+            default:
+                return markedText;
+        }
+    }, text);
+}
+
+function clampPosition(position: number, contentLength: number): number {
+    if (!Number.isInteger(position) || position < 0) {
+        throw new Error(`Invalid document position: ${position}`);
+    }
+    return Math.min(position, contentLength);
+}
+
+function clampRange(
+    from: number,
+    to: number,
+    contentLength: number,
+): [number, number] {
+    if (
+        !Number.isInteger(from) ||
+        !Number.isInteger(to) ||
+        from < 0 ||
+        to < from
+    ) {
+        throw new Error(`Invalid document range: ${from}-${to}`);
+    }
+    return [Math.min(from, contentLength), Math.min(to, contentLength)];
+}

ts/packages/agents/markdown/src/agent/markdownActionHandler.ts

@@ -18,6 +18,7 @@ import { ChildProcess, fork } from "child_process";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import { UICommandResult } from "./ipcTypes.js";
+import { applyDocumentOperations } from "./documentOperations.js";
 import registerDebug from "debug";
 
 const debug = registerDebug("typeagent:markdown:agent");
@@ -379,8 +380,11 @@ async function handleStreamingMarkdownAction(
         `[AGENT] Starting streaming action: ${action.actionName} (stream: ${streamId})`,
     );
 
-    const agent = await createMarkdownAgent("GPT_4o");
+    const agent = await createMarkdownAgent("GPT_4_O");
     const storage = actionContext.sessionContext.sessionStorage;
+    if (!storage) {
+        throw new Error("Markdown actions require session storage");
+    }
 
     // Get current document content
     const filePath = `${actionContext.sessionContext.agentContext.currentFileName}`;
@@ -539,7 +543,6 @@ async function handleMarkdownAction(
     actionContext: ActionContext<MarkdownActionContext>,
 ) {
     let result: ActionResult | undefined = undefined;
-    const agent = await createMarkdownAgent("GPT_4o");
 
     // Accumulates the LLM token usage consumed while handling this action so
     // it can be reported back to the dispatcher as "Action Tokens". The agent
@@ -549,9 +552,16 @@ async function handleMarkdownAction(
         completion_tokens: 0,
         total_tokens: 0,
     };
-    agent.tokenUsage = tokenUsage;
+    const createAgent = async () => {
+        const agent = await createMarkdownAgent("GPT_4_O");
+        agent.tokenUsage = tokenUsage;
+        return agent;
+    };
 
     const storage = actionContext.sessionContext.sessionStorage;
+    if (!storage) {
+        throw new Error("Markdown actions require session storage");
+    }
 
     switch (action.actionName) {
         case "openDocument":
@@ -571,14 +581,14 @@ async function handleMarkdownAction(
                 actionContext.sessionContext.agentContext.currentFileName =
                     newFileName;
 
-                if (!(await storage?.exists(newFileName))) {
-                    await storage?.write(newFileName, "");
+                if (!(await storage.exists(newFileName))) {
+                    await storage.write(newFileName, "");
                 }
 
                 if (actionContext.sessionContext.agentContext.viewProcess) {
                     const fullPath = await getFullMarkdownFilePath(
                         newFileName,
-                        storage!,
+                        storage,
                     );
 
                     actionContext.sessionContext.agentContext.viewProcess.send({
@@ -588,6 +598,10 @@ async function handleMarkdownAction(
                     });
                 }
                 result = createActionResult("Document opened");
+                result.resultEntity = {
+                    name: newFileName,
+                    type: ["file", "markdown"],
+                };
                 result.activityContext = {
                     activityName: "editingMarkdown",
                     description: "Editing a Markdown document",
@@ -600,6 +614,7 @@ async function handleMarkdownAction(
             break;
         }
         case "updateDocument": {
+            const agent = await createAgent();
             debug("Starting updateDocument action in agent process");
             result = createActionResult("Updating document ...");
 
@@ -629,9 +644,9 @@ async function handleMarkdownAction(
                 }
             } else {
                 // Fallback if no view process
-                if (await storage?.exists(filePath)) {
+                if (await storage.exists(filePath)) {
                     markdownContent =
-                        (await storage?.read(filePath, "utf8")) || "";
+                        (await storage.read(filePath, "utf8")) || "";
                     debug(
                         "No view process, read content from storage:",
                         markdownContent?.length,
@@ -714,9 +729,12 @@ async function handleMarkdownAction(
                             "Operations applied successfully via view process",
                         );
                     } else {
-                        console.warn(
-                            "No view process available, operations not applied",
+                        const updatedContent = applyDocumentOperations(
+                            markdownContent,
+                            updateResult.operations,
                         );
+                        await storage.write(filePath, updatedContent);
+                        debug("Applied operations directly to session storage");
                     }
                 } else {
                     debug("[AGENT] No operations returned from LLM");
@@ -740,6 +758,7 @@ async function handleMarkdownAction(
             break;
         }
         case "streamingUpdateDocument": {
+            const agent = await createAgent();
             // Handle streaming AI commands - now unified with regular updateDocument flow
             debug(
                 "Starting streamingUpdateDocument action - using standard translator flow",
@@ -772,9 +791,9 @@ async function handleMarkdownAction(
                 }
             } else {
                 // Fallback if no view process
-                if (await storage?.exists(filePath)) {
+                if (await storage.exists(filePath)) {
                     markdownContent =
-                        (await storage?.read(filePath, "utf8")) || "";
+                        (await storage.read(filePath, "utf8")) || "";
                     debug(
                         "No view process, read content from storage:",
                         markdownContent?.length,
@@ -819,8 +838,13 @@ async function handleMarkdownAction(
                             "Operations applied successfully via view process",
                         );
                     } else {
-                        console.warn(
-                            "No view process available, operations not applied",
+                        const updatedContent = applyDocumentOperations(
+                            markdownContent,
+                            updateResult.operations,
+                        );
+                        await storage.write(filePath, updatedContent);
+                        debug(
+                            "Applied streaming operations directly to session storage",
                         );
                     }
                 }

ts/packages/agents/markdown/src/agent/markdownOperationSchema.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 
 // Document operation types for incremental updates to ProseMirror documents
-// Position references should be line numbers (0-based) in the document.
+// Position references are character offsets (0-based) in the markdown text.
 export type DocumentOperation =
     | InsertOperation
     | DeleteOperation

ts/packages/agents/markdown/src/agent/translator.ts

@@ -21,7 +21,7 @@ import { MarkdownUpdateResult } from "./markdownOperationSchema.js";
 const debug = registerDebug("typeagent:markdown:translator");
 
 export async function createMarkdownAgent(
-    model: "GPT_35_TURBO" | "GPT_4" | "GPT-v" | "GPT_4o",
+    model: "GPT_35_TURBO" | "GPT_4" | "GPT_V" | "GPT_4_O",
 ) {
     const packageRoot = path.join("../../");
     const schemaText = await fs.promises.readFile(