letagents 0.12.8 → 0.12.10

package/dist/mcp/server/tools/tasks/mutation-tools.js

@@ -0,0 +1,121 @@
+import { z } from "zod";
+import { deriveTaskPresenceStatus } from "../../../agent-presence.js";
+import { getRememberedRoomPresence, syncRoomPresence, toPublicAgentIdentity, } from "../../runtime.js";
+import { patchTask } from "./api.js";
+import { resolveTaskToolIdentity, resolveTaskToolTarget, taskActorPayload, } from "./context.js";
+import { jsonToolResponse, taskToolError } from "./response.js";
+import { deprecatedAssigneeSchema, boardIntentApprovalSchema, TASK_STATUSES, workerTaskIdentitySchema, workflowArtifactSchema, } from "./schemas.js";
+export function registerTaskMutationTools(server) {
+    server.tool("claim_task", "Claim an accepted task. The task must be in 'accepted' " +
+        "status. This sets the assignee to you and moves the status to 'assigned'. " +
+        "Do NOT claim proposed tasks — they need to be accepted first.", {
+        task_id: z.string().describe("The task ID to claim, e.g. 'task_1'"),
+        assignee: deprecatedAssigneeSchema,
+        ...workerTaskIdentitySchema,
+        ...boardIntentApprovalSchema,
+    }, async ({ task_id, assignee: _assignee, room_id, conversation_id: _conversation_id, agent_session_id, board_intent_id, board_approval_token }) => {
+        const target = resolveTaskToolTarget(room_id);
+        if (!target)
+            return taskToolError("Not in a room.");
+        try {
+            const { identity, agentSession } = await resolveTaskToolIdentity(target, agent_session_id);
+            const updated = await patchTask(target, task_id, {
+                status: "assigned",
+                assignee: identity.actor_label,
+                ...taskActorPayload(identity, agentSession),
+                assignee_agent_key: identity.canonical_key,
+                board_intent_id,
+                board_approval_token,
+            });
+            await syncRoomPresence(target.effectiveRoomId, identity, {
+                status: "working",
+                status_text: `claimed ${task_id}`,
+            }, agentSession);
+            return jsonToolResponse({ success: true, task: updated, agent_identity: toPublicAgentIdentity(identity) }, 2);
+        }
+        catch (error) {
+            return taskToolError(String(error));
+        }
+    });
+    server.tool("update_task", "Update a task's status or assignee. Status transitions are validated — " +
+        "only valid transitions are allowed (e.g. in_progress → in_review, " +
+        "but NOT proposed → in_progress).", {
+        task_id: z.string().describe("The task ID to update"),
+        status: z.enum(TASK_STATUSES).optional().describe("New status for the task"),
+        assignee: z
+            .string()
+            .optional()
+            .describe("New assignee for the task. Defaults to the current agent when status=assigned."),
+        pr_url: z.string().optional().describe("PR URL to link to the task"),
+        workflow_artifacts: z
+            .array(workflowArtifactSchema)
+            .max(32)
+            .optional()
+            .describe("Persisted provider-neutral task workflow artifacts to attach to the task"),
+        ...workerTaskIdentitySchema,
+        ...boardIntentApprovalSchema,
+    }, async ({ task_id, status, assignee, pr_url, workflow_artifacts, room_id, conversation_id: _conversation_id, agent_session_id, board_intent_id, board_approval_token }) => {
+        const target = resolveTaskToolTarget(room_id);
+        if (!target)
+            return taskToolError("Not in a room.");
+        try {
+            const { identity, agentSession } = await resolveTaskToolIdentity(target, agent_session_id);
+            const rememberedPresence = getRememberedRoomPresence(target.effectiveRoomId, identity);
+            const nextAssignee = status === "assigned" && !assignee ? identity.actor_label : assignee;
+            const nextAssigneeAgentKey = nextAssignee === identity.actor_label ? identity.canonical_key : undefined;
+            const updated = await patchTask(target, task_id, {
+                status,
+                assignee: nextAssignee,
+                assignee_agent_key: nextAssigneeAgentKey,
+                pr_url,
+                workflow_artifacts,
+                board_intent_id,
+                board_approval_token,
+                ...taskActorPayload(identity, agentSession),
+            });
+            await syncRoomPresence(target.effectiveRoomId, identity, {
+                status: deriveTaskPresenceStatus(status ?? null, rememberedPresence.status),
+                status_text: status ? `${task_id} -> ${status}` : rememberedPresence.status_text,
+            }, agentSession);
+            return jsonToolResponse({
+                success: true,
+                task: updated,
+                agent_identity: toPublicAgentIdentity(identity),
+            }, 2);
+        }
+        catch (error) {
+            return taskToolError(String(error));
+        }
+    });
+    server.tool("complete_task", "Submit a task for review. Moves the task to 'in_review' status. " +
+        "Optionally attach a PR URL. After this, a reviewer must confirm " +
+        "the work is merged before it can be marked done.", {
+        task_id: z.string().describe("The task ID to submit for review"),
+        pr_url: z.string().optional().describe("GitHub PR URL for the work"),
+        ...workerTaskIdentitySchema,
+    }, async ({ task_id, pr_url, room_id, conversation_id: _conversation_id, agent_session_id }) => {
+        const target = resolveTaskToolTarget(room_id);
+        if (!target)
+            return taskToolError("Not in a room.");
+        try {
+            const { identity, agentSession } = await resolveTaskToolIdentity(target, agent_session_id);
+            const updated = await patchTask(target, task_id, {
+                status: "in_review",
+                pr_url,
+                ...taskActorPayload(identity, agentSession),
+            });
+            await syncRoomPresence(target.effectiveRoomId, identity, {
+                status: "reviewing",
+                status_text: `${task_id} -> in_review`,
+            }, agentSession);
+            return jsonToolResponse({
+                success: true,
+                task: updated,
+                agent_identity: toPublicAgentIdentity(identity),
+            }, 2);
+        }
+        catch (error) {
+            return taskToolError(String(error));
+        }
+    });
+}

package/dist/mcp/server/tools/tasks/response.js

@@ -0,0 +1,13 @@
+export function jsonToolResponse(value, space) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(value, null, space),
+            },
+        ],
+    };
+}
+export function taskToolError(error) {
+    return jsonToolResponse({ success: false, error });
+}

package/dist/mcp/server/tools/tasks/schemas.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+export const TASK_STATUSES = [
+    "proposed",
+    "accepted",
+    "assigned",
+    "in_progress",
+    "blocked",
+    "in_review",
+    "merged",
+    "done",
+    "cancelled",
+];
+export const workerTaskIdentitySchema = {
+    room_id: z.string().optional().describe("Canonical room ID. Defaults to current room."),
+    conversation_id: z
+        .string()
+        .optional()
+        .describe("Deprecated for worker writes; registered worker session identity is used."),
+    agent_session_id: z
+        .string()
+        .optional()
+        .describe("Registered agent session to use for this task action. Required for worker task writes."),
+};
+export const boardIntentApprovalSchema = {
+    board_intent_id: z.string().optional().describe("Approved board intent id for high-impact board actions."),
+    board_approval_token: z.string().optional().describe("Scoped approval token returned by approve_board_intent for non-task_create intents."),
+};
+export const taskReviewIdentitySchema = {
+    ...workerTaskIdentitySchema,
+    agent_session_id: z
+        .string()
+        .optional()
+        .describe("Registered agent session to use for this review action. Required for worker review writes."),
+};
+export const taskLeaseIdentitySchema = {
+    ...workerTaskIdentitySchema,
+    agent_session_id: z
+        .string()
+        .optional()
+        .describe("Registered agent session to use for this lease action. Required for worker lease writes."),
+};
+export const deprecatedAssigneeSchema = z
+    .string()
+    .optional()
+    .describe("Deprecated override. Agent identity is resolved automatically on room entry.");
+export const workflowArtifactSchema = z
+    .object({
+    provider: z.enum(["git", "github", "gitlab", "bitbucket", "unknown"]),
+    kind: z.enum([
+        "issue",
+        "branch",
+        "commit",
+        "diff",
+        "change_summary",
+        "pull_request",
+        "merge_request",
+        "review",
+        "check_run",
+        "merge",
+    ]),
+    id: z.string().nullable().optional(),
+    number: z.number().int().nullable().optional(),
+    title: z.string().nullable().optional(),
+    url: z.string().nullable().optional(),
+    ref: z.string().nullable().optional(),
+    state: z.string().nullable().optional(),
+})
+    .strict();

package/dist/mcp/server/tools/tasks.js

@@ -0,0 +1 @@
+export { registerTaskTools } from "./tasks/index.js";