c64-debug-mcp 1.0.12 → 1.0.13

package/dist/http.cjs

@@ -3636,40 +3636,35 @@ var setRegistersTool = createViceTool({
 });
 var readMemoryTool = createViceTool({
   id: "memory_read",
-  description: "Reads a memory chunk. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
-  inputSchema: 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().max(65535).describe("Number of bytes to read")
-    }).refine((input) => input.address + input.length <= 65536, {
-      message: "address + length must stay within the 64K address space",
-      path: ["length"]
-    }),
-    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)")
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    }).refine((input) => input.end < 65536, {
-      message: "End address must stay within the 64K address space",
-      path: ["end"]
-    })
-  ]),
+  description: "Reads a memory chunk. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
+  inputSchema: import_zod4.z.object({
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: import_zod4.z.number().int().positive().max(65535).optional().describe("Number of bytes to read (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address.")
+  }),
   dataSchema: import_zod4.z.object({
-    address: import_zod4.z.number().int().min(0).max(65535).describe("Start address of the returned memory chunk"),
+    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) => {
-    let address;
+    const address = input.start_address;
     let length;
-    if ("start" in input && "end" in input) {
-      address = input.start;
-      length = input.end - input.start + 1;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      if (input.end_address >= 65536) {
+        throw new Error("End address must stay within the 64K address space");
+      }
+      length = input.end_address - address + 1;
+    } else if (input.data_length !== void 0) {
+      length = input.data_length;
+      if (address + length > 65536) {
+        throw new Error("address + length must stay within the 64K address space");
+      }
     } else {
-      address = input.address;
-      length = input.length;
+      throw new Error("Must provide either data_length or end_address");
     }
     const result = await c64Session.readMemory(address, address + length - 1);
     return {
@@ -3691,7 +3686,7 @@ var writeMemoryTool = createViceTool({
   }),
   dataSchema: import_zod4.z.object({
     worked: import_zod4.z.boolean().describe("Whether the write operation completed successfully"),
-    address: import_zod4.z.number().int().min(0).max(65535).describe("Start address where the bytes were written"),
+    address: address16Schema.describe("Start address where the bytes were written"),
     length: import_zod4.z.number().int().min(1).describe("Number of bytes written")
   }).extend(debugStateSchema.shape),
   execute: async (input) => await c64Session.writeMemory(input.address, input.data)
@@ -3740,47 +3735,44 @@ 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.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)
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    })
-  ]),
+  description: "Creates an execution breakpoint or read/write watchpoint. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
+  inputSchema: import_zod4.z.object({
+    kind: breakpointKindSchema,
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: import_zod4.z.number().int().positive().default(1).describe("Size of the breakpoint range in bytes (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address."),
+    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,
     lastStopReason: stopReasonSchema,
-    programCounter: import_zod4.z.number().int().min(0).max(65535).nullable(),
+    programCounter: address16Schema.nullable(),
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    const normalizedInput = "start" in input && "end" in input ? {
+    const address = input.start_address;
+    let length;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      length = input.end_address - address + 1;
+    } else {
+      length = input.data_length;
+    }
+    const normalizedInput = {
       kind: input.kind,
-      address: input.start,
-      length: input.end - input.start + 1,
+      address,
+      length,
       condition: input.condition,
       label: input.label,
       temporary: input.temporary,
       enabled: input.enabled
-    } : input;
+    };
     const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),

package/dist/http.js

@@ -3613,40 +3613,35 @@ var setRegistersTool = createViceTool({
 });
 var readMemoryTool = createViceTool({
   id: "memory_read",
-  description: "Reads a memory chunk. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
-  inputSchema: z3.union([
-    z3.object({
-      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      length: z3.number().int().positive().max(65535).describe("Number of bytes to read")
-    }).refine((input) => input.address + input.length <= 65536, {
-      message: "address + length must stay within the 64K address space",
-      path: ["length"]
-    }),
-    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)")
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    }).refine((input) => input.end < 65536, {
-      message: "End address must stay within the 64K address space",
-      path: ["end"]
-    })
-  ]),
+  description: "Reads a memory chunk. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
+  inputSchema: z3.object({
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: z3.number().int().positive().max(65535).optional().describe("Number of bytes to read (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address.")
+  }),
   dataSchema: z3.object({
-    address: z3.number().int().min(0).max(65535).describe("Start address of the returned memory chunk"),
+    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) => {
-    let address;
+    const address = input.start_address;
     let length;
-    if ("start" in input && "end" in input) {
-      address = input.start;
-      length = input.end - input.start + 1;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      if (input.end_address >= 65536) {
+        throw new Error("End address must stay within the 64K address space");
+      }
+      length = input.end_address - address + 1;
+    } else if (input.data_length !== void 0) {
+      length = input.data_length;
+      if (address + length > 65536) {
+        throw new Error("address + length must stay within the 64K address space");
+      }
     } else {
-      address = input.address;
-      length = input.length;
+      throw new Error("Must provide either data_length or end_address");
     }
     const result = await c64Session.readMemory(address, address + length - 1);
     return {
@@ -3668,7 +3663,7 @@ var writeMemoryTool = createViceTool({
   }),
   dataSchema: z3.object({
     worked: z3.boolean().describe("Whether the write operation completed successfully"),
-    address: z3.number().int().min(0).max(65535).describe("Start address where the bytes were written"),
+    address: address16Schema.describe("Start address where the bytes were written"),
     length: z3.number().int().min(1).describe("Number of bytes written")
   }).extend(debugStateSchema.shape),
   execute: async (input) => await c64Session.writeMemory(input.address, input.data)
@@ -3717,47 +3712,44 @@ 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.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)
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    })
-  ]),
+  description: "Creates an execution breakpoint or read/write watchpoint. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
+  inputSchema: z3.object({
+    kind: breakpointKindSchema,
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: z3.number().int().positive().default(1).describe("Size of the breakpoint range in bytes (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address."),
+    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,
     lastStopReason: stopReasonSchema,
-    programCounter: z3.number().int().min(0).max(65535).nullable(),
+    programCounter: address16Schema.nullable(),
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    const normalizedInput = "start" in input && "end" in input ? {
+    const address = input.start_address;
+    let length;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      length = input.end_address - address + 1;
+    } else {
+      length = input.data_length;
+    }
+    const normalizedInput = {
       kind: input.kind,
-      address: input.start,
-      length: input.end - input.start + 1,
+      address,
+      length,
       condition: input.condition,
       label: input.label,
       temporary: input.temporary,
       enabled: input.enabled
-    } : input;
+    };
     const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),

package/dist/stdio.cjs

@@ -3633,40 +3633,35 @@ var setRegistersTool = createViceTool({
 });
 var readMemoryTool = createViceTool({
   id: "memory_read",
-  description: "Reads a memory chunk. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
-  inputSchema: 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().max(65535).describe("Number of bytes to read")
-    }).refine((input) => input.address + input.length <= 65536, {
-      message: "address + length must stay within the 64K address space",
-      path: ["length"]
-    }),
-    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)")
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    }).refine((input) => input.end < 65536, {
-      message: "End address must stay within the 64K address space",
-      path: ["end"]
-    })
-  ]),
+  description: "Reads a memory chunk. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
+  inputSchema: import_zod4.z.object({
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: import_zod4.z.number().int().positive().max(65535).optional().describe("Number of bytes to read (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address.")
+  }),
   dataSchema: import_zod4.z.object({
-    address: import_zod4.z.number().int().min(0).max(65535).describe("Start address of the returned memory chunk"),
+    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) => {
-    let address;
+    const address = input.start_address;
     let length;
-    if ("start" in input && "end" in input) {
-      address = input.start;
-      length = input.end - input.start + 1;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      if (input.end_address >= 65536) {
+        throw new Error("End address must stay within the 64K address space");
+      }
+      length = input.end_address - address + 1;
+    } else if (input.data_length !== void 0) {
+      length = input.data_length;
+      if (address + length > 65536) {
+        throw new Error("address + length must stay within the 64K address space");
+      }
     } else {
-      address = input.address;
-      length = input.length;
+      throw new Error("Must provide either data_length or end_address");
     }
     const result = await c64Session.readMemory(address, address + length - 1);
     return {
@@ -3688,7 +3683,7 @@ var writeMemoryTool = createViceTool({
   }),
   dataSchema: import_zod4.z.object({
     worked: import_zod4.z.boolean().describe("Whether the write operation completed successfully"),
-    address: import_zod4.z.number().int().min(0).max(65535).describe("Start address where the bytes were written"),
+    address: address16Schema.describe("Start address where the bytes were written"),
     length: import_zod4.z.number().int().min(1).describe("Number of bytes written")
   }).extend(debugStateSchema.shape),
   execute: async (input) => await c64Session.writeMemory(input.address, input.data)
@@ -3737,47 +3732,44 @@ 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.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)
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    })
-  ]),
+  description: "Creates an execution breakpoint or read/write watchpoint. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
+  inputSchema: import_zod4.z.object({
+    kind: breakpointKindSchema,
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: import_zod4.z.number().int().positive().default(1).describe("Size of the breakpoint range in bytes (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address."),
+    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,
     lastStopReason: stopReasonSchema,
-    programCounter: import_zod4.z.number().int().min(0).max(65535).nullable(),
+    programCounter: address16Schema.nullable(),
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    const normalizedInput = "start" in input && "end" in input ? {
+    const address = input.start_address;
+    let length;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      length = input.end_address - address + 1;
+    } else {
+      length = input.data_length;
+    }
+    const normalizedInput = {
       kind: input.kind,
-      address: input.start,
-      length: input.end - input.start + 1,
+      address,
+      length,
       condition: input.condition,
       label: input.label,
       temporary: input.temporary,
       enabled: input.enabled
-    } : input;
+    };
     const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),

package/dist/stdio.js

@@ -3610,40 +3610,35 @@ var setRegistersTool = createViceTool({
 });
 var readMemoryTool = createViceTool({
   id: "memory_read",
-  description: "Reads a memory chunk. Use either (address, length) or (start, end) format. Addresses can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
-  inputSchema: z3.union([
-    z3.object({
-      address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
-      length: z3.number().int().positive().max(65535).describe("Number of bytes to read")
-    }).refine((input) => input.address + input.length <= 65536, {
-      message: "address + length must stay within the 64K address space",
-      path: ["length"]
-    }),
-    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)")
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    }).refine((input) => input.end < 65536, {
-      message: "End address must stay within the 64K address space",
-      path: ["end"]
-    })
-  ]),
+  description: "Reads a memory chunk. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000). Returns byte values as decimal numbers.",
+  inputSchema: z3.object({
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: z3.number().int().positive().max(65535).optional().describe("Number of bytes to read (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address.")
+  }),
   dataSchema: z3.object({
-    address: z3.number().int().min(0).max(65535).describe("Start address of the returned memory chunk"),
+    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) => {
-    let address;
+    const address = input.start_address;
     let length;
-    if ("start" in input && "end" in input) {
-      address = input.start;
-      length = input.end - input.start + 1;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      if (input.end_address >= 65536) {
+        throw new Error("End address must stay within the 64K address space");
+      }
+      length = input.end_address - address + 1;
+    } else if (input.data_length !== void 0) {
+      length = input.data_length;
+      if (address + length > 65536) {
+        throw new Error("address + length must stay within the 64K address space");
+      }
     } else {
-      address = input.address;
-      length = input.length;
+      throw new Error("Must provide either data_length or end_address");
     }
     const result = await c64Session.readMemory(address, address + length - 1);
     return {
@@ -3665,7 +3660,7 @@ var writeMemoryTool = createViceTool({
   }),
   dataSchema: z3.object({
     worked: z3.boolean().describe("Whether the write operation completed successfully"),
-    address: z3.number().int().min(0).max(65535).describe("Start address where the bytes were written"),
+    address: address16Schema.describe("Start address where the bytes were written"),
     length: z3.number().int().min(1).describe("Number of bytes written")
   }).extend(debugStateSchema.shape),
   execute: async (input) => await c64Session.writeMemory(input.address, input.data)
@@ -3714,47 +3709,44 @@ 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.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)
-    }).refine((input) => input.start <= input.end, {
-      message: "End address must be greater than or equal to start address",
-      path: ["end"]
-    })
-  ]),
+  description: "Creates an execution breakpoint or read/write watchpoint. Specify start_address and either data_length or end_address. Address can be decimal (53248) or hex string with prefix ($D000, 0xD000).",
+  inputSchema: z3.object({
+    kind: breakpointKindSchema,
+    start_address: address16Schema.describe("Start address: decimal (53248) or hex string with prefix ($D000, 0xD000)"),
+    data_length: z3.number().int().positive().default(1).describe("Size of the breakpoint range in bytes (use either data_length or end_address)"),
+    end_address: address16Schema.optional().describe("End address (inclusive): decimal (53248) or hex string with prefix ($D000, 0xD000). Use either data_length or end_address."),
+    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,
     lastStopReason: stopReasonSchema,
-    programCounter: z3.number().int().min(0).max(65535).nullable(),
+    programCounter: address16Schema.nullable(),
     registers: c64PartialRegisterValueSchema.nullable()
   }),
   execute: async (input) => {
-    const normalizedInput = "start" in input && "end" in input ? {
+    const address = input.start_address;
+    let length;
+    if (input.end_address !== void 0) {
+      if (address > input.end_address) {
+        throw new Error("End address must be greater than or equal to start address");
+      }
+      length = input.end_address - address + 1;
+    } else {
+      length = input.data_length;
+    }
+    const normalizedInput = {
       kind: input.kind,
-      address: input.start,
-      length: input.end - input.start + 1,
+      address,
+      length,
       condition: input.condition,
       label: input.label,
       temporary: input.temporary,
       enabled: input.enabled
-    } : input;
+    };
     const result = await c64Session.breakpointSet(normalizedInput);
     return {
       breakpoint: normalizeBreakpoint(result.breakpoint),

package/package.json

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