@olivaresai/alma-mcp 1.3.0 → 1.3.2

package/README.md

@@ -1,36 +1,52 @@
+<div align="center">
+
 # @olivaresai/alma-mcp
 
-MCP (Model Context Protocol) server for [Alma](https://alma.olivares.ai) — persistent memory for AI agents. Gives any MCP-compatible client (Claude Desktop, Cursor, Windsurf, etc.) full access to Alma's memory, context, and chat capabilities.
+**MCP Server for [Alma](https://alma.olivares.ai) — persistent memory for AI agents.**
 
-## Setup
+[![npm](https://img.shields.io/npm/v/@olivaresai/alma-mcp?color=FE9A37)](https://www.npmjs.com/package/@olivaresai/alma-mcp)
+[![MCP](https://img.shields.io/badge/MCP-compatible-3178c6)](https://modelcontextprotocol.io)
+[![Node](https://img.shields.io/badge/Node.js-18+-339933)](https://nodejs.org)
 
-```bash
-npm install -g @olivaresai/alma-mcp
-```
+</div>
+
+---
+
+Gives any MCP-compatible AI client full access to Alma's persistent memory, context assembly, chat, and data management. Your AI remembers everything — across sessions, tools, and platforms.
+
+## Setup
 
 ### Claude Desktop / Cursor / Windsurf
 
-Add to your MCP configuration (`claude_desktop_config.json` or equivalent):
+Add to your MCP configuration:
 
 ```json
 {
   "mcpServers": {
     "alma": {
-      "command": "alma-mcp",
+      "command": "npx",
+      "args": ["@olivaresai/alma-mcp"],
       "env": {
-        "ALMA_API_KEY": "your-api-key",
-        "ALMA_BASE_URL": "https://alma.olivares.ai/api/v1"
+        "ALMA_API_KEY": "alma_sk_..."
       }
     }
   }
 }
 ```
 
+### Global install (alternative)
+
+```bash
+npm install -g @olivaresai/alma-mcp
+```
+
+Then use `"command": "alma-mcp"` instead of `npx`.
+
 ### Environment Variables
 
 | Variable | Required | Description |
 |----------|----------|-------------|
-| `ALMA_API_KEY` | Yes | Your Alma API key |
+| `ALMA_API_KEY` | Yes | Your Alma API key ([get one here](https://alma.olivares.ai/settings)) |
 | `ALMA_BASE_URL` | No | API base URL (default: `https://alma.olivares.ai/api/v1`) |
 | `ALMA_ENVIRONMENT_ID` | No | Default environment ID |
 | `ALMA_DEBUG` | No | Enable debug logging |
@@ -39,107 +55,88 @@ Add to your MCP configuration (`claude_desktop_config.json` or equivalent):
 
 ### Context
 
-| Tool | Description | Parameters |
-|------|-------------|------------|
-| `alma_assemble` | Build a complete system prompt from Alma — includes identity (soul), relevant memories, recent episodes, and learned procedures. Use this before sending a message to an LLM. | `message` (required), `environment_id`, `token_budget` |
-| `alma_preview_context` | Preview the full system prompt that Alma would assemble. Shows exactly what the LLM sees. Useful for debugging. | `message` |
-| `alma_focus` | Update Alma's active context focus. Tell Alma what you're currently working on so it can prioritize relevant memories. | `context` (required, max 2000 chars), `source` (web/extension/mcp/api) |
-| `alma_continue_session` | Continue a session after context limit, new session, or error. Generates a summary and continuation prompt. | `conversation_text` (required), `reason` (required: context_limit/new_session/error), `environment_id` |
+| Tool | Description |
+|------|-------------|
+| `alma_assemble` | Build a complete system prompt — soul, memories, episodes, procedures |
+| `alma_preview_context` | Preview the exact system prompt the LLM would see |
+| `alma_focus` | Update active context focus (what you're working on) |
+| `alma_continue_session` | Continue after context limit, new session, or error |
 
 ### Memory
 
-| Tool | Description | Parameters |
-|------|-------------|------------|
-| `alma_remember` | Store a new memory in Alma. | `content` (required, max 50000 chars), `category` (general/preference/fact/decision/project), `importance` (0-1) |
-| `alma_recall` | Search memories by keyword. | `query` (required), `limit` (1-50, default 10) |
-| `alma_search` | Advanced memory search with filters — keyword, semantic, or hybrid mode with date ranges and importance thresholds. | `query` (required), `mode` (keyword/semantic/hybrid), `from`/`to` (ISO dates), `category`, `min_importance` (0-1), `limit` (1-50) |
-| `alma_delete_memory` | Delete a specific memory by ID. | `id` (required) |
-| `alma_extract` | Extract memories and episodes from a block of text (conversation, meeting notes, etc.). | `text` (required, 10-200K chars), `save` (default true), `environment_id` |
-
-### Episodes
-
-| Tool | Description | Parameters |
-|------|-------------|------------|
-| `alma_list_episodes` | List conversation episodes (summaries with topics and outcomes). | `limit` (1-100, default 20), `offset` |
-| `alma_search_episodes` | Search episodes by topic. | `topic` (required), `limit` (1-50, default 10) |
-| `alma_create_episode` | Create a new episode manually. | `summary` (required, max 5000 chars), `topics` (string array), `outcome` |
-
-### Procedures
-
-| Tool | Description | Parameters |
-|------|-------------|------------|
-| `alma_list_procedures` | List stored procedures (trigger-action rules). | `limit` (1-100, default 50), `offset` |
-| `alma_create_procedure` | Create a new procedure. | `trigger_pattern` (required), `action` (required), `context` |
-
-### Soul & Blocks
-
-| Tool | Description | Parameters |
-|------|-------------|------------|
-| `alma_update_block` | Update a soul memory block (identity, rules, language, etc.). | `label` (required), `value` (required) |
-
-### Chat
-
-| Tool | Description | Parameters |
-|------|-------------|------------|
-| `alma_chat` | Send a message to Alma and get a response. Supports 3 Claude models. | `message` (required), `conversation_id`, `environment_id`, `model` |
-
-### Images
-
-| Tool | Description | Parameters |
-|------|-------------|------------|
-| `alma_generate_image` | Generate an image via Alma's Image Studio (Replicate Flux / Leonardo). Requires a paid plan. | `prompt` (required), `style` (natural/vivid/artistic), `size` (square/landscape/portrait) |
-
-### Memory Management
-
-| Tool | Description | Parameters |
-|------|-------------|------------|
-| `alma_update_memory` | Update an existing memory's content, category, or importance. | `id` (required), `content`, `category`, `importance` (0-1) |
-
-### Environments
-
-| Tool | Description | Parameters |
-|------|-------------|------------|
-| `alma_list_environments` | List all available environments. | _(none)_ |
-| `alma_create_environment` | Create a new environment. | `name` (required, max 100 chars) |
-
-### Data
-
-| Tool | Description | Parameters |
-|------|-------------|------------|
-| `alma_export` | Export data from Alma (conversations, memories, soul, or all). | `type` (required: conversation/memories/soul/all), `format` (md/json/html), `conversation_id` |
+| Tool | Description |
+|------|-------------|
+| `alma_remember` | Store a new memory |
+| `alma_recall` | Quick keyword search across memories |
+| `alma_search` | Advanced search — keyword, semantic, or hybrid with filters |
+| `alma_update_memory` | Update an existing memory's content, category, or importance |
+| `alma_delete_memory` | Delete a specific memory |
+| `alma_extract` | Extract memories and episodes from text (conversations, notes) |
+
+### Episodes & Procedures
+
+| Tool | Description |
+|------|-------------|
+| `alma_list_episodes` | List conversation episode summaries |
+| `alma_search_episodes` | Search episodes by topic |
+| `alma_create_episode` | Create a new episode manually |
+| `alma_list_procedures` | List trigger-action behavioral rules |
+| `alma_create_procedure` | Create a new procedure |
+
+### Soul, Chat & More
+
+| Tool | Description |
+|------|-------------|
+| `alma_update_block` | Update a soul memory block (identity, rules, etc.) |
+| `alma_chat` | Send a message to Alma and get a response |
+| `alma_generate_image` | Generate an image via Image Studio |
+| `alma_export` | Export data (conversations, memories, soul, all) |
+| `alma_list_environments` | List all environments |
+| `alma_create_environment` | Create a new environment |
 
 ## Resources (9)
 
 | Resource URI | Description |
 |-------------|-------------|
-| `alma://soul` | Current soul configuration (identity, personality, tone, rules) |
+| `alma://soul` | Current soul configuration |
 | `alma://memories` | Recent memories (last 50) |
-| `alma://memories/{category}` | Memories filtered by category (general, preference, fact, decision, project) |
+| `alma://memories/{category}` | Memories by category (general, preference, fact, decision, project) |
 | `alma://environments` | All available environments |
-| `alma://conversations` | Recent chat conversations (last 20) |
-| `alma://budget` | Current token budget status (usage, remaining, purchased) |
-| `alma://blocks` | All memory blocks (identity, worldview, style, rules, etc.) |
+| `alma://conversations` | Recent conversations (last 20) |
+| `alma://budget` | Token budget status |
+| `alma://blocks` | All soul memory blocks |
 | `alma://episodes` | Recent episodes (last 20) |
 | `alma://procedures` | All stored procedures (limit 50) |
 
-## Supported Models
+## Models
 
-3 models (Anthropic Claude):
+3 Claude models available via `alma_chat`:
 
-| Model | Tier | Best For |
-|-------|------|----------|
-| `claude-haiku` | Normal | Fast responses, simple tasks |
-| `claude-sonnet` | Advanced | Balanced quality and speed |
-| `claude-opus` | Complex | Highest quality, deep reasoning |
+| Model | Best For |
+|-------|----------|
+| `claude-haiku` | Fast responses, simple tasks |
+| `claude-sonnet` | Balanced quality and speed |
+| `claude-opus` | Deep reasoning, complex work |
+
+## Compatible Clients
+
+- **Claude Desktop** — Anthropic's official desktop app
+- **Cursor** — AI-powered code editor
+- **Windsurf** — AI development environment
+- Any [MCP-compatible](https://modelcontextprotocol.io) client
 
 ## Links
 
-- [Alma Platform](https://alma.olivares.ai)
-- [Documentation](https://alma.olivares.ai/docs)
-- [SDK](https://www.npmjs.com/package/@olivaresai/alma-sdk)
+- [Alma App](https://alma.olivares.ai)
+- [Documentation](https://olivares.ai/docs)
+- [JavaScript SDK](https://www.npmjs.com/package/@olivaresai/alma-sdk)
 - [VSCode Extension](https://marketplace.visualstudio.com/items?itemName=olivares.alma-vscode)
-- [OlivaresAI](https://olivares.ai)
+- [GitHub](https://github.com/olivaresai/alma)
+
+---
+
+<div align="center">
 
-## License
+*Built by [olivares.ai](https://olivares.ai) — Give your AI a soul.*
 
-Proprietary. See [LICENSE](https://github.com/olivaresai/alma/blob/main/LICENSE) for details.
+</div>

package/dist/index.js

@@ -328,6 +328,87 @@ var AlmaClient = class _AlmaClient {
   async createProcedure(params) {
     return this.request("POST", "/procedures", params);
   }
+  // ─── Cowork (Collaborative Workspaces) ─────────────
+  async listWorkspaces() {
+    return this.request("GET", "/cowork/workspaces");
+  }
+  async createWorkspace(params) {
+    return this.request("POST", "/cowork/workspaces", params);
+  }
+  async listWorkspaceFiles(workspaceId) {
+    return this.request(
+      "GET",
+      `/cowork/workspaces/${encodeURIComponent(workspaceId)}/files`
+    );
+  }
+  async readWorkspaceFile(workspaceId, filePath) {
+    const qs = new URLSearchParams({ path: filePath });
+    return this.request(
+      "GET",
+      `/cowork/workspaces/${encodeURIComponent(workspaceId)}/files/read?${qs}`
+    );
+  }
+  async writeWorkspaceFile(workspaceId, filePath, content) {
+    return this.request(
+      "POST",
+      `/cowork/workspaces/${encodeURIComponent(workspaceId)}/files/write`,
+      { path: filePath, content }
+    );
+  }
+  async searchWorkspace(workspaceId, query) {
+    const qs = new URLSearchParams({ q: query });
+    return this.request(
+      "GET",
+      `/cowork/workspaces/${encodeURIComponent(workspaceId)}/search?${qs}`
+    );
+  }
+  async executeSkill(workspaceId, params) {
+    return this.request(
+      "POST",
+      `/cowork/workspaces/${encodeURIComponent(workspaceId)}/skills`,
+      params
+    );
+  }
+  async applyDiff(workspaceId, operationId) {
+    return this.request(
+      "POST",
+      `/cowork/workspaces/${encodeURIComponent(workspaceId)}/apply`,
+      { operationId }
+    );
+  }
+  // ─── Video ────────────────────────────────────────
+  async generateVideo(params) {
+    return this.request("POST", "/video/generate", params);
+  }
+  async checkVideoJob(jobId) {
+    return this.request(
+      "GET",
+      `/video/jobs/${encodeURIComponent(jobId)}`
+    );
+  }
+  async listVideoProjects() {
+    return this.request("GET", "/video/projects");
+  }
+  async createVideoProject(params) {
+    return this.request("POST", "/video/projects", params);
+  }
+  async planVideoScenes(projectId, params) {
+    return this.request(
+      "POST",
+      `/video/projects/${encodeURIComponent(projectId)}/plan`,
+      params
+    );
+  }
+  async stitchVideo(projectId, jobIds) {
+    return this.request(
+      "POST",
+      `/video/projects/${encodeURIComponent(projectId)}/stitch`,
+      { jobIds }
+    );
+  }
+  async getVideoBudget() {
+    return this.request("GET", "/video/budget");
+  }
 };
 
 // src/tools/assemble.ts
@@ -1232,12 +1313,470 @@ ${JSON.stringify(result.memory, null, 2)}`
   );
 }
 
+// src/tools/cowork.ts
+import { z as z18 } from "zod";
+function registerCoworkTools(server2, client2) {
+  server2.registerTool(
+    "cowork_list_workspaces",
+    {
+      title: "List Workspaces",
+      description: "List all collaborative workspaces available to the user. Returns workspace IDs, names, and metadata.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const result = await client2.listWorkspaces();
+        if (result.workspaces.length === 0) {
+          return {
+            content: [{ type: "text", text: "No workspaces found." }]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_create_workspace",
+    {
+      title: "Create Workspace",
+      description: "Create a new collaborative workspace. Workspaces hold files that Alma can read, write, and operate on.",
+      inputSchema: {
+        name: z18.string().min(1).max(200).describe("Name for the workspace"),
+        description: z18.string().max(1e3).optional().describe("Optional description of the workspace purpose"),
+        sourceType: z18.string().optional().describe('Source type for the workspace (e.g. "blank", "template", "import")')
+      }
+    },
+    async ({ name, description, sourceType }) => {
+      try {
+        const result = await client2.createWorkspace({ name, description, sourceType });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Workspace created successfully.
+${JSON.stringify(result.workspace, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_list_files",
+    {
+      title: "List Workspace Files",
+      description: "List all files in a collaborative workspace. Returns file paths, sizes, and metadata.",
+      inputSchema: {
+        workspaceId: z18.string().min(1).describe("The workspace ID to list files from")
+      }
+    },
+    async ({ workspaceId }) => {
+      try {
+        const result = await client2.listWorkspaceFiles(workspaceId);
+        if (result.files.length === 0) {
+          return {
+            content: [{ type: "text", text: "No files found in this workspace." }]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_read_file",
+    {
+      title: "Read Workspace File",
+      description: "Read the content of a file in a collaborative workspace. Returns the file content and metadata.",
+      inputSchema: {
+        workspaceId: z18.string().min(1).describe("The workspace ID containing the file"),
+        filePath: z18.string().min(1).describe("Path of the file within the workspace")
+      }
+    },
+    async ({ workspaceId, filePath }) => {
+      try {
+        const result = await client2.readWorkspaceFile(workspaceId, filePath);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result.file, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_write_file",
+    {
+      title: "Write Workspace File",
+      description: "Write or update a file in a collaborative workspace. Creates the file if it does not exist.",
+      inputSchema: {
+        workspaceId: z18.string().min(1).describe("The workspace ID to write the file in"),
+        filePath: z18.string().min(1).describe("Path of the file within the workspace"),
+        content: z18.string().describe("The content to write to the file")
+      }
+    },
+    async ({ workspaceId, filePath, content }) => {
+      try {
+        const result = await client2.writeWorkspaceFile(workspaceId, filePath, content);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `File written successfully.
+${JSON.stringify(result.file, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_search",
+    {
+      title: "Search Workspace",
+      description: "Search across all files in a collaborative workspace. Returns matching files and content snippets.",
+      inputSchema: {
+        workspaceId: z18.string().min(1).describe("The workspace ID to search in"),
+        query: z18.string().min(1).describe("Search query string")
+      }
+    },
+    async ({ workspaceId, query }) => {
+      try {
+        const result = await client2.searchWorkspace(workspaceId, query);
+        if (result.results.length === 0) {
+          return {
+            content: [{ type: "text", text: `No results found for: ${query}` }]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_execute_skill",
+    {
+      title: "Execute Skill",
+      description: "Run an AI skill on a file or input within a collaborative workspace. Available skills: explain, refactor, review, test, fix, document, search, commit.",
+      inputSchema: {
+        workspaceId: z18.string().min(1).describe("The workspace ID to execute the skill in"),
+        skill: z18.enum(["explain", "refactor", "review", "test", "fix", "document", "search", "commit"]).describe("The skill to execute"),
+        targetPath: z18.string().optional().describe("Optional file path to target with the skill"),
+        input: z18.string().min(1).describe("Input or instructions for the skill execution")
+      }
+    },
+    async ({ workspaceId, skill, targetPath, input }) => {
+      try {
+        const result = await client2.executeSkill(workspaceId, { skill, targetPath, input });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Skill "${skill}" executed successfully.
+${JSON.stringify(result.result, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "cowork_apply_diff",
+    {
+      title: "Apply Operation Diff",
+      description: "Apply a pending operation diff to a workspace file. Use after executing a skill that produces changes.",
+      inputSchema: {
+        workspaceId: z18.string().min(1).describe("The workspace ID containing the operation"),
+        operationId: z18.string().min(1).describe("The operation ID whose diff should be applied")
+      }
+    },
+    async ({ workspaceId, operationId }) => {
+      try {
+        const result = await client2.applyDiff(workspaceId, operationId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.applied ? `Diff applied successfully.
+${JSON.stringify(result.result, null, 2)}` : "Diff could not be applied. The operation may have already been applied or expired."
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/video.ts
+import { z as z19 } from "zod";
+function registerVideoTools(server2, client2) {
+  server2.registerTool(
+    "video_generate",
+    {
+      title: "Generate Video",
+      description: "Start an AI video generation job. Returns a job ID to track progress. Requires a paid plan with video credits.",
+      inputSchema: {
+        prompt: z19.string().min(1).max(2e3).describe("Text description of the video to generate"),
+        model: z19.string().min(1).describe('Video generation model to use (e.g. "runway-gen3", "kling-v1", "pika-v2")'),
+        durationSeconds: z19.number().int().min(1).max(60).describe("Duration of the video in seconds (1-60)"),
+        aspectRatio: z19.enum(["16:9", "9:16", "1:1", "4:3", "3:4"]).optional().describe("Aspect ratio of the video (default: 16:9)"),
+        style: z19.string().max(200).optional().describe('Optional style modifier (e.g. "cinematic", "anime", "documentary")')
+      }
+    },
+    async ({ prompt, model, durationSeconds, aspectRatio, style }) => {
+      try {
+        const result = await client2.generateVideo({ prompt, model, durationSeconds, aspectRatio, style });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Video generation started.
+${JSON.stringify(result.job, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "video_check_job",
+    {
+      title: "Check Video Job",
+      description: "Check the status of a video generation job. Returns status, progress percentage, and result URL when complete.",
+      inputSchema: {
+        jobId: z19.string().min(1).describe("The video generation job ID to check")
+      }
+    },
+    async ({ jobId }) => {
+      try {
+        const result = await client2.checkVideoJob(jobId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result.job, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "video_list_projects",
+    {
+      title: "List Video Projects",
+      description: "List all video projects for the user. Projects organize multiple video scenes into a cohesive production.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const result = await client2.listVideoProjects();
+        if (result.projects.length === 0) {
+          return {
+            content: [{ type: "text", text: "No video projects found." }]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "video_create_project",
+    {
+      title: "Create Video Project",
+      description: "Create a new video project. Projects let you plan scenes, generate clips, and stitch them into a final video.",
+      inputSchema: {
+        name: z19.string().min(1).max(200).describe("Name for the video project"),
+        description: z19.string().max(1e3).optional().describe("Optional description of the video project")
+      }
+    },
+    async ({ name, description }) => {
+      try {
+        const result = await client2.createVideoProject({ name, description });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Video project created successfully.
+${JSON.stringify(result.project, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "video_plan_scenes",
+    {
+      title: "Plan Video Scenes",
+      description: "Use AI to plan scenes for a video project. Breaks a description into individual scene prompts with timing and transitions.",
+      inputSchema: {
+        projectId: z19.string().min(1).describe("The video project ID to plan scenes for"),
+        description: z19.string().min(1).max(5e3).describe("Description of the video to plan (story, concept, or script)"),
+        sceneCount: z19.number().int().min(1).max(20).optional().describe("Number of scenes to plan (default: auto-determined by AI)")
+      }
+    },
+    async ({ projectId, description, sceneCount }) => {
+      try {
+        const result = await client2.planVideoScenes(projectId, { description, sceneCount });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Scene plan created (${result.scenes.length} scenes).
+${JSON.stringify(result.scenes, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "video_stitch",
+    {
+      title: "Stitch Video",
+      description: "Stitch multiple generated video scenes into a single final video. All referenced jobs must be complete.",
+      inputSchema: {
+        projectId: z19.string().min(1).describe("The video project ID"),
+        jobIds: z19.array(z19.string().min(1)).min(1).max(20).describe("Ordered list of completed video job IDs to stitch together")
+      }
+    },
+    async ({ projectId, jobIds }) => {
+      try {
+        const result = await client2.stitchVideo(projectId, jobIds);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Video stitch job started.
+${JSON.stringify(result.job, null, 2)}`
+            }
+          ]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // src/index.ts
 var config = loadConfig();
 var client = new AlmaClient(config);
 var server = new McpServer({
   name: "alma-mcp",
-  version: "1.3.0"
+  version: "1.3.2"
 });
 registerAssembleTool(server, client);
 registerRememberTool(server, client);
@@ -1260,6 +1799,8 @@ registerListProceduresTool(server, client);
 registerCreateProcedureTool(server, client);
 registerPreviewContextTool(server, client);
 registerUpdateMemoryTool(server, client);
+registerCoworkTools(server, client);
+registerVideoTools(server, client);
 server.registerResource(
   "soul",
   "alma://soul",
@@ -1400,6 +1941,34 @@ server.registerResource(
     }
   }
 );
+server.registerResource(
+  "video-budget",
+  "alma://video-budget",
+  {
+    title: "Video Budget",
+    description: "Current video generation credits, usage, and remaining quota",
+    mimeType: "application/json"
+  },
+  async (uri) => {
+    try {
+      const result = await client.getVideoBudget();
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      return {
+        contents: [{ uri: uri.href, mimeType: "text/plain", text: `Error loading resource: ${message}` }]
+      };
+    }
+  }
+);
 server.registerResource(
   "memories-by-category",
   new ResourceTemplate("alma://memories/{category}", {
@@ -1523,10 +2092,76 @@ server.registerResource(
     }
   }
 );
+server.prompt(
+  "alma-context",
+  "Assemble Alma's full context: soul identity, relevant memories, recent episodes, and procedures. Use this to give the AI persistent memory about the user.",
+  {},
+  async () => {
+    try {
+      const result = await client.assembleContext({ message: "general conversation" });
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `The following is your persistent memory and identity context from Alma. Use it to personalize your responses:
+
+${result.system_prompt}`
+            }
+          }
+        ]
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unknown error";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `[Alma context unavailable: ${message}]`
+            }
+          }
+        ]
+      };
+    }
+  }
+);
+server.prompt(
+  "alma-recall",
+  "Search Alma's memory for information about a specific topic.",
+  { topic: { description: "The topic to recall memories about", required: true } },
+  async (args) => {
+    try {
+      const result = await client.searchMemories({ q: args.topic ?? "", limit: 10 });
+      const memoryText = result.memories.length > 0 ? result.memories.map((m) => `- ${m.content} (${m.category}, importance: ${m.importance})`).join("\n") : "No memories found for this topic.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Here is what Alma remembers about "${args.topic}":
+
+${memoryText}`
+            }
+          }
+        ]
+      };
+    } catch {
+      return {
+        messages: [
+          { role: "user", content: { type: "text", text: `[Could not recall memories for "${args.topic}"]` } }
+        ]
+      };
+    }
+  }
+);
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("[alma-mcp] Server started on stdio (v1.3.0, 21 tools, 9 resources)");
+  console.error("[alma-mcp] Server started on stdio (v1.3.2, 35 tools, 10 resources, 2 prompts)");
   if (process.env.ALMA_DEBUG) {
     console.error(`[alma-mcp] API: ${config.baseUrl}`);
     if (config.environmentId) {

package/package.json

@@ -1,20 +1,30 @@
 {
   "name": "@olivaresai/alma-mcp",
-  "version": "1.3.0",
-  "description": "MCP Server for Alma — persistent memory for AI agents",
+  "version": "1.3.2",
+  "description": "MCP Server for Alma by OlivaresAI — persistent memory for AI agents",
   "type": "module",
   "bin": {
     "alma-mcp": "./dist/index.js"
   },
   "main": "dist/index.js",
-  "files": ["dist", "README.md", "LICENSE"],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsx src/index.ts",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": ["mcp", "alma", "ai", "memory", "persistent-memory", "ai-agent", "model-context-protocol", "claude", "cursor", "windsurf", "llm"],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "alma",
+    "ai",
+    "memory",
+    "persistent-memory",
+    "ai-agent",
+    "model-context-protocol",
+    "claude",
+    "cursor",
+    "windsurf",
+    "llm"
+  ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.0",
     "zod": "^3.24.0"
@@ -35,5 +45,9 @@
   },
   "author": "OlivaresAI",
   "license": "SEE LICENSE IN LICENSE",
-  "pnpm": {}
-}
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit"
+  }
+}