@xingular/harness 1.2.0 → 1.3.1-unstable.0

package/dist/sdk/tools/checklist.js

@@ -1,55 +0,0 @@
-// The run's own checklist: the model writes the whole list each time, and the run records it as
-// a `checklist.updated` event. It only changes run state, so it stays callable in plan mode.
-import { checklistItemSchema, MAX_CHECKLIST_ITEMS } from "../sessions/contracts.js";
-export const CHECKLIST_WRITE = 'checklist_write';
-const MARK = { pending: '[ ]', in_progress: '[~]', completed: '[x]' };
-/** The checklist as the model reads it back. */
-export function describeChecklist(items) {
-    if (!items.length)
-        return 'The checklist is empty.';
-    return items.map((item) => `${MARK[item.status]} ${item.text}`).join('\n');
-}
-/** The latest checklist a run wrote, or an empty list. */
-export function checklistOf(events) {
-    const last = events.filter((event) => event.type === 'checklist.updated').at(-1);
-    const items = last?.payload?.items;
-    return Array.isArray(items) ? items.flatMap((item) => {
-        const parsed = checklistItemSchema.safeParse(item);
-        return parsed.success ? [parsed.data] : [];
-    }) : [];
-}
-export function checklistTool(run) {
-    return {
-        name: CHECKLIST_WRITE,
-        label: 'Write the checklist',
-        description: 'Keep a checklist of the steps of the current work. The user watches this list to follow your progress, so write it early and keep it current. Send the whole list every time; it replaces the previous one. ' +
-            'Use it whenever the work has several distinct steps or will take several tool calls, when the user gives several things to do, and when a subagent brief asks for more than one thing. Do not use it for a single, simple step or for conversation. ' +
-            'Statuses: pending, in_progress, completed. Keep exactly one step in_progress while you work, mark a step completed as soon as it is done (not in batches), and add steps you discover. ' +
-            'Before your final response, write one final checklist update: mark every fully completed step completed, and leave unfinished or blocked steps in their accurate pending or in_progress status. Never mark unfinished work completed. ' +
-            'Only mark a step completed when it is fully done; if something blocks it, keep it in_progress and add a step for the blocker.',
-        parameters: (Type) => Type.Object({
-            items: Type.Array(Type.Object({
-                text: Type.String({ description: 'One step, as a short imperative line' }),
-                status: Type.Union([Type.Literal('pending'), Type.Literal('in_progress'), Type.Literal('completed')])
-            }), { maxItems: MAX_CHECKLIST_ITEMS })
-        }),
-        readOnly: true,
-        planModeSafe: () => true,
-        execute: async (input) => {
-            if (!Array.isArray(input.items))
-                return 'Send items: the whole checklist as an array.';
-            if (input.items.length > MAX_CHECKLIST_ITEMS)
-                return `Keep the checklist to ${MAX_CHECKLIST_ITEMS} steps or fewer.`;
-            const items = [];
-            for (const raw of input.items) {
-                const entry = raw;
-                const parsed = checklistItemSchema.safeParse({ text: typeof entry?.text === 'string' ? entry.text.trim() : entry?.text, status: entry?.status });
-                if (!parsed.success)
-                    return 'Every step needs text of 1 to 500 characters and a status of pending, in_progress or completed.';
-                items.push(parsed.data);
-            }
-            run.emit('checklist.updated', { items });
-            return describeChecklist(items);
-        }
-    };
-}