@fredrika/mcp-mochi 1.0.5 → 1.0.6-beta.1

package/dist/index.js

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
-import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import axios from "axios";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import FormData from "form-data";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import dotenv from "dotenv";
 import { z } from "zod";
-import { zodToJsonSchema } from "zod-to-json-schema";
 dotenv.config();
 /**
  * Custom error class for Mochi API errors
@@ -36,14 +35,14 @@ const CreateCardRequestSchema = z.object({
         .string()
         .min(1)
         .describe("Markdown content of the card. Separate front and back using a horizontal rule (---) or use brackets for {{cloze deletion}}."),
-    "deck-id": z.string().min(1).describe("ID of the deck to create the card in"),
-    "template-id": z
+    deckId: z.string().min(1).describe("ID of the deck to create the card in"),
+    templateId: z
         .string()
         .optional()
         .nullable()
         .default(null)
         .describe("Optional template ID to use for the card. Defaults to null if not set."),
-    "manual-tags": z
+    tags: z
         .array(z.string())
         .optional()
         .describe("Optional array of tags to add to the card"),
@@ -57,16 +56,10 @@ const UpdateCardRequestSchema = z.object({
         .string()
         .optional()
         .describe("Updated markdown content of the card"),
-    "deck-id": z
-        .string()
-        .optional()
-        .describe("ID of the deck to move the card to"),
-    "template-id": z
-        .string()
-        .optional()
-        .describe("Template ID to use for the card"),
-    "archived?": z.boolean().optional().describe("Whether the card is archived"),
-    "trashed?": z.string().optional().describe("Whether the card is trashed"),
+    deckId: z.string().optional().describe("ID of the deck to move the card to"),
+    templateId: z.string().optional().describe("Template ID to use for the card"),
+    archived: z.boolean().optional().describe("Whether the card is archived"),
+    trashed: z.boolean().optional().describe("Whether the card is trashed"),
     fields: z
         .record(z.string(), CreateCardFieldSchema)
         .optional()
@@ -79,7 +72,7 @@ const ListDecksParamsSchema = z.object({
         .describe("Pagination bookmark for fetching next page of results"),
 });
 const ListCardsParamsSchema = z.object({
-    "deck-id": z.string().optional().describe("Get cards from deck ID"),
+    deckId: z.string().optional().describe("Get cards from deck ID"),
     limit: z
         .number()
         .min(1)
@@ -97,10 +90,96 @@ const ListTemplatesParamsSchema = z.object({
         .optional()
         .describe("Pagination bookmark for fetching next page of results"),
 });
+const GetDueCardsParamsSchema = z.object({
+    deckId: z
+        .string()
+        .optional()
+        .describe("Optional deck ID to filter due cards by a specific deck"),
+    date: z
+        .string()
+        .optional()
+        .describe("Optional ISO 8601 date to get cards due on that date. Defaults to today."),
+});
+const CreateCardFromTemplateSchema = z.object({
+    templateId: z
+        .string()
+        .min(1)
+        .describe("ID of the template to use. Get this from mochi_list_templates."),
+    deckId: z
+        .string()
+        .min(1)
+        .describe("ID of the deck to create the card in. Get this from mochi_list_decks."),
+    fields: z
+        .record(z.string(), z.string())
+        .describe('Map of field NAMES (not IDs) to values. E.g., { "Word": "serendipity" } or { "Front": "Question?", "Back": "Answer" }'),
+    tags: z
+        .array(z.string())
+        .optional()
+        .describe("Optional array of tags to add to the card"),
+});
+// Schema for adding attachments
+const AddAttachmentSchema = z.object({
+    cardId: z.string().min(1).describe("ID of the card to attach the file to"),
+    data: z.string().min(1).describe("Base64-encoded file data"),
+    filename: z
+        .string()
+        .min(1)
+        .describe("Filename with extension (e.g., 'image.png', 'audio.mp3')"),
+    contentType: z
+        .string()
+        .optional()
+        .describe("MIME type of the file (e.g., 'image/png'). Can be inferred from filename if not provided."),
+});
+// Helper to transform camelCase params to hyphenated format for Mochi API
+function toMochiCreateCardRequest(params) {
+    return {
+        content: params.content,
+        "deck-id": params.deckId,
+        "template-id": params.templateId,
+        "manual-tags": params.tags,
+        fields: params.fields,
+    };
+}
+function toMochiUpdateCardRequest(params) {
+    const result = {};
+    if (params.content !== undefined)
+        result.content = params.content;
+    if (params.deckId !== undefined)
+        result["deck-id"] = params.deckId;
+    if (params.templateId !== undefined)
+        result["template-id"] = params.templateId;
+    if (params.archived !== undefined)
+        result["archived?"] = params.archived;
+    if (params.trashed !== undefined)
+        result["trashed?"] = params.trashed;
+    if (params.fields !== undefined)
+        result.fields = params.fields;
+    return result;
+}
+function toMochiListCardsParams(params) {
+    const result = {};
+    if (params.deckId !== undefined)
+        result["deck-id"] = params.deckId;
+    if (params.limit !== undefined)
+        result.limit = params.limit;
+    if (params.bookmark !== undefined)
+        result.bookmark = params.bookmark;
+    return result;
+}
 const TemplateFieldSchema = z.object({
     id: z.string().describe("Unique identifier for the template field"),
     name: z.string().describe("Display name of the field"),
     pos: z.string().describe("Position of the field in the template"),
+    type: z
+        .string()
+        .optional()
+        .nullable()
+        .describe("Field type: null/text for user input, or ai/speech/translate/dictionary for auto-generated"),
+    source: z
+        .string()
+        .optional()
+        .nullable()
+        .describe("Source field ID for auto-generated fields"),
     options: z
         .object({
         "multi-line?": z
@@ -108,6 +187,7 @@ const TemplateFieldSchema = z.object({
             .optional()
             .describe("Whether the field supports multiple lines of text"),
     })
+        .passthrough()
         .optional()
         .describe("Additional options for the field"),
 });
@@ -141,12 +221,13 @@ const CardSchema = z
     name: z.string().describe("Display name of the card"),
     "deck-id": z.string().describe("ID of the deck containing the card"),
     fields: z
-        .record(z.unknown())
+        .record(z.string(), z.unknown())
         .optional()
         .describe("Map of field IDs to field values. Need to match the field IDs in the template"),
 })
     .strip();
 const CreateCardResponseSchema = CardSchema.strip();
+const UpdateCardResponseSchema = CardSchema.strip();
 const ListCardsResponseSchema = z
     .object({
     bookmark: z.string().describe("Pagination bookmark for fetching next page"),
@@ -158,7 +239,16 @@ const DeckSchema = z
     id: z.string().describe("Unique identifier for the deck"),
     sort: z.number().describe("Sort order of the deck"),
     name: z.string().describe("Display name of the deck"),
-    archived: z.boolean().optional().describe("Whether the deck is archived"),
+    "archived?": z
+        .boolean()
+        .optional()
+        .nullable()
+        .describe("Whether the deck is archived"),
+    "trashed?": z
+        .object({ date: z.string() })
+        .optional()
+        .nullable()
+        .describe("Whether the deck is trashed"),
 })
     .strip();
 const ListDecksResponseSchema = z
@@ -167,6 +257,18 @@ const ListDecksResponseSchema = z
     docs: z.array(DeckSchema).describe("Array of decks"),
 })
     .strip();
+const DueCardSchema = z
+    .object({
+    id: z.string().describe("Unique identifier for the card"),
+    content: z.string().describe("Markdown content of the card"),
+    name: z.string().describe("Display name of the card"),
+    "deck-id": z.string().describe("ID of the deck containing the card"),
+    "new?": z.boolean().describe("Whether the card is new (never reviewed)"),
+})
+    .passthrough();
+const GetDueCardsResponseSchema = z.object({
+    cards: z.array(DueCardSchema).describe("Array of cards due for review"),
+});
 function getApiKey() {
     const apiKey = process.env.MOCHI_API_KEY;
     if (!apiKey) {
@@ -190,11 +292,13 @@ export class MochiClient {
         });
     }
     async createCard(request) {
-        const response = await this.api.post("/cards", request);
+        const mochiRequest = toMochiCreateCardRequest(request);
+        const response = await this.api.post("/cards", mochiRequest);
         return CreateCardResponseSchema.parse(response.data);
     }
     async updateCard(cardId, request) {
-        const response = await this.api.post(`/cards/${cardId}`, request);
+        const mochiRequest = toMochiUpdateCardRequest(request);
+        const response = await this.api.post(`/cards/${cardId}`, mochiRequest);
         return CreateCardResponseSchema.parse(response.data);
     }
     async listDecks(params) {
@@ -202,13 +306,18 @@ export class MochiClient {
             ? ListDecksParamsSchema.parse(params)
             : undefined;
         const response = await this.api.get("/decks", { params: validatedParams });
-        return ListDecksResponseSchema.parse(response.data).docs.filter((deck) => !deck.archived);
+        return ListDecksResponseSchema.parse(response.data)
+            .docs.filter((deck) => !deck["archived?"] && !deck["trashed?"])
+            .sort((a, b) => a.sort - b.sort);
     }
     async listCards(params) {
         const validatedParams = params
             ? ListCardsParamsSchema.parse(params)
             : undefined;
-        const response = await this.api.get("/cards", { params: validatedParams });
+        const mochiParams = validatedParams
+            ? toMochiListCardsParams(validatedParams)
+            : undefined;
+        const response = await this.api.get("/cards", { params: mochiParams });
         return ListCardsResponseSchema.parse(response.data);
     }
     async listTemplates(params) {
@@ -220,386 +329,399 @@ export class MochiClient {
         });
         return ListTemplatesResponseSchema.parse(response.data);
     }
+    async getDueCards(params) {
+        const validatedParams = params
+            ? GetDueCardsParamsSchema.parse(params)
+            : undefined;
+        const deckId = validatedParams?.deckId;
+        const endpoint = deckId ? `/due/${deckId}` : "/due";
+        const queryParams = validatedParams?.date
+            ? { date: validatedParams.date }
+            : undefined;
+        const response = await this.api.get(endpoint, { params: queryParams });
+        return GetDueCardsResponseSchema.parse(response.data);
+    }
+    async getTemplate(templateId) {
+        const response = await this.api.get(`/templates/${templateId}`);
+        return TemplateSchema.parse(response.data);
+    }
+    async createCardFromTemplate(request) {
+        // Fetch the template to get field definitions
+        const template = await this.getTemplate(request.templateId);
+        // Map field names to IDs
+        const fieldNameToId = {};
+        for (const [fieldId, field] of Object.entries(template.fields)) {
+            fieldNameToId[field.name] = fieldId;
+        }
+        // Build the fields object with IDs
+        const fields = {};
+        const fieldValues = [];
+        for (const [fieldName, value] of Object.entries(request.fields)) {
+            const fieldId = fieldNameToId[fieldName];
+            if (!fieldId) {
+                throw new MochiError([
+                    `Unknown field name: "${fieldName}". Available fields: ${Object.keys(fieldNameToId).join(", ")}`,
+                ], 400);
+            }
+            fields[fieldId] = { id: fieldId, value };
+            fieldValues.push(value);
+        }
+        // Build content from field values (joined with separator for multi-field templates)
+        const content = fieldValues.join("\n---\n");
+        const createRequest = {
+            content,
+            deckId: request.deckId,
+            templateId: request.templateId,
+            fields,
+            tags: request.tags,
+        };
+        return this.createCard(createRequest);
+    }
+    async addAttachment(request) {
+        // Infer content-type from filename if not provided
+        let contentType = request.contentType;
+        if (!contentType) {
+            const ext = request.filename.split(".").pop()?.toLowerCase();
+            const mimeTypes = {
+                png: "image/png",
+                jpg: "image/jpeg",
+                jpeg: "image/jpeg",
+                gif: "image/gif",
+                webp: "image/webp",
+                svg: "image/svg+xml",
+                mp3: "audio/mpeg",
+                wav: "audio/wav",
+                ogg: "audio/ogg",
+                mp4: "video/mp4",
+                pdf: "application/pdf",
+            };
+            contentType = mimeTypes[ext ?? ""] ?? "application/octet-stream";
+        }
+        // Convert base64 to Buffer
+        const buffer = Buffer.from(request.data, "base64");
+        // Create form data
+        const formData = new FormData();
+        formData.append("file", buffer, {
+            filename: request.filename,
+            contentType,
+        });
+        // Upload attachment
+        await this.api.post(`/cards/${request.cardId}/attachments/${encodeURIComponent(request.filename)}`, formData, {
+            headers: {
+                ...formData.getHeaders(),
+                Authorization: `Basic ${Buffer.from(`${this.token}:`).toString("base64")}`,
+            },
+        });
+        return {
+            filename: request.filename,
+            markdown: `![](@media/${request.filename})`,
+        };
+    }
 }
 // Server setup
-const server = new Server({
+const server = new McpServer({
     name: "mcp-server/mochi",
     version: "1.0.3",
-}, {
-    capabilities: {
-        tools: {},
-        resources: {},
-        prompts: {},
-    },
 });
-// Set up request handlers
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
-        {
-            name: "mochi_create_card",
-            description: `Create a new flashcard in Mochi. Use this whenever I ask questions about something that is interesting to remember. E.g. if I ask "What is the capital of France?", you should create a new flashcard with the content "What is the capital of France?\n---\nParis".
-
-## Parameters
-
-### deck-id (required)
-ALWAYS look up deck-id with the mochi_list_decks tool.
-
-### content (required)
-The markdown content of the card. Separate front and back using a horizontal rule (---).
-
-### template-id (optional)
-When using a template, the field ids MUST match the template ones. If not using a template, omit this field.
-
-### fields (optional)
-A map of field IDs (keyword) to field values. Only required when using a template. The field IDs must correspond to the fields defined on the template.
-
-## Example without template
-{
-  "content": "What is the capital of France?\n---\nParis",
-  "deck-id": "btmZUXWM"
-}
-
-## Example with template
-{
-  "content": "New card from API. ![](@media/foobar03.png)",
-  "deck-id": "btmZUXWM",
-  "template-id": "8BtaEAXe",
-  "fields": {
-    "name": {
-      "id": "name",
-      "value": "Hello,"
-    },
-    "JNEnw1e7": {
-      "id": "JNEnw1e7",
-      "value": "World!"
-    }
-  }
-}
-
-## Properties of good flashcards:
-- **focused:** A question or answer involving too much detail will dull your concentration and stimulate incomplete retrievals, leaving some bulbs unlit.
-- **precise** about what they're asking for. Vague questions will elicit vague answers, which won't reliably light the bulbs you're targeting.
-- **consistent** answers, lighting the same bulbs each time you perform the task.
-- **tractable**: Write prompts which you can almost always answer correctly. This often means breaking the task down, or adding cues
-- **effortful**: You shouldn't be able to trivially infer the answer.
-`,
-            inputSchema: zodToJsonSchema(CreateCardRequestSchema),
-            annotations: {
-                title: "Create flashcard on Mochi",
-                readOnlyHint: false,
-                destructiveHint: false,
-                idempotentHint: false,
-                openWorldHint: true,
-            },
-        },
-        {
-            name: "mochi_update_card",
-            description: `Update or delete an existing flashcard in Mochi. To delete set trashed to true.`,
-            inputSchema: zodToJsonSchema(z.object({
-                "card-id": z.string(),
-                ...UpdateCardRequestSchema.shape,
-            })),
-            annotations: {
-                title: "Update flashcard on Mochi",
-                readOnlyHint: false,
-                destructiveHint: false,
-                idempotentHint: false,
-                openWorldHint: true,
-            },
-        },
-        {
-            name: "mochi_list_cards",
-            description: "List cards in pages of 10 cards per page",
-            inputSchema: zodToJsonSchema(ListCardsParamsSchema),
-            annotations: {
-                title: "List flashcards on Mochi",
-                readOnlyHint: true,
-                destructiveHint: false,
-                idempotentHint: true,
-                openWorldHint: false,
-            },
-        },
-        {
-            name: "mochi_list_decks",
-            description: "List all decks",
-            inputSchema: zodToJsonSchema(ListDecksParamsSchema),
-            annotations: {
-                title: "List decks on Mochi",
-                readOnlyHint: true,
-                destructiveHint: false,
-                idempotentHint: true,
-                openWorldHint: false,
-            },
-        },
-        {
-            name: "mochi_list_templates",
-            description: `Templates can be used to create cards with pre-defined fields using the template_id field. 
-
-Example response:
-{
-  "bookmark": "g1AAAABAeJzLYWBgYMpgSmHgKy5JLCrJTq2MT8lPzkzJBYpzVBn4JgaaVZiC5Dlg8igyWQAxwRHd",
-  "docs": [
-    {
-      "id": "YDELNZSu",
-      "name": "Simple flashcard",
-      "content": "# << Front >>\n---\n<< Back >>",
-      "pos": "s",
-      "fields": {
-        "name": {
-          "id": "name",
-          "name": "Front",
-          "pos": "a"
-        },
-        "Ysrde7Lj": {
-          "id": "Ysrde7Lj",
-          "name": "Back",
-          "pos": "m",
-          "options": {
-            "multi-line?": true
-          }
-        }
-      }
-    },
-    ...
-  ]
-}`,
-            inputSchema: zodToJsonSchema(ListTemplatesParamsSchema),
-            annotations: {
-                title: "List templates on Mochi",
-                readOnlyHint: true,
-                destructiveHint: false,
-                idempotentHint: true,
-                openWorldHint: false,
-            },
-        },
-    ],
-}));
+// Schema for update flashcard tool (combines cardId with update fields)
+const UpdateFlashcardToolSchema = z.object({
+    cardId: z.string().describe("ID of the card to update"),
+    ...UpdateCardRequestSchema.shape,
+});
+// Output schema for attachment response
+const AddAttachmentResponseSchema = z.object({
+    filename: z.string().describe("The filename of the uploaded attachment"),
+    markdown: z
+        .string()
+        .describe("Markdown reference to use in card content, e.g. ![](@media/filename)"),
+});
 // Create Mochi client
 const mochiClient = new MochiClient(MOCHI_API_KEY);
-// Add resource handlers
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
+// Helper to format errors for tool responses
+function formatToolError(error) {
+    if (error instanceof z.ZodError) {
+        const formattedErrors = error.issues.map((issue) => {
+            const path = issue.path.join(".");
+            const message = issue.code === "invalid_type" && issue.message.includes("Required")
+                ? `Required field '${path}' is missing`
+                : issue.message;
+            return `${path ? `${path}: ` : ""}${message}`;
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Validation error:\n${formattedErrors.join("\n")}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    if (error instanceof MochiError) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Mochi API error (${error.statusCode}): ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
     return {
-        resources: [
+        content: [
             {
-                uri: `mochi://decks`,
-                name: "All Mochi Decks",
-                description: `List of all decks in Mochi.`,
-                mimeType: "application/json",
-            },
-            {
-                uri: `mochi://templates`,
-                name: "All Mochi Templates",
-                description: `List of all templates in Mochi.`,
-                mimeType: "application/json",
+                type: "text",
+                text: `Error: ${error instanceof Error ? error.message : String(error)}`,
             },
         ],
+        isError: true,
     };
+}
+// Register tools
+// Note: Using type assertions due to Zod version compatibility between SDK (v4) and project (v3)
+server.registerTool("mochi_create_flashcard", {
+    title: "Create flashcard on Mochi",
+    description: "Create a new flashcard in Mochi. Look up deckId with mochi_list_decks first. For template-based cards, prefer mochi_create_card_from_template.",
+    inputSchema: CreateCardRequestSchema,
+    outputSchema: CreateCardResponseSchema,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+}, async (args) => {
+    try {
+        const response = await mochiClient.createCard(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+            structuredContent: response,
+        };
+    }
+    catch (error) {
+        return formatToolError(error);
+    }
 });
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const uri = request.params.uri;
-    switch (uri) {
-        case "mochi://decks": {
-            const decks = await mochiClient.listDecks();
-            return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: "application/json",
-                        text: JSON.stringify(decks.map((deck) => ({
-                            id: deck.id,
-                            name: deck.name,
-                            archived: deck.archived,
-                        })), null, 2),
-                    },
-                ],
-            };
-        }
-        case "mochi://templates": {
-            const templates = await mochiClient.listTemplates();
-            return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: "application/json",
-                        text: JSON.stringify(templates, null, 2),
-                    },
-                ],
-            };
-        }
-        default: {
-            throw new Error("Invalid resource URI");
-        }
+server.registerTool("mochi_create_card_from_template", {
+    title: "Create flashcard from template on Mochi",
+    description: "Create a flashcard using a template with field names (not IDs). Preferred way to create template-based cards. Automatically maps field names to IDs. Get templates with mochi_list_templates, decks with mochi_list_decks.",
+    inputSchema: CreateCardFromTemplateSchema,
+    outputSchema: CreateCardResponseSchema,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+}, async (args) => {
+    try {
+        const response = await mochiClient.createCardFromTemplate(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+            structuredContent: response,
+        };
+    }
+    catch (error) {
+        return formatToolError(error);
     }
 });
-const CreateFlashcardPromptSchema = z.object({
-    input: z
-        .string()
-        .describe("The information to base the flashcard on.")
-        .optional(),
+server.registerTool("mochi_update_flashcard", {
+    title: "Update flashcard on Mochi",
+    description: "Update or delete an existing flashcard. Set trashed to true to delete.",
+    inputSchema: UpdateFlashcardToolSchema,
+    outputSchema: UpdateCardResponseSchema,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+}, async (args) => {
+    try {
+        const { cardId, ...updateArgs } = args;
+        const response = await mochiClient.updateCard(cardId, updateArgs);
+        return {
+            content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+            structuredContent: response,
+        };
+    }
+    catch (error) {
+        return formatToolError(error);
+    }
+});
+server.registerTool("mochi_add_attachment", {
+    title: "Add attachment to flashcard on Mochi",
+    description: "Add an attachment (image, audio, etc.) to a card using base64 data. For URL-based images, just use markdown directly in card content instead.",
+    inputSchema: AddAttachmentSchema,
+    outputSchema: AddAttachmentResponseSchema,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+}, async (args) => {
+    try {
+        const response = await mochiClient.addAttachment(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+            structuredContent: response,
+        };
+    }
+    catch (error) {
+        return formatToolError(error);
+    }
+});
+server.registerTool("mochi_list_flashcards", {
+    title: "List flashcards on Mochi",
+    description: "List flashcards, optionally filtered by deck. Returns paginated results.",
+    inputSchema: ListCardsParamsSchema.shape,
+    outputSchema: ListCardsResponseSchema,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async (args) => {
+    try {
+        const response = await mochiClient.listCards(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+            structuredContent: response,
+        };
+    }
+    catch (error) {
+        return formatToolError(error);
+    }
+});
+server.registerTool("mochi_list_decks", {
+    title: "List decks on Mochi",
+    description: "List all decks. Use to get deckId for other operations.",
+    inputSchema: ListDecksParamsSchema.shape,
+    outputSchema: ListDecksResponseSchema,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async (args) => {
+    try {
+        const response = await mochiClient.listDecks(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+            structuredContent: { bookmark: "", docs: response },
+        };
+    }
+    catch (error) {
+        return formatToolError(error);
+    }
+});
+server.registerTool("mochi_list_templates", {
+    title: "List templates on Mochi",
+    description: "List all templates. Use with mochi_create_card_from_template for easy template-based card creation.",
+    inputSchema: ListTemplatesParamsSchema.shape,
+    outputSchema: ListTemplatesResponseSchema,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async (args) => {
+    try {
+        const response = await mochiClient.listTemplates(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+            structuredContent: response,
+        };
+    }
+    catch (error) {
+        return formatToolError(error);
+    }
+});
+server.registerTool("mochi_get_due_cards", {
+    title: "Get due flashcards on Mochi",
+    description: "Get flashcards due for review on a specific date (defaults to today).",
+    inputSchema: GetDueCardsParamsSchema.shape,
+    outputSchema: GetDueCardsResponseSchema,
+    annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async (args) => {
+    try {
+        const response = await mochiClient.getDueCards(args);
+        return {
+            content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+            structuredContent: response,
+        };
+    }
+    catch (error) {
+        return formatToolError(error);
+    }
 });
-server.setRequestHandler(ListPromptsRequestSchema, async () => {
+// Register resources
+server.registerResource("decks", "mochi://decks", {
+    description: "List of all decks in Mochi.",
+    mimeType: "application/json",
+}, async () => {
+    const decks = await mochiClient.listDecks();
     return {
-        prompts: [
+        contents: [
             {
-                name: "write-flashcard",
-                description: "Write a flashcard based on user-provided information.",
-                arguments: [
-                    {
-                        name: "input",
-                        description: "The information to base the flashcard on.",
-                    },
-                ],
+                uri: "mochi://decks",
+                mimeType: "application/json",
+                text: JSON.stringify(decks.map((deck) => ({ id: deck.id, name: deck.name })), null, 2),
             },
         ],
     };
 });
-server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-    const params = CreateFlashcardPromptSchema.parse(request.params.arguments);
-    const { input } = params;
+server.registerResource("templates", "mochi://templates", {
+    description: "List of all templates in Mochi.",
+    mimeType: "application/json",
+}, async () => {
+    const templates = await mochiClient.listTemplates();
     return {
-        messages: [
+        contents: [
             {
-                role: "user",
-                content: {
-                    type: "text",
-                    text: `Create a flashcard using the info below while adhering to these principles: 
+                uri: "mochi://templates",
+                mimeType: "application/json",
+                text: JSON.stringify(templates, null, 2),
+            },
+        ],
+    };
+});
+// Register prompts
+server.registerPrompt("write-flashcard", {
+    description: "Write a flashcard based on user-provided information.",
+    argsSchema: {
+        input: z
+            .string()
+            .describe("The information to base the flashcard on.")
+            .optional(),
+    },
+}, async ({ input }) => ({
+    messages: [
+        {
+            role: "user",
+            content: {
+                type: "text",
+                text: `Create a flashcard using the info below while adhering to these principles:
 - Keep questions and answers atomic.
 - Utilize cloze prompts when applicable, like "This is a text with {{hidden}} part. Then don't use '---' separator.".
 - Focus on effective retrieval practice by being concise and clear.
 - Make it just challenging enough to reinforce specific facts.
 Input: ${input}
 `,
-                },
             },
-        ],
-    };
-});
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    try {
-        switch (request.params.name) {
-            case "mochi_create_card": {
-                const validatedArgs = CreateCardRequestSchema.parse(request.params.arguments);
-                const response = await mochiClient.createCard(validatedArgs);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(response, null, 2),
-                        },
-                    ],
-                    isError: false,
-                };
-            }
-            case "mochi_update_card": {
-                const { "card-id": cardId, ...updateArgs } = z
-                    .object({
-                    "card-id": z.string(),
-                    ...UpdateCardRequestSchema.shape,
-                })
-                    .parse(request.params.arguments);
-                const response = await mochiClient.updateCard(cardId, updateArgs);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(response, null, 2),
-                        },
-                    ],
-                    isError: false,
-                };
-            }
-            case "mochi_list_decks": {
-                const validatedArgs = ListDecksParamsSchema.parse(request.params.arguments);
-                const response = await mochiClient.listDecks(validatedArgs);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(response, null, 2),
-                        },
-                    ],
-                    isError: false,
-                };
-            }
-            case "mochi_list_cards": {
-                const validatedArgs = ListCardsParamsSchema.parse(request.params.arguments);
-                const response = await mochiClient.listCards(validatedArgs);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(response, null, 2),
-                        },
-                    ],
-                    isError: false,
-                };
-            }
-            case "mochi_list_templates": {
-                const validatedArgs = ListTemplatesParamsSchema.parse(request.params.arguments);
-                const response = await mochiClient.listTemplates(validatedArgs);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(response, null, 2),
-                        },
-                    ],
-                    isError: false,
-                };
-            }
-            default:
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Unknown tool: ${request.params.name}`,
-                        },
-                    ],
-                    isError: true,
-                };
-        }
-    }
-    catch (error) {
-        if (error instanceof z.ZodError) {
-            const formattedErrors = error.errors.map((err) => {
-                const path = err.path.join(".");
-                const message = err.code === "invalid_type" && err.message.includes("Required")
-                    ? `Required field '${path}' is missing`
-                    : err.message;
-                return `${path ? `${path}: ` : ""}${message}`;
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Validation error:\n${formattedErrors.join("\n")}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        if (error instanceof MochiError) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Mochi API error (${error.statusCode}): ${error.message}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-});
+        },
+    ],
+}));
 async function runServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);