@drawcall/design 0.5.12 → 0.6.0

package/README.md

@@ -46,17 +46,13 @@ program.addCommand(createDesignCommand());
 The MCP tools can be mounted into a server owned by another package:
 
 ```ts
-import {
-  createDesignMcpOperations,
-  registerDesignTools,
-  v1,
-} from "@drawcall/design";
+import { registerDesignTools, v1 } from "@drawcall/design";
 import { McpServer } from "@modelcontextprotocol/server";
 
 const client = v1.createClient({ authToken: process.env.DRAWCALL_AUTH_TOKEN });
 const server = new McpServer({ name: "mcp.drawcall.ai", version: "1.0.0" });
 
-registerDesignTools(server, createDesignMcpOperations(client));
+registerDesignTools(server, client);
 ```
 
 The host owns the server identity, authentication, and transport. The MCP SDK

package/dist/browser.d.ts

@@ -1,5 +1,5 @@
 export * as v1 from "./v1/index.js";
-export { createDesignMcpOperations, registerDesignTools, type DesignMcpOperationRunner, type DesignMcpOperations, type DesignMcpServer, type DesignMcpScreenshot, type DesignMcpToolResult, } from "./mcp/index.js";
+export { registerDesignTools, type DesignMcpOptions, type DesignMcpServer, type DesignMcpToolResult, } from "./mcp/index.js";
 export { cliDesignSkill, mcpDesignSkill } from "./skill.generated.js";
 export { frameCreationCapabilities, type FrameCreationCapability, type FrameCreationCapabilityId, type FrameCreationInput, } from "./v1/capabilities.js";
 export { cameraPoseSchema, IMAGE_GENERATION_MODEL, IMAGE_GENERATION_PROVIDER, } from "./v1/schemas.js";

package/dist/browser.js

@@ -1,5 +1,5 @@
 export * as v1 from "./v1/index.js";
-export { createDesignMcpOperations, registerDesignTools, } from "./mcp/index.js";
+export { registerDesignTools, } from "./mcp/index.js";
 export { cliDesignSkill, mcpDesignSkill } from "./skill.generated.js";
 export { frameCreationCapabilities, } from "./v1/capabilities.js";
 export { cameraPoseSchema, IMAGE_GENERATION_MODEL, IMAGE_GENERATION_PROVIDER, } from "./v1/schemas.js";

package/dist/mcp/file.d.ts

@@ -1,2 +1,3 @@
-import type { DesignMcpOperationRunner, DesignMcpOperations, DesignMcpServer } from "./types.js";
-export declare function registerFileTools(server: DesignMcpServer, design: DesignMcpOperations, run: DesignMcpOperationRunner): void;
+import type { DesignV1Client } from "../v1/client.js";
+import type { DesignMcpServer } from "./types.js";
+export declare function registerFileTools(server: DesignMcpServer, client: DesignV1Client): void;

package/dist/mcp/file.js

@@ -1,7 +1,7 @@
 import { fileTextSchema } from "../v1/schemas.js";
 import { fileResult, result } from "./result.js";
 import { directoryPathSchema, fileInput, projectInput } from "./schema.js";
-export function registerFileTools(server, design, run) {
+export function registerFileTools(server, client) {
     server.registerTool("list_files", {
         description: "Return canonical project-absolute paths. Omit path to list the entire project; otherwise use /<frame-id> without a trailing slash. Pass returned file paths unchanged to file tools.",
         inputSchema: projectInput.extend({
@@ -13,7 +13,10 @@ export function registerFileTools(server, design, run) {
             openWorldHint: false,
             idempotentHint: true,
         },
-    }, async ({ project, path }) => result(await run("list_files", () => design.listFiles(project, path))));
+    }, async ({ project, path }) => result(await client.filesystem.list({
+        project,
+        ...(path === undefined ? {} : { path }),
+    })));
     server.registerTool("read_file", {
         description: "Read one canonical project-absolute path returned by list_files. The path includes the frame ID; this tool does not accept a frame argument. Binary files return their hosted URL and media type.",
         inputSchema: fileInput,
@@ -24,7 +27,7 @@ export function registerFileTools(server, design, run) {
             idempotentHint: true,
         },
     }, async ({ project, path }) => {
-        const file = await run("read_file", () => design.readFile(project, path));
+        const file = await client.filesystem.read({ project, path });
         return file.type === "text" ? fileResult(file) : result(file);
     });
     server.registerTool("write_file", {
@@ -35,7 +38,7 @@ export function registerFileTools(server, design, run) {
             destructiveHint: true,
             openWorldHint: true,
         },
-    }, async ({ project, path, text }) => result(await run("write_file", () => design.writeFile(project, path, text))));
+    }, async ({ project, path, text }) => result(await client.filesystem.write({ project, path, text })));
     server.registerTool("edit_file", {
         description: "Replace oldText when it occurs exactly once at a canonical project-absolute .glts path. The path includes the frame ID; this tool does not accept a frame argument.",
         inputSchema: fileInput.extend({
@@ -47,7 +50,7 @@ export function registerFileTools(server, design, run) {
             destructiveHint: true,
             openWorldHint: true,
         },
-    }, async ({ project, path, oldText, newText }) => result(await run("edit_file", () => design.editFile(project, path, oldText, newText))));
+    }, async ({ project, path, oldText, newText }) => result(await client.filesystem.edit({ project, path, oldText, newText })));
     server.registerTool("delete_file", {
         description: "Permanently delete one .glts file at a canonical project-absolute path. The path includes the frame ID; this tool does not accept a frame argument.",
         inputSchema: fileInput,
@@ -56,5 +59,5 @@ export function registerFileTools(server, design, run) {
             destructiveHint: true,
             openWorldHint: true,
         },
-    }, async ({ project, path }) => result(await run("delete_file", () => design.deleteFile(project, path))));
+    }, async ({ project, path }) => result(await client.filesystem.delete({ project, path })));
 }

package/dist/mcp/frame.d.ts

@@ -1,2 +1,3 @@
-import type { DesignMcpOperationRunner, DesignMcpOperations, DesignMcpServer } from "./types.js";
-export declare function registerFrameTools(server: DesignMcpServer, design: DesignMcpOperations, run: DesignMcpOperationRunner): void;
+import type { DesignV1Client } from "../v1/client.js";
+import type { DesignMcpServer } from "./types.js";
+export declare function registerFrameTools(server: DesignMcpServer, client: DesignV1Client, fetcher: typeof globalThis.fetch): void;

package/dist/mcp/frame.js

@@ -1,7 +1,7 @@
-import { frameNameSchema, generateImageFrameSchema } from "../v1/schemas.js";
+import { frameNameSchema, generateImageFrameSchema, } from "../v1/schemas.js";
 import { base64, result } from "./result.js";
 import { createFrameSchema, frameCreationInput, frameInput, projectInput, } from "./schema.js";
-export function registerFrameTools(server, design, run) {
+export function registerFrameTools(server, client, fetcher) {
     server.registerTool("list_frames", {
         description: "List frames. Use their immutable ids for frame commands and filesystem paths.",
         inputSchema: projectInput,
@@ -11,9 +11,7 @@ export function registerFrameTools(server, design, run) {
             openWorldHint: false,
             idempotentHint: true,
         },
-    }, async ({ project }) => result({
-        frames: await run("list_frames", () => design.listFrames(project)),
-    }));
+    }, async ({ project }) => result({ frames: await client.frame.list({ project }) }));
     server.registerTool("create_frame", {
         description: "Create a frame in a Drawcall Design project. Use type=glts for reusable 3D objects and scenes, then write its source with write_file. Use type=image only for an existing public image URL and type=market only for an exact public Market asset.",
         inputSchema: createFrameSchema,
@@ -24,7 +22,7 @@ export function registerFrameTools(server, design, run) {
             idempotentHint: false,
         },
     }, async (input) => result({
-        frame: await run("create_frame", () => design.createFrame(frameCreationInput(input))),
+        frame: await client.frame.create(frameCreationInput(input)),
     }));
     server.registerTool("generate_image", {
         description: "Generate a 2D image or reference frame from text and up to four same-project image frame references. Use only when the user asks for a 2D image, picture, concept, or reference; do not use for 3D objects, scenes, or reusable GLTS assets. For edit, target is reference 0. New frames are the default; result=replace explicitly replaces the target image while preserving its frame ID, name, and layout.",
@@ -36,7 +34,7 @@ export function registerFrameTools(server, design, run) {
             idempotentHint: false,
         },
     }, async (input) => result({
-        frame: await run("generate_image", () => design.generateImage(input)),
+        frame: await client.frame.generateImage(input),
     }));
     server.registerTool("rename_frame", {
         description: "Rename a frame. Its immutable frame id does not change.",
@@ -47,7 +45,7 @@ export function registerFrameTools(server, design, run) {
             openWorldHint: false,
         },
     }, async ({ project, frame, name }) => result({
-        frame: await run("rename_frame", () => design.renameFrame(project, frame, name)),
+        frame: await client.frame.rename({ project, frame, name }),
     }));
     server.registerTool("delete_frame", {
         description: "Permanently delete a frame.",
@@ -58,7 +56,7 @@ export function registerFrameTools(server, design, run) {
             openWorldHint: true,
             idempotentHint: false,
         },
-    }, async ({ project, frame }) => result(await run("delete_frame", () => design.deleteFrame(project, frame))));
+    }, async ({ project, frame }) => result(await client.frame.delete({ project, frame })));
     server.registerTool("get_frame_screenshot", {
         description: "Render a DPR-1 PNG screenshot of a frame.",
         inputSchema: frameInput,
@@ -69,7 +67,8 @@ export function registerFrameTools(server, design, run) {
             idempotentHint: true,
         },
     }, async ({ project, frame }) => {
-        const screenshot = await run("get_frame_screenshot", () => design.screenshot(project, frame));
+        const screenshot = await client.frame.screenshot({ project, frame });
+        const png = await screenshotBytes(screenshot, fetcher);
         const structuredContent = {
             url: screenshot.url,
             width: screenshot.width,
@@ -80,7 +79,7 @@ export function registerFrameTools(server, design, run) {
             content: [
                 {
                     type: "image",
-                    data: base64(screenshot.png),
+                    data: base64(png),
                     mimeType: screenshot.mediaType,
                 },
             ],
@@ -88,3 +87,17 @@ export function registerFrameTools(server, design, run) {
         };
     });
 }
+async function screenshotBytes(screenshot, fetcher) {
+    const response = await fetcher(screenshot.url);
+    if (!response.ok) {
+        throw new Error(`Could not read screenshot ${screenshot.url}: ${response.status} ${response.statusText}`);
+    }
+    const mediaType = response.headers
+        .get("content-type")
+        ?.split(";", 1)[0]
+        ?.trim();
+    if (mediaType !== screenshot.mediaType) {
+        throw new Error(`Screenshot ${screenshot.url} returned ${mediaType ?? "no media type"}; expected ${screenshot.mediaType}`);
+    }
+    return new Uint8Array(await response.arrayBuffer());
+}

package/dist/mcp/index.d.ts

@@ -1,3 +1,2 @@
-export { createDesignMcpOperations } from "./client.js";
 export { registerDesignTools } from "./register.js";
-export type { DesignMcpOperationRunner, DesignMcpOperations, DesignMcpServer, DesignMcpScreenshot, DesignMcpToolResult, } from "./types.js";
+export type { DesignMcpOptions, DesignMcpServer, DesignMcpToolResult, } from "./types.js";

package/dist/mcp/index.js

@@ -1,2 +1 @@
-export { createDesignMcpOperations } from "./client.js";
 export { registerDesignTools } from "./register.js";

package/dist/mcp/project.d.ts

@@ -1,2 +1,3 @@
-import type { DesignMcpOperationRunner, DesignMcpOperations, DesignMcpServer } from "./types.js";
-export declare function registerProjectTools(server: DesignMcpServer, design: DesignMcpOperations, run: DesignMcpOperationRunner): void;
+import type { DesignV1Client } from "../v1/client.js";
+import type { DesignMcpServer } from "./types.js";
+export declare function registerProjectTools(server: DesignMcpServer, client: DesignV1Client): void;

package/dist/mcp/project.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { projectNameSchema } from "../v1/schemas.js";
 import { result } from "./result.js";
 import { projectInput } from "./schema.js";
-export function registerProjectTools(server, design, run) {
+export function registerProjectTools(server, client) {
     server.registerTool("list_projects", {
         description: "List projects available to the current Drawcall account.",
         annotations: {
@@ -11,9 +11,7 @@ export function registerProjectTools(server, design, run) {
             openWorldHint: false,
             idempotentHint: true,
         },
-    }, async () => result({
-        projects: await run("list_projects", () => design.listProjects()),
-    }));
+    }, async () => result({ projects: await client.project.list() }));
     server.registerTool("create_project", {
         description: "Create a project. Use its returned immutable id in every later call.",
         inputSchema: z.object({ name: projectNameSchema }).strict(),
@@ -23,9 +21,7 @@ export function registerProjectTools(server, design, run) {
             openWorldHint: false,
             idempotentHint: false,
         },
-    }, async ({ name }) => result({
-        project: await run("create_project", () => design.createProject(name)),
-    }));
+    }, async ({ name }) => result({ project: await client.project.create({ name }) }));
     server.registerTool("delete_project", {
         description: "Permanently delete a project and its frames.",
         inputSchema: projectInput,
@@ -35,5 +31,5 @@ export function registerProjectTools(server, design, run) {
             openWorldHint: true,
             idempotentHint: false,
         },
-    }, async ({ project }) => result(await run("delete_project", () => design.deleteProject(project))));
+    }, async ({ project }) => result(await client.project.delete({ project })));
 }

package/dist/mcp/register.d.ts

@@ -1,2 +1,3 @@
-import type { DesignMcpOperationRunner, DesignMcpOperations, DesignMcpServer } from "./types.js";
-export declare function registerDesignTools(server: DesignMcpServer, design: DesignMcpOperations, run?: DesignMcpOperationRunner): void;
+import type { DesignV1Client } from "../v1/client.js";
+import type { DesignMcpOptions, DesignMcpServer } from "./types.js";
+export declare function registerDesignTools(server: DesignMcpServer, client: DesignV1Client, options?: DesignMcpOptions): void;

package/dist/mcp/register.js

@@ -2,12 +2,9 @@ import { registerFileTools } from "./file.js";
 import { registerFrameTools } from "./frame.js";
 import { registerProjectTools } from "./project.js";
 import { registerSkillTool } from "./skill.js";
-export function registerDesignTools(server, design, run = runOperation) {
+export function registerDesignTools(server, client, options = {}) {
     registerSkillTool(server);
-    registerProjectTools(server, design, run);
-    registerFrameTools(server, design, run);
-    registerFileTools(server, design, run);
-}
-function runOperation(_name, operation) {
-    return operation();
+    registerProjectTools(server, client);
+    registerFrameTools(server, client, options.fetch ?? globalThis.fetch);
+    registerFileTools(server, client);
 }

package/dist/mcp/types.d.ts

@@ -1,4 +1,3 @@
-import type { CreateFrame, DesignFile, FileList, FileMutation, Frame, GenerateImageFrame, Project, Screenshot } from "../v1/schemas.js";
 import type { z } from "zod";
 export interface DesignMcpToolResult {
     [key: string]: unknown;
@@ -27,28 +26,7 @@ type DesignMcpToolHandler<Input extends z.ZodType | undefined> = Input extends z
 export interface DesignMcpServer {
     registerTool<Input extends z.ZodType | undefined = undefined>(name: string, config: DesignMcpToolConfig<Input>, handler: DesignMcpToolHandler<Input>): unknown;
 }
-export interface DesignMcpScreenshot extends Screenshot {
-    png: Uint8Array;
-}
-export type DesignMcpOperationRunner = <Result>(name: string, operation: () => Promise<Result>) => Promise<Result>;
-export interface DesignMcpOperations {
-    listProjects(): Promise<Project[]>;
-    createProject(name: string): Promise<Project>;
-    deleteProject(project: string): Promise<{
-        id: string;
-    }>;
-    listFrames(project: string): Promise<Frame[]>;
-    createFrame(input: CreateFrame): Promise<Frame>;
-    generateImage(input: GenerateImageFrame): Promise<Frame>;
-    renameFrame(project: string, frame: string, name: string): Promise<Frame>;
-    deleteFrame(project: string, frame: string): Promise<{
-        id: string;
-    }>;
-    listFiles(project: string, path?: string): Promise<FileList>;
-    readFile(project: string, path: string): Promise<DesignFile>;
-    writeFile(project: string, path: string, text: string): Promise<FileMutation>;
-    editFile(project: string, path: string, oldText: string, newText: string): Promise<FileMutation>;
-    deleteFile(project: string, path: string): Promise<FileMutation>;
-    screenshot(project: string, frame: string): Promise<DesignMcpScreenshot>;
+export interface DesignMcpOptions {
+    fetch?: typeof globalThis.fetch;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drawcall/design",
-  "version": "0.5.12",
+  "version": "0.6.0",
   "description": "Typed API and remote CLI for Drawcall Design",
   "repository": {
     "type": "git",

package/dist/mcp/client.d.ts

@@ -1,3 +0,0 @@
-import type { DesignV1Client } from "../v1/client.js";
-import type { DesignMcpOperations } from "./types.js";
-export declare function createDesignMcpOperations(client: DesignV1Client, fetcher?: typeof globalThis.fetch): DesignMcpOperations;

package/dist/mcp/client.js

@@ -1,38 +0,0 @@
-export function createDesignMcpOperations(client, fetcher = globalThis.fetch) {
-    return {
-        listProjects: () => client.project.list(),
-        createProject: (name) => client.project.create({ name }),
-        deleteProject: (project) => client.project.delete({ project }),
-        listFrames: (project) => client.frame.list({ project }),
-        createFrame: (input) => client.frame.create(input),
-        generateImage: (input) => client.frame.generateImage(input),
-        renameFrame: (project, frame, name) => client.frame.rename({ project, frame, name }),
-        deleteFrame: (project, frame) => client.frame.delete({ project, frame }),
-        listFiles: (project, path) => client.filesystem.list({
-            project,
-            ...(path === undefined ? {} : { path }),
-        }),
-        readFile: (project, path) => client.filesystem.read({ project, path }),
-        writeFile: (project, path, text) => client.filesystem.write({ project, path, text }),
-        editFile: (project, path, oldText, newText) => client.filesystem.edit({ project, path, oldText, newText }),
-        deleteFile: (project, path) => client.filesystem.delete({ project, path }),
-        screenshot: async (project, frame) => {
-            const screenshot = await client.frame.screenshot({ project, frame });
-            const response = await fetcher(screenshot.url);
-            if (!response.ok) {
-                throw new Error(`Could not read screenshot ${screenshot.url}: ${response.status} ${response.statusText}`);
-            }
-            const mediaType = response.headers
-                .get("content-type")
-                ?.split(";", 1)[0]
-                ?.trim();
-            if (mediaType !== screenshot.mediaType) {
-                throw new Error(`Screenshot ${screenshot.url} returned ${mediaType ?? "no media type"}; expected ${screenshot.mediaType}`);
-            }
-            return {
-                ...screenshot,
-                png: new Uint8Array(await response.arrayBuffer()),
-            };
-        },
-    };
-}