@kvasar/google-stitch 0.1.22 → 0.1.24

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-google-stitch",
    "name": "Google Stitch MCP",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "Integrates Google Stitch MCP services into OpenClaw",
    "skills": ["skills"],
   "configSchema": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kvasar/google-stitch",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "OpenClaw plugin for Google Stitch UI generation, screen design, variants, and design systems",
   "type": "module",
   "main": "./src/index.ts",

package/src/services/stitch-mcp-client.ts

@@ -45,16 +45,7 @@ export class StitchMCPClient {
       this.connected = true;
     }
   }
-    async createProject(name: string) {
-    await this.connect();
-
-    return this.client.callTool({
-      name: "create_project",
-      arguments: {
-      name: name,
-    },
-    });
-  }
+ 
 
  async generateScreen(params: {
   projectId: string;

package/src/tools/apply_design_system.ts

@@ -1,60 +1,24 @@
-type SelectedScreenInstance = {
-  id: string;
-  sourceScreen: string;
-};
+import { Type, Static } from "@sinclair/typebox";
 
-type ApplyDesignSystemParams = {
-  projectId: string;
-  selectedScreenInstances: SelectedScreenInstance[];
-  assetId: string;
-};
+const SelectedScreenInstanceSchema = Type.Object({
+  id: Type.String({ description: "Required. Screen instance ID (not source screen ID)." }),
+  sourceScreen: Type.String({ description: "Required. Resource name format: projects/{project}/screens/{screen}" })
+});
 
-export const applyDesignSystemTool = (client: any) => ({
-  name: "apply_design_system",
-  description:
-    "Applies a design system asset to one or more screens, updating colors, fonts, and shapes",
+const ApplyDesignSystemSchema = Type.Object({
+  projectId: Type.String({ description: "Required. Project ID without prefix." }),
+  selectedScreenInstances: Type.Array(SelectedScreenInstanceSchema, {
+    description: "Required. Screen instances to update from get_project."
+  }),
+  assetId: Type.String({ description: "Required. Design system asset ID without assets/ prefix." })
+});
 
-  parameters: {
-    type: "object",
-    properties: {
-      projectId: {
-        type: "string",
-        description: "Required. Project ID without prefix."
-      },
-      selectedScreenInstances: {
-        type: "array",
-        description:
-          "Required. Screen instances to update from get_project.",
-        items: {
-          type: "object",
-          properties: {
-            id: {
-              type: "string",
-              description:
-                "Required. Screen instance ID (not source screen ID)."
-            },
-            sourceScreen: {
-              type: "string",
-              description:
-                "Required. Resource name format: projects/{project}/screens/{screen}"
-            }
-          },
-          required: ["id", "sourceScreen"]
-        }
-      },
-      assetId: {
-        type: "string",
-        description:
-          "Required. Design system asset ID without assets/ prefix."
-      }
-    },
-    required: [
-      "projectId",
-      "selectedScreenInstances",
-      "assetId"
-    ]
-  },
+type ApplyDesignSystemParams = Static<typeof ApplyDesignSystemSchema>;
 
+export const applyDesignSystemTool = (client: any) => ({
+  name: "apply_design_system",
+  description: "Applies a design system asset to one or more screens, updating colors, fonts, and shapes",
+  parameters: ApplyDesignSystemSchema,
   async execute(_: string, params: ApplyDesignSystemParams) {
     return await client.request("apply_design_system", params);
   }

package/src/tools/create_design_system.ts

@@ -1,141 +1,89 @@
-type ColorMode =
-  | "COLOR_MODE_UNSPECIFIED"
-  | "LIGHT"
-  | "DARK";
+import { Type, Static } from "@sinclair/typebox";
 
-type FontType =
-  | "FONT_UNSPECIFIED"
-  | "INTER"
-  | "DM_SANS"
-  | "GEIST";
+const ColorMode = Type.Union([
+  Type.Literal("COLOR_MODE_UNSPECIFIED"),
+  Type.Literal("LIGHT"),
+  Type.Literal("DARK")
+]);
 
-type Roundness =
-  | "ROUNDNESS_UNSPECIFIED"
-  | "ROUND_FOUR"
-  | "ROUND_EIGHT"
-  | "ROUND_TWELVE"
-  | "ROUND_FULL";
+const FontType = Type.Union([
+  Type.Literal("FONT_UNSPECIFIED"),
+  Type.Literal("INTER"),
+  Type.Literal("DM_SANS"),
+  Type.Literal("GEIST")
+]);
 
-type ColorVariant =
-  | "COLOR_VARIANT_UNSPECIFIED"
-  | "MONOCHROME"
-  | "NEUTRAL"
-  | "TONAL_SPOT"
-  | "VIBRANT"
-  | "EXPRESSIVE"
-  | "FIDELITY"
-  | "CONTENT"
-  | "RAINBOW"
-  | "FRUIT_SALAD";
+const Roundness = Type.Union([
+  Type.Literal("ROUNDNESS_UNSPECIFIED"),
+  Type.Literal("ROUND_FOUR"),
+  Type.Literal("ROUND_EIGHT"),
+  Type.Literal("ROUND_TWELVE"),
+  Type.Literal("ROUND_FULL")
+]);
 
-type DesignTheme = {
-  colorMode: ColorMode;
-  headlineFont: FontType;
-  bodyFont: FontType;
-  labelFont?: FontType;
-  roundness: Roundness;
-  customColor: string;
-  colorVariant?: ColorVariant;
-  overridePrimaryColor?: string;
-  overrideSecondaryColor?: string;
-  overrideTertiaryColor?: string;
-  overrideNeutralColor?: string;
-  designMd?: string;
-};
+const ColorVariant = Type.Union([
+  Type.Literal("COLOR_VARIANT_UNSPECIFIED"),
+  Type.Literal("MONOCHROME"),
+  Type.Literal("NEUTRAL"),
+  Type.Literal("TONAL_SPOT"),
+  Type.Literal("VIBRANT"),
+  Type.Literal("EXPRESSIVE"),
+  Type.Literal("FIDELITY"),
+  Type.Literal("CONTENT"),
+  Type.Literal("RAINBOW"),
+  Type.Literal("FRUIT_SALAD")
+]);
 
-type DesignSystem = {
-  displayName: string;
-  theme: DesignTheme;
-};
+const DesignThemeSchema = Type.Object({
+  colorMode: Type.Union([Type.Literal("LIGHT"), Type.Literal("DARK")], {
+    description: "Color mode"
+  }),
+  headlineFont: Type.Union([Type.Literal("INTER"), Type.Literal("DM_SANS"), Type.Literal("GEIST")], {
+    description: "Headline font"
+  }),
+  bodyFont: Type.Union([Type.Literal("INTER"), Type.Literal("DM_SANS"), Type.Literal("GEIST")], {
+    description: "Body font"
+  }),
+  labelFont: Type.Optional(Type.Union([Type.Literal("INTER"), Type.Literal("DM_SANS"), Type.Literal("GEIST")], {
+    description: "Label font"
+  })),
+  roundness: Type.Union([
+    Type.Literal("ROUND_FOUR"),
+    Type.Literal("ROUND_EIGHT"),
+    Type.Literal("ROUND_TWELVE"),
+    Type.Literal("ROUND_FULL")
+  ], {
+    description: "Roundness level"
+  }),
+  customColor: Type.String({ description: "Hex seed color" }),
+  colorVariant: Type.Optional(Type.Union([
+    Type.Literal("MONOCHROME"),
+    Type.Literal("NEUTRAL"),
+    Type.Literal("TONAL_SPOT"),
+    Type.Literal("VIBRANT"),
+    Type.Literal("EXPRESSIVE")
+  ], {
+    description: "Color variant"
+  })),
+  designMd: Type.Optional(Type.String({ description: "Optional markdown design instructions" }))
+});
 
-type CreateDesignSystemParams = {
-  designSystem: DesignSystem;
-  projectId?: string;
-};
+const DesignSystemSchema = Type.Object({
+  displayName: Type.String({ description: "Required. Display name." }),
+  theme: DesignThemeSchema
+});
 
-export const createDesignSystemTool = (client: any) => ({
-  name: "create_design_system",
-  description:
-    "Creates a new design system with colors, typography, roundness, and theme tokens for a Stitch project",
+const CreateDesignSystemSchema = Type.Object({
+  projectId: Type.Optional(Type.String({ description: "Optional. Project ID. If omitted, creates a global design asset." })),
+  designSystem: DesignSystemSchema
+});
 
-  parameters: {
-    type: "object",
-    properties: {
-      projectId: {
-        type: "string",
-        description:
-          "Optional. Project ID. If omitted, creates a global design asset."
-      },
-      designSystem: {
-        type: "object",
-        description: "Required. Design system definition.",
-        properties: {
-          displayName: {
-            type: "string",
-            description: "Required. Display name."
-          },
-          theme: {
-            type: "object",
-            properties: {
-              colorMode: {
-                type: "string",
-                enum: ["LIGHT", "DARK"]
-              },
-              headlineFont: {
-                type: "string",
-                enum: ["INTER", "DM_SANS", "GEIST"]
-              },
-              bodyFont: {
-                type: "string",
-                enum: ["INTER", "DM_SANS", "GEIST"]
-              },
-              labelFont: {
-                type: "string",
-                enum: ["INTER", "DM_SANS", "GEIST"]
-              },
-              roundness: {
-                type: "string",
-                enum: [
-                  "ROUND_FOUR",
-                  "ROUND_EIGHT",
-                  "ROUND_TWELVE",
-                  "ROUND_FULL"
-                ]
-              },
-              customColor: {
-                type: "string",
-                description: "Hex seed color"
-              },
-              colorVariant: {
-                type: "string",
-                enum: [
-                  "MONOCHROME",
-                  "NEUTRAL",
-                  "TONAL_SPOT",
-                  "VIBRANT",
-                  "EXPRESSIVE"
-                ]
-              },
-              designMd: {
-                type: "string",
-                description: "Optional markdown design instructions"
-              }
-            },
-            required: [
-              "colorMode",
-              "headlineFont",
-              "bodyFont",
-              "roundness",
-              "customColor"
-            ]
-          }
-        },
-        required: ["displayName", "theme"]
-      }
-    },
-    required: ["designSystem"]
-  },
+type CreateDesignSystemParams = Static<typeof CreateDesignSystemSchema>;
 
+export const createDesignSystemTool = (client: any) => ({
+  name: "create_design_system",
+  description: "Creates a new design system with colors, typography, roundness, and theme tokens for a Stitch project",
+  parameters: CreateDesignSystemSchema,
   async execute(_: string, params: CreateDesignSystemParams) {
     return await client.request("create_design_system", params);
   }

package/src/tools/create_project.ts

@@ -20,7 +20,7 @@ export function createProjectTool(client: StitchMCPClient) {
       ),
     }),
     async execute(_id: string, params: CreateProjectParams) {
-      const result = await client.createProject(params.title);
+      const result = await client.request("create_project",params);
       return {
         content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }],
       };

package/src/tools/edit_screens.ts

@@ -1,7 +1,49 @@
-export const editScreensTool = (client:any) => ({
+import { Type, Static } from "@sinclair/typebox";
+
+const EditScreensSchema = Type.Object({
+  projectId: Type.String({
+    description: "Required. Project ID without prefix.",
+  }),
+
+  selectedScreenIds: Type.Array(Type.String(), {
+    description:
+      "Required. Screen IDs to edit, without `screens/` prefix.",
+    minItems: 1,
+  }),
+
+  prompt: Type.String({
+    description: "Required. Edit instruction.",
+  }),
+
+  deviceType: Type.Optional(
+    Type.Union([
+      Type.Literal("DEVICE_TYPE_UNSPECIFIED"),
+      Type.Literal("MOBILE"),
+      Type.Literal("DESKTOP"),
+      Type.Literal("TABLET"),
+      Type.Literal("AGNOSTIC"),
+    ])
+  ),
+
+  modelId: Type.Optional(
+    Type.Union([
+      Type.Literal("MODEL_ID_UNSPECIFIED"),
+      Type.Literal("GEMINI_3_PRO"),
+      Type.Literal("GEMINI_3_FLASH"),
+      Type.Literal("GEMINI_3_1_PRO"),
+    ])
+  ),
+});
+
+type EditScreensParams = Static<typeof EditScreensSchema>;
+
+export const editScreensTool = (client: any) => ({
   name: "edit_screens",
-  description: "edit screens",
-  async execute(_: string, params: any) {
+  description:
+    "Edits existing screens using a text prompt. This process may take a few minutes.",
+  parameters: EditScreensSchema,
+
+  async execute(_: string, params: EditScreensParams) {
     return await client.request?.("edit_screens", params);
   },
-});
+});

package/src/tools/generate_screen_from_text_tool.ts

@@ -6,7 +6,7 @@ import {
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { Type } from "@sinclair/typebox";
+import { Type, Static } from "@sinclair/typebox";
 
 
 type StitchFile = {
@@ -22,68 +22,75 @@ type SessionOutputComponent = {
    
 };
 
+type ScreenType = "SCREEN_TYPE_UNSPECIFIED" | "COMPONENT" | "LAYOUT" | "PAGE" | "FLOW";
+type ScreenStatus = "SCREEN_STATUS_UNSPECIFIED" | "DRAFT" | "PUBLISHED" | "ARCHIVED";
+type DisplayMode = "DISPLAY_MODE_UNSPECIFIED" | "LIGHT" | "DARK";
+
+type DesignTheme = {
+  colorMode?: string;
+  headlineFont?: string;
+  bodyFont?: string;
+  labelFont?: string;
+  roundness?: string;
+  customColor?: string;
+  colorVariant?: string;
+};
+
+type ScreenMetadata = {
+  agent?: string;
+  status?: ScreenStatus;
+  displayMode?: DisplayMode;
+};
+
 type StitchResponse = {
   screen?: {
     name?: string;
+    id?: string;
     title?: string;
     prompt?: string;
     screenshot?: StitchFile;
     htmlCode?: StitchFile;
+    figmaExport?: StitchFile;
+    theme?: DesignTheme;
     deviceType?: DeviceType;
+    screenType?: ScreenType;
+    screenMetadata?: ScreenMetadata;
     width?: string;
     height?: string;
+    groupId?: string;
+    groupName?: string;
+    generatedBy?: string;
+    isCreatedByClient?: boolean;
   };
   output_components?: SessionOutputComponent[];
 };
 
+const GenerateScreenSchema = Type.Object({
+  projectId: Type.String({ description: "Required. Project ID without prefix." }),
+  prompt: Type.String({ description: "Natural language prompt describing the UI screen" }),
+  deviceType: Type.Optional(Type.Union([
+    Type.Literal("DEVICE_TYPE_UNSPECIFIED"),
+    Type.Literal("MOBILE"),
+    Type.Literal("DESKTOP"),
+    Type.Literal("TABLET"),
+    Type.Literal("AGNOSTIC")
+  ])),
+  modelId: Type.Optional(Type.Union([
+    Type.Literal("MODEL_ID_UNSPECIFIED"),
+    Type.Literal("GEMINI_3_PRO"),
+    Type.Literal("GEMINI_3_FLASH"),
+    Type.Literal("GEMINI_3_1_PRO")
+  ]))
+});
+
+type GenerateScreenParams = Static<typeof GenerateScreenSchema>;
+
 export function generateScreenFromTextTool(client: StitchMCPClient) {
   return {
     name: "generate_screen_from_text",
     description: "Generate a UI screen from a natural language prompt",
-
-    parameters: {
-      type: "object",
-      properties: {
-        projectId: {
-          type: "string",
-          description: "Required. Project ID without prefix."
-        },
-        prompt: {
-          type: "string",
-          description: "Describe the UI screen to generate"
-        },
-        deviceType: {
-          type: "string",
-          enum: [
-            "DEVICE_TYPE_UNSPECIFIED",
-            "MOBILE",
-            "DESKTOP",
-            "TABLET",
-            "AGNOSTIC"
-          ]
-        },
-        modelId: {
-          type: "string",
-          enum: [
-            "MODEL_ID_UNSPECIFIED",
-            "GEMINI_3_PRO",
-            "GEMINI_3_FLASH",
-            "GEMINI_3_1_PRO"
-          ]
-        }
-      },
-      required: ["projectId", "prompt"]
-    },
-
-    async execute(
-      _id: string,
-      params: {
-        projectId: string;
-        prompt: string;
-        deviceType?: DeviceType;
-        modelId?: ModelId;
-      }
-    ) {
+    parameters: GenerateScreenSchema,
+    async execute(_id: string, params: GenerateScreenParams) {
       const result = (await client.generateScreen(params)) as StitchResponse;
 
       const screen = result.screen;
@@ -100,6 +107,45 @@ export function generateScreenFromTextTool(client: StitchMCPClient) {
 
       const content: Array<{ type: string; [key: string]: any }> = [];
 
+      // Add screen metadata summary first
+      if (screen) {
+        const screenInfo = `
+## Screen Generated Successfully
+
+**Title:** ${screen.title || "Untitled"}
+**Resource Name:** ${screen.name || "N/A"}
+**ID:** ${screen.id || "N/A"}
+**Device Type:** ${screen.deviceType || "N/A"}
+**Screen Type:** ${screen.screenType || "N/A"}
+**Dimensions:** ${screen.width || "N/A"} x ${screen.height || "N/A"}
+**Generated By:** ${screen.generatedBy || "N/A"}
+**Prompt:** ${screen.prompt || "N/A"}
+
+**Metadata:**
+- Agent: ${screen.screenMetadata?.agent || "N/A"}
+- Status: ${screen.screenMetadata?.status || "N/A"}
+- Display Mode: ${screen.screenMetadata?.displayMode || "N/A"}
+
+**Group Info:**
+- Group ID: ${screen.groupId || "N/A"}
+- Group Name: ${screen.groupName || "N/A"}
+
+**Theme:**
+- Color Mode: ${screen.theme?.colorMode || "N/A"}
+- Headline Font: ${screen.theme?.headlineFont || "N/A"}
+- Body Font: ${screen.theme?.bodyFont || "N/A"}
+- Roundness: ${screen.theme?.roundness || "N/A"}
+- Color Variant: ${screen.theme?.colorVariant || "N/A"}
+
+**Client Created:** ${screen.isCreatedByClient ? "Yes" : "No"}
+        `;
+
+        content.push({
+          type: "text",
+          text: screenInfo.trim()
+        });
+      }
+
       if (modelText) {
         content.push({
           type: "text",
@@ -178,6 +224,7 @@ export function generateScreenFromTextTool(client: StitchMCPClient) {
           <h3>${escapeHtml(
             screen?.title || "Generated screen"
           )}</h3>
+          <p>No HTML preview available</p>
         </div>`;
       }
 
@@ -186,6 +233,19 @@ export function generateScreenFromTextTool(client: StitchMCPClient) {
         html
       });
 
+      // Add Figma export info if available
+      if (screen?.figmaExport) {
+        const figmaInfo = `
+**Figma Export Available:** ${screen.figmaExport.downloadUrl ? "Yes" : "No"}
+${screen.figmaExport.name ? `**File Name:** ${screen.figmaExport.name}` : ""}
+        `;
+        
+        content.push({
+          type: "text",
+          text: figmaInfo.trim()
+        });
+      }
+
       if (suggestionText) {
         content.push({
           type: "text",

package/src/tools/generate_variants.ts

@@ -1,7 +1,84 @@
-export const generateVariantsTool = (client:any) => ({
+import { Type, Static } from "@sinclair/typebox";
+
+const VariantOptionsSchema = Type.Object({
+  variantCount: Type.Optional(
+    Type.Integer({
+      minimum: 1,
+      maximum: 5,
+      description: "Number of variants (1–5). Default: 3.",
+    })
+  ),
+
+  creativeRange: Type.Optional(
+    Type.Union([
+      Type.Literal("CREATIVE_RANGE_UNSPECIFIED"),
+      Type.Literal("REFINE"),
+      Type.Literal("EXPLORE"),
+      Type.Literal("REIMAGINE"),
+    ])
+  ),
+
+  aspects: Type.Optional(
+    Type.Array(
+      Type.Union([
+        Type.Literal("VARIANT_ASPECT_UNSPECIFIED"),
+        Type.Literal("LAYOUT"),
+        Type.Literal("COLOR_SCHEME"),
+        Type.Literal("IMAGES"),
+        Type.Literal("TEXT_FONT"),
+        Type.Literal("TEXT_CONTENT"),
+      ])
+    )
+  ),
+});
+
+const GenerateVariantsSchema = Type.Object({
+  projectId: Type.String({
+    description: "Required. Project ID without prefix.",
+  }),
+
+  selectedScreenIds: Type.Array(Type.String(), {
+    description: "Required. Screen IDs to generate variants for.",
+    minItems: 1,
+  }),
+
+  prompt: Type.String({
+    description: "Required. Text guiding variant generation.",
+  }),
+
+  variantOptions: VariantOptionsSchema,
+
+  deviceType: Type.Optional(
+    Type.Union([
+      Type.Literal("DEVICE_TYPE_UNSPECIFIED"),
+      Type.Literal("MOBILE"),
+      Type.Literal("DESKTOP"),
+      Type.Literal("TABLET"),
+      Type.Literal("AGNOSTIC"),
+    ])
+  ),
+
+  modelId: Type.Optional(
+    Type.Union([
+      Type.Literal("MODEL_ID_UNSPECIFIED"),
+      // deprecated but still supported by API
+      Type.Literal("GEMINI_3_PRO"),
+      Type.Literal("GEMINI_3_FLASH"),
+      Type.Literal("GEMINI_3_1_PRO"),
+    ])
+  ),
+});
+
+type GenerateVariantsParams = Static<typeof GenerateVariantsSchema>;
+
+export const generateVariantsTool = (client: any) => ({
   name: "generate_variants",
-  description: "generate variants",
-  async execute(_: string, params: any) {
+  description:
+    "Generates design variants of existing screens based on selected screens and variant options.",
+
+  parameters: GenerateVariantsSchema,
+
+  async execute(_: string, params: GenerateVariantsParams) {
     return await client.request?.("generate_variants", params);
   },
-});
+});

package/src/tools/get_project.ts

@@ -1,7 +1,16 @@
-export const getProjectTool = (client:any) => ({
+import { Type, Static } from "@sinclair/typebox";
+
+const GetProjectSchema = Type.Object({
+  // This tool appears to accept any parameters as per the API
+});
+
+type GetProjectParams = Static<typeof GetProjectSchema>;
+
+export const getProjectTool = (client: any) => ({
   name: "get_project",
   description: "get project",
-  async execute(_: string, params: any) {
+  parameters: GetProjectSchema,
+  async execute(_: string, params: GetProjectParams) {
     return await client.request?.("get_project", params);
   },
 });

package/src/tools/get_screen.ts

@@ -2,6 +2,7 @@ import { StitchMCPClient } from "../services/stitch-mcp-client.js";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { Type, Static } from "@sinclair/typebox";
 
 type StitchFile = {
   name?: string;
@@ -27,11 +28,13 @@ type Screen = {
   isCreatedByClient?: boolean;
 };
 
-type GetScreenParams = {
-  name: string;
-  projectId: string;
-  screenId: string;
-};
+const GetScreenSchema = Type.Object({
+  name: Type.String({ description: "Required. Resource name. Format: projects/{project}/screens/{screen}" }),
+  projectId: Type.String({ description: "Required (deprecated). Project ID without prefix." }),
+  screenId: Type.String({ description: "Required (deprecated). Screen ID without prefix." })
+});
+
+type GetScreenParams = Static<typeof GetScreenSchema>;
 
 type ContentItem = {
   type: string;
@@ -40,35 +43,9 @@ type ContentItem = {
 
 export const getScreenTool = (client: StitchMCPClient) => ({
   name: "get_screen",
-  description:
-    "Retrieves and visually renders a specific screen within a Stitch project.",
-
-  parameters: {
-    type: "object",
-    properties: {
-      name: {
-        type: "string",
-        description:
-          "Required. Resource name. Format: projects/{project}/screens/{screen}"
-      },
-      projectId: {
-        type: "string",
-        description:
-          "Required (deprecated). Project ID without prefix."
-      },
-      screenId: {
-        type: "string",
-        description:
-          "Required (deprecated). Screen ID without prefix."
-      }
-    },
-    required: ["name", "projectId", "screenId"]
-  },
-
-  async execute(
-    _: string,
-    params: GetScreenParams
-  ) {
+  description: "Retrieves and visually renders a specific screen within a Stitch project.",
+  parameters: GetScreenSchema,
+  async execute(_: string, params: GetScreenParams) {
     const { name, projectId, screenId } = params;
 
     if (!name || !projectId || !screenId) {

package/src/tools/update_design_system.ts

@@ -1,7 +1,55 @@
-export const updateDesignSystemTool = (client:any) => ({
+import { Type, Static } from "@sinclair/typebox";
+
+/**
+ * Reusable nested theme schema
+ */
+const DesignThemeSchema = Type.Object({
+  name: Type.Optional(Type.String()),
+  primaryColor: Type.Optional(Type.String()),
+  secondaryColor: Type.Optional(Type.String()),
+  typography: Type.Optional(Type.String()),
+  spacing: Type.Optional(Type.String()),
+});
+
+/**
+ * Main design system schema
+ */
+const DesignSystemSchema = Type.Object({
+  name: Type.Optional(Type.String()),
+  description: Type.Optional(Type.String()),
+  themes: Type.Optional(Type.Array(DesignThemeSchema)),
+  components: Type.Optional(Type.Array(Type.String())),
+  tokens: Type.Optional(Type.Record(Type.String(), Type.Any())),
+});
+
+/**
+ * Update schema
+ */
+const UpdateDesignSystemSchema = Type.Object({
+  name: Type.String({
+    pattern: "^assets\\/[^\\/]+$",
+    description:
+      "Required. Resource name. Format: `assets/{asset}`.",
+  }),
+
+  projectId: Type.String({
+    description: "Required. Project ID without prefix.",
+  }),
+
+  designSystem: DesignSystemSchema,
+});
+
+type UpdateDesignSystemParams = Static<typeof UpdateDesignSystemSchema>;
+
+export const updateDesignSystemTool = (client: any) => ({
   name: "update_design_system",
-  description: "update design system",
-  async execute(_: string, params: any) {
+
+  description:
+    "Updates an existing design system. Identifies the asset by its name field.",
+
+  parameters: UpdateDesignSystemSchema,
+
+  async execute(_: string, params: UpdateDesignSystemParams) {
     return await client.request?.("update_design_system", params);
   },
-});
+});