c64-debug-mcp 1.0.8 → 1.0.10

package/dist/http.cjs

@@ -153,15 +153,6 @@ var import_zod3 = require("zod");
 var import_zod2 = require("zod");
 var warningSchema = warningItemSchema;
 function parseAddress16(input) {
-  if (input === void 0) {
-    throw new import_zod2.z.ZodError([
-      {
-        code: "custom",
-        message: "Address is required",
-        path: []
-      }
-    ]);
-  }
   if (typeof input === "number") {
     if (!Number.isInteger(input) || input < 0 || input > 65535) {
       throw new import_zod2.z.ZodError([
@@ -224,15 +215,6 @@ function parseAddress16(input) {
 }
 var address16Schema = import_zod2.z.preprocess(parseAddress16, import_zod2.z.number().int().min(0).max(65535)).describe("16-bit C64 address: decimal (53248) or hex string with prefix ($D000, 0xD000)");
 function parseByte(input) {
-  if (input === void 0) {
-    throw new import_zod2.z.ZodError([
-      {
-        code: "custom",
-        message: "Byte value is required",
-        path: []
-      }
-    ]);
-  }
   if (typeof input === "number") {
     if (!Number.isInteger(input) || input < 0 || input > 255) {
       throw new import_zod2.z.ZodError([
@@ -3664,30 +3646,33 @@ var readMemoryTool = createViceTool({
       start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
       end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
     })
-  ]).transform((input) => {
-    if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
-        throw new Error("End address must be greater than or equal to start address");
-      }
-      return {
-        address: input.start,
-        length: input.end - input.start + 1
-      };
-    }
-    return input;
-  }).refine((input) => input.address + input.length <= 65536, {
-    message: "address + length must stay within the 64K address space",
-    path: ["length"]
-  }),
+  ]),
   dataSchema: import_zod4.z.object({
     address: address16Schema.describe("Start address of the returned memory chunk"),
     length: import_zod4.z.number().int().min(0).describe("Number of bytes returned"),
     data: byteArraySchema.describe("Raw bytes returned from memory")
   }),
   execute: async (input) => {
-    const result = await c64Session.readMemory(input.address, input.address + input.length - 1);
+    let address;
+    let length;
+    if ("start" in input && "end" in input) {
+      if (input.end < input.start) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      address = input.start;
+      length = input.end - input.start + 1;
+    } else if ("address" in input && "length" in input) {
+      address = input.address;
+      length = input.length;
+    } else {
+      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
+    }
+    if (address + length > 65536) {
+      throw new Error("address + length must stay within the 64K address space");
+    }
+    const result = await c64Session.readMemory(address, address + length - 1);
     return {
-      address: input.address,
+      address,
       length: result.length,
       data: result.data
     };
@@ -3755,36 +3740,26 @@ var listBreakpointsTool = createViceTool({
 var breakpointSetTool = createViceTool({
   id: "breakpoint_set",
   description: "Creates an execution breakpoint or read/write watchpoint. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
-  inputSchema: import_zod4.z.object({
-    kind: breakpointKindSchema,
-    condition: import_zod4.z.string().optional(),
-    label: import_zod4.z.string().optional(),
-    temporary: import_zod4.z.boolean().default(false),
-    enabled: import_zod4.z.boolean().default(true)
-  }).and(
-    import_zod4.z.union([
-      import_zod4.z.object({
-        address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-        length: import_zod4.z.number().int().positive().default(1).describe("Size of the breakpoint range in bytes")
-      }),
-      import_zod4.z.object({
-        start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-        end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
-      })
-    ])
-  ).transform((input) => {
-    if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
-        throw new Error("End address must be greater than or equal to start address");
-      }
-      return {
-        ...input,
-        address: input.start,
-        length: input.end - input.start + 1
-      };
-    }
-    return input;
-  }),
+  inputSchema: import_zod4.z.union([
+    import_zod4.z.object({
+      kind: breakpointKindSchema,
+      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+      length: import_zod4.z.number().int().positive().default(1).describe("Size of the breakpoint range in bytes"),
+      condition: import_zod4.z.string().optional(),
+      label: import_zod4.z.string().optional(),
+      temporary: import_zod4.z.boolean().default(false),
+      enabled: import_zod4.z.boolean().default(true)
+    }),
+    import_zod4.z.object({
+      kind: breakpointKindSchema,
+      start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+      end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+      condition: import_zod4.z.string().optional(),
+      label: import_zod4.z.string().optional(),
+      temporary: import_zod4.z.boolean().default(false),
+      enabled: import_zod4.z.boolean().default(true)
+    })
+  ]),
   dataSchema: import_zod4.z.object({
     breakpoint: breakpointSchema,
     executionState: executionStateSchema,
@@ -3793,7 +3768,34 @@ var breakpointSetTool = createViceTool({
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    const result = await c64Session.breakpointSet(input);
+    let normalizedInput;
+    if ("start" in input && "end" in input) {
+      if (input.end < input.start) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      normalizedInput = {
+        kind: input.kind,
+        address: input.start,
+        length: input.end - input.start + 1,
+        condition: input.condition,
+        label: input.label,
+        temporary: input.temporary,
+        enabled: input.enabled
+      };
+    } else if ("address" in input && "length" in input) {
+      normalizedInput = {
+        kind: input.kind,
+        address: input.address,
+        length: input.length,
+        condition: input.condition,
+        label: input.label,
+        temporary: input.temporary,
+        enabled: input.enabled
+      };
+    } else {
+      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
+    }
+    const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),
       executionState: result.executionState,

package/dist/http.js

@@ -130,15 +130,6 @@ import { ZodError } from "zod";
 import { z as z2 } from "zod";
 var warningSchema = warningItemSchema;
 function parseAddress16(input) {
-  if (input === void 0) {
-    throw new z2.ZodError([
-      {
-        code: "custom",
-        message: "Address is required",
-        path: []
-      }
-    ]);
-  }
   if (typeof input === "number") {
     if (!Number.isInteger(input) || input < 0 || input > 65535) {
       throw new z2.ZodError([
@@ -201,15 +192,6 @@ function parseAddress16(input) {
 }
 var address16Schema = z2.preprocess(parseAddress16, z2.number().int().min(0).max(65535)).describe("16-bit C64 address: decimal (53248) or hex string with prefix ($D000, 0xD000)");
 function parseByte(input) {
-  if (input === void 0) {
-    throw new z2.ZodError([
-      {
-        code: "custom",
-        message: "Byte value is required",
-        path: []
-      }
-    ]);
-  }
   if (typeof input === "number") {
     if (!Number.isInteger(input) || input < 0 || input > 255) {
       throw new z2.ZodError([
@@ -3641,30 +3623,33 @@ var readMemoryTool = createViceTool({
       start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
       end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
     })
-  ]).transform((input) => {
-    if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
-        throw new Error("End address must be greater than or equal to start address");
-      }
-      return {
-        address: input.start,
-        length: input.end - input.start + 1
-      };
-    }
-    return input;
-  }).refine((input) => input.address + input.length <= 65536, {
-    message: "address + length must stay within the 64K address space",
-    path: ["length"]
-  }),
+  ]),
   dataSchema: z3.object({
     address: address16Schema.describe("Start address of the returned memory chunk"),
     length: z3.number().int().min(0).describe("Number of bytes returned"),
     data: byteArraySchema.describe("Raw bytes returned from memory")
   }),
   execute: async (input) => {
-    const result = await c64Session.readMemory(input.address, input.address + input.length - 1);
+    let address;
+    let length;
+    if ("start" in input && "end" in input) {
+      if (input.end < input.start) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      address = input.start;
+      length = input.end - input.start + 1;
+    } else if ("address" in input && "length" in input) {
+      address = input.address;
+      length = input.length;
+    } else {
+      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
+    }
+    if (address + length > 65536) {
+      throw new Error("address + length must stay within the 64K address space");
+    }
+    const result = await c64Session.readMemory(address, address + length - 1);
     return {
-      address: input.address,
+      address,
       length: result.length,
       data: result.data
     };
@@ -3732,36 +3717,26 @@ var listBreakpointsTool = createViceTool({
 var breakpointSetTool = createViceTool({
   id: "breakpoint_set",
   description: "Creates an execution breakpoint or read/write watchpoint. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
-  inputSchema: z3.object({
-    kind: breakpointKindSchema,
-    condition: z3.string().optional(),
-    label: z3.string().optional(),
-    temporary: z3.boolean().default(false),
-    enabled: z3.boolean().default(true)
-  }).and(
-    z3.union([
-      z3.object({
-        address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-        length: z3.number().int().positive().default(1).describe("Size of the breakpoint range in bytes")
-      }),
-      z3.object({
-        start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-        end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
-      })
-    ])
-  ).transform((input) => {
-    if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
-        throw new Error("End address must be greater than or equal to start address");
-      }
-      return {
-        ...input,
-        address: input.start,
-        length: input.end - input.start + 1
-      };
-    }
-    return input;
-  }),
+  inputSchema: z3.union([
+    z3.object({
+      kind: breakpointKindSchema,
+      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+      length: z3.number().int().positive().default(1).describe("Size of the breakpoint range in bytes"),
+      condition: z3.string().optional(),
+      label: z3.string().optional(),
+      temporary: z3.boolean().default(false),
+      enabled: z3.boolean().default(true)
+    }),
+    z3.object({
+      kind: breakpointKindSchema,
+      start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+      end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+      condition: z3.string().optional(),
+      label: z3.string().optional(),
+      temporary: z3.boolean().default(false),
+      enabled: z3.boolean().default(true)
+    })
+  ]),
   dataSchema: z3.object({
     breakpoint: breakpointSchema,
     executionState: executionStateSchema,
@@ -3770,7 +3745,34 @@ var breakpointSetTool = createViceTool({
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    const result = await c64Session.breakpointSet(input);
+    let normalizedInput;
+    if ("start" in input && "end" in input) {
+      if (input.end < input.start) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      normalizedInput = {
+        kind: input.kind,
+        address: input.start,
+        length: input.end - input.start + 1,
+        condition: input.condition,
+        label: input.label,
+        temporary: input.temporary,
+        enabled: input.enabled
+      };
+    } else if ("address" in input && "length" in input) {
+      normalizedInput = {
+        kind: input.kind,
+        address: input.address,
+        length: input.length,
+        condition: input.condition,
+        label: input.label,
+        temporary: input.temporary,
+        enabled: input.enabled
+      };
+    } else {
+      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
+    }
+    const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),
       executionState: result.executionState,

package/dist/stdio.cjs

@@ -150,15 +150,6 @@ var import_zod3 = require("zod");
 var import_zod2 = require("zod");
 var warningSchema = warningItemSchema;
 function parseAddress16(input) {
-  if (input === void 0) {
-    throw new import_zod2.z.ZodError([
-      {
-        code: "custom",
-        message: "Address is required",
-        path: []
-      }
-    ]);
-  }
   if (typeof input === "number") {
     if (!Number.isInteger(input) || input < 0 || input > 65535) {
       throw new import_zod2.z.ZodError([
@@ -221,15 +212,6 @@ function parseAddress16(input) {
 }
 var address16Schema = import_zod2.z.preprocess(parseAddress16, import_zod2.z.number().int().min(0).max(65535)).describe("16-bit C64 address: decimal (53248) or hex string with prefix ($D000, 0xD000)");
 function parseByte(input) {
-  if (input === void 0) {
-    throw new import_zod2.z.ZodError([
-      {
-        code: "custom",
-        message: "Byte value is required",
-        path: []
-      }
-    ]);
-  }
   if (typeof input === "number") {
     if (!Number.isInteger(input) || input < 0 || input > 255) {
       throw new import_zod2.z.ZodError([
@@ -3661,30 +3643,33 @@ var readMemoryTool = createViceTool({
       start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
       end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
     })
-  ]).transform((input) => {
-    if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
-        throw new Error("End address must be greater than or equal to start address");
-      }
-      return {
-        address: input.start,
-        length: input.end - input.start + 1
-      };
-    }
-    return input;
-  }).refine((input) => input.address + input.length <= 65536, {
-    message: "address + length must stay within the 64K address space",
-    path: ["length"]
-  }),
+  ]),
   dataSchema: import_zod4.z.object({
     address: address16Schema.describe("Start address of the returned memory chunk"),
     length: import_zod4.z.number().int().min(0).describe("Number of bytes returned"),
     data: byteArraySchema.describe("Raw bytes returned from memory")
   }),
   execute: async (input) => {
-    const result = await c64Session.readMemory(input.address, input.address + input.length - 1);
+    let address;
+    let length;
+    if ("start" in input && "end" in input) {
+      if (input.end < input.start) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      address = input.start;
+      length = input.end - input.start + 1;
+    } else if ("address" in input && "length" in input) {
+      address = input.address;
+      length = input.length;
+    } else {
+      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
+    }
+    if (address + length > 65536) {
+      throw new Error("address + length must stay within the 64K address space");
+    }
+    const result = await c64Session.readMemory(address, address + length - 1);
     return {
-      address: input.address,
+      address,
       length: result.length,
       data: result.data
     };
@@ -3752,36 +3737,26 @@ var listBreakpointsTool = createViceTool({
 var breakpointSetTool = createViceTool({
   id: "breakpoint_set",
   description: "Creates an execution breakpoint or read/write watchpoint. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
-  inputSchema: import_zod4.z.object({
-    kind: breakpointKindSchema,
-    condition: import_zod4.z.string().optional(),
-    label: import_zod4.z.string().optional(),
-    temporary: import_zod4.z.boolean().default(false),
-    enabled: import_zod4.z.boolean().default(true)
-  }).and(
-    import_zod4.z.union([
-      import_zod4.z.object({
-        address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-        length: import_zod4.z.number().int().positive().default(1).describe("Size of the breakpoint range in bytes")
-      }),
-      import_zod4.z.object({
-        start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-        end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
-      })
-    ])
-  ).transform((input) => {
-    if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
-        throw new Error("End address must be greater than or equal to start address");
-      }
-      return {
-        ...input,
-        address: input.start,
-        length: input.end - input.start + 1
-      };
-    }
-    return input;
-  }),
+  inputSchema: import_zod4.z.union([
+    import_zod4.z.object({
+      kind: breakpointKindSchema,
+      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+      length: import_zod4.z.number().int().positive().default(1).describe("Size of the breakpoint range in bytes"),
+      condition: import_zod4.z.string().optional(),
+      label: import_zod4.z.string().optional(),
+      temporary: import_zod4.z.boolean().default(false),
+      enabled: import_zod4.z.boolean().default(true)
+    }),
+    import_zod4.z.object({
+      kind: breakpointKindSchema,
+      start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+      end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+      condition: import_zod4.z.string().optional(),
+      label: import_zod4.z.string().optional(),
+      temporary: import_zod4.z.boolean().default(false),
+      enabled: import_zod4.z.boolean().default(true)
+    })
+  ]),
   dataSchema: import_zod4.z.object({
     breakpoint: breakpointSchema,
     executionState: executionStateSchema,
@@ -3790,7 +3765,34 @@ var breakpointSetTool = createViceTool({
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    const result = await c64Session.breakpointSet(input);
+    let normalizedInput;
+    if ("start" in input && "end" in input) {
+      if (input.end < input.start) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      normalizedInput = {
+        kind: input.kind,
+        address: input.start,
+        length: input.end - input.start + 1,
+        condition: input.condition,
+        label: input.label,
+        temporary: input.temporary,
+        enabled: input.enabled
+      };
+    } else if ("address" in input && "length" in input) {
+      normalizedInput = {
+        kind: input.kind,
+        address: input.address,
+        length: input.length,
+        condition: input.condition,
+        label: input.label,
+        temporary: input.temporary,
+        enabled: input.enabled
+      };
+    } else {
+      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
+    }
+    const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),
       executionState: result.executionState,

package/dist/stdio.js

@@ -127,15 +127,6 @@ import { ZodError } from "zod";
 import { z as z2 } from "zod";
 var warningSchema = warningItemSchema;
 function parseAddress16(input) {
-  if (input === void 0) {
-    throw new z2.ZodError([
-      {
-        code: "custom",
-        message: "Address is required",
-        path: []
-      }
-    ]);
-  }
   if (typeof input === "number") {
     if (!Number.isInteger(input) || input < 0 || input > 65535) {
       throw new z2.ZodError([
@@ -198,15 +189,6 @@ function parseAddress16(input) {
 }
 var address16Schema = z2.preprocess(parseAddress16, z2.number().int().min(0).max(65535)).describe("16-bit C64 address: decimal (53248) or hex string with prefix ($D000, 0xD000)");
 function parseByte(input) {
-  if (input === void 0) {
-    throw new z2.ZodError([
-      {
-        code: "custom",
-        message: "Byte value is required",
-        path: []
-      }
-    ]);
-  }
   if (typeof input === "number") {
     if (!Number.isInteger(input) || input < 0 || input > 255) {
       throw new z2.ZodError([
@@ -3638,30 +3620,33 @@ var readMemoryTool = createViceTool({
       start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
       end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
     })
-  ]).transform((input) => {
-    if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
-        throw new Error("End address must be greater than or equal to start address");
-      }
-      return {
-        address: input.start,
-        length: input.end - input.start + 1
-      };
-    }
-    return input;
-  }).refine((input) => input.address + input.length <= 65536, {
-    message: "address + length must stay within the 64K address space",
-    path: ["length"]
-  }),
+  ]),
   dataSchema: z3.object({
     address: address16Schema.describe("Start address of the returned memory chunk"),
     length: z3.number().int().min(0).describe("Number of bytes returned"),
     data: byteArraySchema.describe("Raw bytes returned from memory")
   }),
   execute: async (input) => {
-    const result = await c64Session.readMemory(input.address, input.address + input.length - 1);
+    let address;
+    let length;
+    if ("start" in input && "end" in input) {
+      if (input.end < input.start) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      address = input.start;
+      length = input.end - input.start + 1;
+    } else if ("address" in input && "length" in input) {
+      address = input.address;
+      length = input.length;
+    } else {
+      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
+    }
+    if (address + length > 65536) {
+      throw new Error("address + length must stay within the 64K address space");
+    }
+    const result = await c64Session.readMemory(address, address + length - 1);
     return {
-      address: input.address,
+      address,
       length: result.length,
       data: result.data
     };
@@ -3729,36 +3714,26 @@ var listBreakpointsTool = createViceTool({
 var breakpointSetTool = createViceTool({
   id: "breakpoint_set",
   description: "Creates an execution breakpoint or read/write watchpoint. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
-  inputSchema: z3.object({
-    kind: breakpointKindSchema,
-    condition: z3.string().optional(),
-    label: z3.string().optional(),
-    temporary: z3.boolean().default(false),
-    enabled: z3.boolean().default(true)
-  }).and(
-    z3.union([
-      z3.object({
-        address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-        length: z3.number().int().positive().default(1).describe("Size of the breakpoint range in bytes")
-      }),
-      z3.object({
-        start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-        end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)")
-      })
-    ])
-  ).transform((input) => {
-    if ("start" in input && "end" in input) {
-      if (input.end < input.start) {
-        throw new Error("End address must be greater than or equal to start address");
-      }
-      return {
-        ...input,
-        address: input.start,
-        length: input.end - input.start + 1
-      };
-    }
-    return input;
-  }),
+  inputSchema: z3.union([
+    z3.object({
+      kind: breakpointKindSchema,
+      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+      length: z3.number().int().positive().default(1).describe("Size of the breakpoint range in bytes"),
+      condition: z3.string().optional(),
+      label: z3.string().optional(),
+      temporary: z3.boolean().default(false),
+      enabled: z3.boolean().default(true)
+    }),
+    z3.object({
+      kind: breakpointKindSchema,
+      start: address16Schema.describe("Start address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+      end: address16Schema.describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+      condition: z3.string().optional(),
+      label: z3.string().optional(),
+      temporary: z3.boolean().default(false),
+      enabled: z3.boolean().default(true)
+    })
+  ]),
   dataSchema: z3.object({
     breakpoint: breakpointSchema,
     executionState: executionStateSchema,
@@ -3767,7 +3742,34 @@ var breakpointSetTool = createViceTool({
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    const result = await c64Session.breakpointSet(input);
+    let normalizedInput;
+    if ("start" in input && "end" in input) {
+      if (input.end < input.start) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      normalizedInput = {
+        kind: input.kind,
+        address: input.start,
+        length: input.end - input.start + 1,
+        condition: input.condition,
+        label: input.label,
+        temporary: input.temporary,
+        enabled: input.enabled
+      };
+    } else if ("address" in input && "length" in input) {
+      normalizedInput = {
+        kind: input.kind,
+        address: input.address,
+        length: input.length,
+        condition: input.condition,
+        label: input.label,
+        temporary: input.temporary,
+        enabled: input.enabled
+      };
+    } else {
+      throw new Error("Invalid input: must provide either (address, length) or (start, end)");
+    }
+    const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),
       executionState: result.executionState,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c64-debug-mcp",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Model Context Protocol server for C64 debugging via VICE emulator",
   "type": "module",
   "keywords": [