@dexto/tools-todo 0.1.1

package/dist/todo-service.d.ts

@@ -0,0 +1,53 @@
+import { Database, AgentEventBus, IDextoLogger } from '@dexto/core';
+import { TodoConfig, TodoInput, TodoUpdateResult, Todo } from './types.js';
+
+/**
+ * Todo Service
+ *
+ * Manages todo lists for tracking agent workflow and task progress.
+ * Emits events through the AgentEventBus using the service:event pattern.
+ */
+
+/**
+ * TodoService - Manages todo lists for agent workflow tracking
+ */
+declare class TodoService {
+    private database;
+    private eventBus;
+    private logger;
+    private config;
+    private initialized;
+    constructor(database: Database, eventBus: AgentEventBus, logger: IDextoLogger, config?: TodoConfig);
+    /**
+     * Initialize the service
+     */
+    initialize(): Promise<void>;
+    /**
+     * Update todos for a session (replaces entire list)
+     */
+    updateTodos(sessionId: string, todoInputs: TodoInput[]): Promise<TodoUpdateResult>;
+    /**
+     * Get todos for a session
+     */
+    getTodos(sessionId: string): Promise<Todo[]>;
+    /**
+     * Generate database key for session todos
+     */
+    private getTodosDatabaseKey;
+    /**
+     * Generate consistent key for todo matching (content + activeForm)
+     * Uses JSON encoding to prevent collisions when fields contain delimiters
+     */
+    private getTodoKey;
+    /**
+     * Generate key from TodoInput
+     * Uses JSON encoding to prevent collisions when fields contain delimiters
+     */
+    private getTodoKeyFromInput;
+    /**
+     * Validate todo status
+     */
+    private validateTodoStatus;
+}
+
+export { TodoService };

package/dist/todo-service.js

@@ -0,0 +1,163 @@
+import { nanoid } from "nanoid";
+import { DextoRuntimeError } from "@dexto/core";
+import { TodoError } from "./errors.js";
+import { TODO_STATUS_VALUES } from "./types.js";
+const DEFAULT_MAX_TODOS = 100;
+const TODOS_KEY_PREFIX = "todos:";
+class TodoService {
+  database;
+  eventBus;
+  logger;
+  config;
+  initialized = false;
+  constructor(database, eventBus, logger, config = {}) {
+    this.database = database;
+    this.eventBus = eventBus;
+    this.logger = logger;
+    this.config = {
+      maxTodosPerSession: config.maxTodosPerSession ?? DEFAULT_MAX_TODOS,
+      enableEvents: config.enableEvents ?? true
+    };
+  }
+  /**
+   * Initialize the service
+   */
+  async initialize() {
+    if (this.initialized) {
+      this.logger.debug("TodoService already initialized");
+      return;
+    }
+    this.initialized = true;
+    this.logger.info("TodoService initialized successfully");
+  }
+  /**
+   * Update todos for a session (replaces entire list)
+   */
+  async updateTodos(sessionId, todoInputs) {
+    if (!this.initialized) {
+      throw TodoError.notInitialized();
+    }
+    if (todoInputs.length > this.config.maxTodosPerSession) {
+      throw TodoError.todoLimitExceeded(todoInputs.length, this.config.maxTodosPerSession);
+    }
+    try {
+      const existing = await this.getTodos(sessionId);
+      const existingMap = new Map(existing.map((t) => [this.getTodoKey(t), t]));
+      const now = /* @__PURE__ */ new Date();
+      const newTodos = [];
+      const stats = { created: 0, updated: 0, deleted: 0 };
+      for (let i = 0; i < todoInputs.length; i++) {
+        const input = todoInputs[i];
+        this.validateTodoStatus(input.status);
+        const todoKey = this.getTodoKeyFromInput(input);
+        const existingTodo = existingMap.get(todoKey);
+        if (existingTodo) {
+          const updated = {
+            ...existingTodo,
+            status: input.status,
+            updatedAt: now,
+            position: i
+          };
+          newTodos.push(updated);
+          stats.updated++;
+          existingMap.delete(todoKey);
+        } else {
+          const created = {
+            id: nanoid(),
+            sessionId,
+            content: input.content,
+            activeForm: input.activeForm,
+            status: input.status,
+            position: i,
+            createdAt: now,
+            updatedAt: now
+          };
+          newTodos.push(created);
+          stats.created++;
+        }
+      }
+      stats.deleted = existingMap.size;
+      const key = this.getTodosDatabaseKey(sessionId);
+      await this.database.set(key, newTodos);
+      if (this.config.enableEvents) {
+        this.eventBus.emit("service:event", {
+          service: "todo",
+          event: "updated",
+          sessionId,
+          data: {
+            todos: newTodos,
+            stats
+          }
+        });
+      }
+      this.logger.debug(
+        `Updated todos for session ${sessionId}: ${stats.created} created, ${stats.updated} updated, ${stats.deleted} deleted`
+      );
+      return {
+        todos: newTodos,
+        sessionId,
+        ...stats
+      };
+    } catch (error) {
+      if (error instanceof DextoRuntimeError) {
+        throw error;
+      }
+      throw TodoError.databaseError(
+        "updateTodos",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Get todos for a session
+   */
+  async getTodos(sessionId) {
+    if (!this.initialized) {
+      throw TodoError.notInitialized();
+    }
+    try {
+      const key = this.getTodosDatabaseKey(sessionId);
+      const todos = await this.database.get(key);
+      return todos || [];
+    } catch (error) {
+      if (error instanceof DextoRuntimeError) {
+        throw error;
+      }
+      throw TodoError.databaseError(
+        "getTodos",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Generate database key for session todos
+   */
+  getTodosDatabaseKey(sessionId) {
+    return `${TODOS_KEY_PREFIX}${sessionId}`;
+  }
+  /**
+   * Generate consistent key for todo matching (content + activeForm)
+   * Uses JSON encoding to prevent collisions when fields contain delimiters
+   */
+  getTodoKey(todo) {
+    return JSON.stringify([todo.content, todo.activeForm]);
+  }
+  /**
+   * Generate key from TodoInput
+   * Uses JSON encoding to prevent collisions when fields contain delimiters
+   */
+  getTodoKeyFromInput(input) {
+    return JSON.stringify([input.content, input.activeForm]);
+  }
+  /**
+   * Validate todo status
+   */
+  validateTodoStatus(status) {
+    if (!TODO_STATUS_VALUES.includes(status)) {
+      throw TodoError.invalidStatus(status);
+    }
+  }
+}
+export {
+  TodoService
+};

package/dist/todo-write-tool.cjs

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var todo_write_tool_exports = {};
+__export(todo_write_tool_exports, {
+  createTodoWriteTool: () => createTodoWriteTool
+});
+module.exports = __toCommonJS(todo_write_tool_exports);
+var import_zod = require("zod");
+var import_types = require("./types.js");
+const TodoItemSchema = import_zod.z.object({
+  content: import_zod.z.string().min(1).describe('Task description in imperative form (e.g., "Fix authentication bug")'),
+  activeForm: import_zod.z.string().min(1).describe(
+    'Present continuous form shown during execution (e.g., "Fixing authentication bug")'
+  ),
+  status: import_zod.z.enum(import_types.TODO_STATUS_VALUES).describe(
+    "Task status: pending (not started), in_progress (currently working), completed (finished)"
+  )
+}).strict();
+const TodoWriteInputSchema = import_zod.z.object({
+  todos: import_zod.z.array(TodoItemSchema).min(1).describe("Array of todo items representing the complete task list for the session")
+}).strict().superRefine((value, ctx) => {
+  const inProgressCount = value.todos.filter((todo) => todo.status === "in_progress").length;
+  if (inProgressCount > 1) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "Only one todo may be in_progress at a time.",
+      path: ["todos"]
+    });
+  }
+}).describe(
+  "Manage task list for current session. Replaces the entire todo list with the provided tasks."
+);
+function createTodoWriteTool(todoService) {
+  return {
+    id: "todo_write",
+    description: `Track progress on multi-step tasks. Use for:
+- Implementation tasks with 3+ steps (features, refactors, bug fixes)
+- Tasks where the user asks for a plan or breakdown
+- Complex workflows where progress visibility helps
+
+Do NOT use for simple single-file edits, quick questions, or explanations.
+
+IMPORTANT: This replaces the entire todo list. Always include ALL tasks (pending, in_progress, completed). Only ONE task should be in_progress at a time. Update status as you work: pending \u2192 in_progress \u2192 completed.`,
+    inputSchema: TodoWriteInputSchema,
+    execute: async (input, context) => {
+      const validatedInput = TodoWriteInputSchema.parse(input);
+      const sessionId = context?.sessionId ?? "default";
+      const result = await todoService.updateTodos(sessionId, validatedInput.todos);
+      const completed = result.todos.filter((t) => t.status === "completed").length;
+      const inProgress = result.todos.filter((t) => t.status === "in_progress").length;
+      const pending = result.todos.filter((t) => t.status === "pending").length;
+      return `Updated tasks: ${completed}/${result.todos.length} completed${inProgress > 0 ? `, 1 in progress` : ""}${pending > 0 ? `, ${pending} pending` : ""}`;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTodoWriteTool
+});

package/dist/todo-write-tool.d.cts

@@ -0,0 +1,16 @@
+import { InternalTool } from '@dexto/core';
+import { TodoService } from './todo-service.cjs';
+import './types.cjs';
+
+/**
+ * Todo Write Tool
+ *
+ * Manages task lists for tracking agent progress and workflow organization
+ */
+
+/**
+ * Create todo_write internal tool
+ */
+declare function createTodoWriteTool(todoService: TodoService): InternalTool;
+
+export { createTodoWriteTool };

package/dist/todo-write-tool.d.ts

@@ -0,0 +1,16 @@
+import { InternalTool } from '@dexto/core';
+import { TodoService } from './todo-service.js';
+import './types.js';
+
+/**
+ * Todo Write Tool
+ *
+ * Manages task lists for tracking agent progress and workflow organization
+ */
+
+/**
+ * Create todo_write internal tool
+ */
+declare function createTodoWriteTool(todoService: TodoService): InternalTool;
+
+export { createTodoWriteTool };

package/dist/todo-write-tool.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { TODO_STATUS_VALUES } from "./types.js";
+const TodoItemSchema = z.object({
+  content: z.string().min(1).describe('Task description in imperative form (e.g., "Fix authentication bug")'),
+  activeForm: z.string().min(1).describe(
+    'Present continuous form shown during execution (e.g., "Fixing authentication bug")'
+  ),
+  status: z.enum(TODO_STATUS_VALUES).describe(
+    "Task status: pending (not started), in_progress (currently working), completed (finished)"
+  )
+}).strict();
+const TodoWriteInputSchema = z.object({
+  todos: z.array(TodoItemSchema).min(1).describe("Array of todo items representing the complete task list for the session")
+}).strict().superRefine((value, ctx) => {
+  const inProgressCount = value.todos.filter((todo) => todo.status === "in_progress").length;
+  if (inProgressCount > 1) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Only one todo may be in_progress at a time.",
+      path: ["todos"]
+    });
+  }
+}).describe(
+  "Manage task list for current session. Replaces the entire todo list with the provided tasks."
+);
+function createTodoWriteTool(todoService) {
+  return {
+    id: "todo_write",
+    description: `Track progress on multi-step tasks. Use for:
+- Implementation tasks with 3+ steps (features, refactors, bug fixes)
+- Tasks where the user asks for a plan or breakdown
+- Complex workflows where progress visibility helps
+
+Do NOT use for simple single-file edits, quick questions, or explanations.
+
+IMPORTANT: This replaces the entire todo list. Always include ALL tasks (pending, in_progress, completed). Only ONE task should be in_progress at a time. Update status as you work: pending \u2192 in_progress \u2192 completed.`,
+    inputSchema: TodoWriteInputSchema,
+    execute: async (input, context) => {
+      const validatedInput = TodoWriteInputSchema.parse(input);
+      const sessionId = context?.sessionId ?? "default";
+      const result = await todoService.updateTodos(sessionId, validatedInput.todos);
+      const completed = result.todos.filter((t) => t.status === "completed").length;
+      const inProgress = result.todos.filter((t) => t.status === "in_progress").length;
+      const pending = result.todos.filter((t) => t.status === "pending").length;
+      return `Updated tasks: ${completed}/${result.todos.length} completed${inProgress > 0 ? `, 1 in progress` : ""}${pending > 0 ? `, ${pending} pending` : ""}`;
+    }
+  };
+}
+export {
+  createTodoWriteTool
+};

package/dist/tool-provider.cjs

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tool_provider_exports = {};
+__export(tool_provider_exports, {
+  todoToolsProvider: () => todoToolsProvider
+});
+module.exports = __toCommonJS(tool_provider_exports);
+var import_zod = require("zod");
+var import_todo_service = require("./todo-service.js");
+var import_todo_write_tool = require("./todo-write-tool.js");
+const DEFAULT_MAX_TODOS_PER_SESSION = 100;
+const DEFAULT_ENABLE_EVENTS = true;
+const TodoToolsConfigSchema = import_zod.z.object({
+  type: import_zod.z.literal("todo-tools"),
+  maxTodosPerSession: import_zod.z.number().int().positive().default(DEFAULT_MAX_TODOS_PER_SESSION).describe(`Maximum todos per session (default: ${DEFAULT_MAX_TODOS_PER_SESSION})`),
+  enableEvents: import_zod.z.boolean().default(DEFAULT_ENABLE_EVENTS).describe("Enable real-time events for todo updates")
+}).strict();
+const todoToolsProvider = {
+  type: "todo-tools",
+  configSchema: TodoToolsConfigSchema,
+  create: (config, context) => {
+    const { logger, agent, services } = context;
+    logger.debug("Creating TodoService for todo tools");
+    const storageManager = services?.storageManager;
+    if (!storageManager) {
+      throw new Error(
+        "TodoService requires storageManager service. Ensure it is available in ToolCreationContext."
+      );
+    }
+    const database = storageManager.getDatabase();
+    const eventBus = agent.agentEventBus;
+    const todoService = new import_todo_service.TodoService(database, eventBus, logger, {
+      maxTodosPerSession: config.maxTodosPerSession,
+      enableEvents: config.enableEvents
+    });
+    todoService.initialize().catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error(`TodoToolsProvider.create: Failed to initialize TodoService: ${message}`);
+    });
+    logger.debug("TodoService created - initialization will complete on first tool use");
+    return [(0, import_todo_write_tool.createTodoWriteTool)(todoService)];
+  },
+  metadata: {
+    displayName: "Todo Tools",
+    description: "Task tracking and workflow management (todo_write)",
+    category: "workflow"
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  todoToolsProvider
+});

package/dist/tool-provider.d.cts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { CustomToolProvider } from '@dexto/core';
+
+/**
+ * Todo Tools Provider
+ *
+ * Provides task tracking tools by wrapping TodoService.
+ * When registered, the provider initializes TodoService and creates the
+ * todo_write tool for managing task lists.
+ */
+
+/**
+ * Configuration schema for Todo tools provider.
+ */
+declare const TodoToolsConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"todo-tools">;
+    maxTodosPerSession: z.ZodDefault<z.ZodNumber>;
+    enableEvents: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    maxTodosPerSession: number;
+    enableEvents: boolean;
+    type: "todo-tools";
+}, {
+    type: "todo-tools";
+    maxTodosPerSession?: number | undefined;
+    enableEvents?: boolean | undefined;
+}>;
+type TodoToolsConfig = z.output<typeof TodoToolsConfigSchema>;
+/**
+ * Todo tools provider.
+ *
+ * Wraps TodoService and provides the todo_write tool for managing task lists.
+ *
+ * When registered via customToolRegistry, TodoService is automatically
+ * initialized and the todo_write tool becomes available to the agent.
+ */
+declare const todoToolsProvider: CustomToolProvider<'todo-tools', TodoToolsConfig>;
+
+export { todoToolsProvider };

package/dist/tool-provider.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { CustomToolProvider } from '@dexto/core';
+
+/**
+ * Todo Tools Provider
+ *
+ * Provides task tracking tools by wrapping TodoService.
+ * When registered, the provider initializes TodoService and creates the
+ * todo_write tool for managing task lists.
+ */
+
+/**
+ * Configuration schema for Todo tools provider.
+ */
+declare const TodoToolsConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"todo-tools">;
+    maxTodosPerSession: z.ZodDefault<z.ZodNumber>;
+    enableEvents: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    maxTodosPerSession: number;
+    enableEvents: boolean;
+    type: "todo-tools";
+}, {
+    type: "todo-tools";
+    maxTodosPerSession?: number | undefined;
+    enableEvents?: boolean | undefined;
+}>;
+type TodoToolsConfig = z.output<typeof TodoToolsConfigSchema>;
+/**
+ * Todo tools provider.
+ *
+ * Wraps TodoService and provides the todo_write tool for managing task lists.
+ *
+ * When registered via customToolRegistry, TodoService is automatically
+ * initialized and the todo_write tool becomes available to the agent.
+ */
+declare const todoToolsProvider: CustomToolProvider<'todo-tools', TodoToolsConfig>;
+
+export { todoToolsProvider };

package/dist/tool-provider.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { TodoService } from "./todo-service.js";
+import { createTodoWriteTool } from "./todo-write-tool.js";
+const DEFAULT_MAX_TODOS_PER_SESSION = 100;
+const DEFAULT_ENABLE_EVENTS = true;
+const TodoToolsConfigSchema = z.object({
+  type: z.literal("todo-tools"),
+  maxTodosPerSession: z.number().int().positive().default(DEFAULT_MAX_TODOS_PER_SESSION).describe(`Maximum todos per session (default: ${DEFAULT_MAX_TODOS_PER_SESSION})`),
+  enableEvents: z.boolean().default(DEFAULT_ENABLE_EVENTS).describe("Enable real-time events for todo updates")
+}).strict();
+const todoToolsProvider = {
+  type: "todo-tools",
+  configSchema: TodoToolsConfigSchema,
+  create: (config, context) => {
+    const { logger, agent, services } = context;
+    logger.debug("Creating TodoService for todo tools");
+    const storageManager = services?.storageManager;
+    if (!storageManager) {
+      throw new Error(
+        "TodoService requires storageManager service. Ensure it is available in ToolCreationContext."
+      );
+    }
+    const database = storageManager.getDatabase();
+    const eventBus = agent.agentEventBus;
+    const todoService = new TodoService(database, eventBus, logger, {
+      maxTodosPerSession: config.maxTodosPerSession,
+      enableEvents: config.enableEvents
+    });
+    todoService.initialize().catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.error(`TodoToolsProvider.create: Failed to initialize TodoService: ${message}`);
+    });
+    logger.debug("TodoService created - initialization will complete on first tool use");
+    return [createTodoWriteTool(todoService)];
+  },
+  metadata: {
+    displayName: "Todo Tools",
+    description: "Task tracking and workflow management (todo_write)",
+    category: "workflow"
+  }
+};
+export {
+  todoToolsProvider
+};

package/dist/types.cjs

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  TODO_STATUS_VALUES: () => TODO_STATUS_VALUES
+});
+module.exports = __toCommonJS(types_exports);
+const TODO_STATUS_VALUES = ["pending", "in_progress", "completed"];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TODO_STATUS_VALUES
+});

package/dist/types.d.cts

@@ -0,0 +1,56 @@
+/**
+ * Todo Service Types
+ *
+ * Types for todo list management and workflow tracking
+ */
+/**
+ * Valid todo status values
+ * Centralized constant to prevent duplication across domains
+ */
+declare const TODO_STATUS_VALUES: readonly ["pending", "in_progress", "completed"];
+/**
+ * Todo item status
+ */
+type TodoStatus = (typeof TODO_STATUS_VALUES)[number];
+/**
+ * Todo item with system metadata
+ */
+interface Todo {
+    id: string;
+    sessionId: string;
+    content: string;
+    activeForm: string;
+    status: TodoStatus;
+    position: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Todo input from tool (without system metadata)
+ */
+interface TodoInput {
+    content: string;
+    activeForm: string;
+    status: TodoStatus;
+}
+/**
+ * Todo list update result
+ */
+interface TodoUpdateResult {
+    todos: Todo[];
+    sessionId: string;
+    created: number;
+    updated: number;
+    deleted: number;
+}
+/**
+ * Configuration for TodoService
+ */
+interface TodoConfig {
+    /** Maximum todos per session */
+    maxTodosPerSession?: number;
+    /** Enable real-time events */
+    enableEvents?: boolean;
+}
+
+export { TODO_STATUS_VALUES, type Todo, type TodoConfig, type TodoInput, type TodoStatus, type TodoUpdateResult };