clm.tool_register("concurrent_async", {    description = "exercise concurrent lua async operations",    params_schema = {        type = "object",        properties = {            get_url = { type = "string" },            post_url = { type = "string" },        },        required = { "get_url", "post_url" },    },    no_prompt = true,    invoke = function(args, ctx)        local started = 0        local tasks = {            clm.spawn(function()                started = started + 1                local response, err = http.get(args.get_url)                if response == nil then                    error(err)                end                return response.body            end),            clm.spawn(function()                started = started + 1                local response, err = http.post(args.post_url, "{}")                if response == nil then                    error(err)                end                return response.body            end),            clm.spawn(function()                started = started + 1                clm.sleep(0)                return "slept"            end),            clm.spawn(function()                started = started + 1                return "multi", "value"            end),        }        if started ~= 0 then            ctx:fail("spawn ran a task before returning")            return        end        if tasks[1]:result() ~= nil then            ctx:fail("pending task unexpectedly had a result")            return        end        local first, wait_err = clm.wait_any(tasks)        if first == nil then            ctx:fail(wait_err)            return        end        local first_outcome = tasks[first]:result()        if first_outcome == nil or not first_outcome.ok then            ctx:fail("wait_any returned an unsuccessful task")            return        end        local outcomes = clm.await_all(tasks)        for i, outcome in ipairs(outcomes) do            if not outcome.ok then                ctx:fail("task " .. i .. " failed: " .. outcome.error)                return            end        end        ctx:complete(table.concat({            outcomes[1].value,            outcomes[2].value,            outcomes[3].value,            outcomes[4].value[1],            outcomes[4].value[2],        }, ":"))    end,}) clm.tool_register("concurrent_error", {    description = "exercise independent task outcomes",    params_schema = { type = "object" },    no_prompt = true,    invoke = function(_, ctx)        local tasks = {            clm.spawn(function()                clm.sleep(0)                return "survived"            end),            clm.spawn(function()                error("child boom")            end),        }        local outcomes = clm.await_all(tasks)        if not outcomes[1].ok or outcomes[1].value ~= "survived" then            ctx:fail("await_all cancelled an independent sibling")            return        end        if outcomes[2].ok or not outcomes[2].error:find("child boom", 1, true) then            ctx:fail("await_all did not preserve the child error")            return        end        ctx:complete(outcomes[1].value .. ":" .. outcomes[2].error)    end,}) clm.tool_register("concurrent_try_error", {    description = "exercise fail-fast task cancellation",    params_schema = { type = "object" },    no_prompt = true,    invoke = function(_, ctx)        local tasks = {            clm.spawn(function()                clm.sleep(30000)                return "too late"            end),            clm.spawn(function()                error("try boom")            end),        }        local results, err = clm.try_all(tasks)        if results ~= nil then            ctx:fail("try_all unexpectedly succeeded")            return        end        local cancelled = tasks[1]:result()        if cancelled == nil or not cancelled.cancelled then            ctx:fail("try_all did not cancel the unfinished sibling")            return        end        ctx:complete(err .. ":cancelled")    end,}) clm.tool_register("wait_timeout_cancel", {    description = "exercise wait timeout and explicit cancellation",    params_schema = { type = "object" },    no_prompt = true,    invoke = function(_, ctx)        local task = clm.spawn(function()            clm.sleep(30000)            return "too late"        end)        local index, err = clm.wait_any({ task }, 0)        if index ~= nil or err ~= "timeout" then            ctx:fail("wait_any did not time out")            return        end        if not task:cancel("test cancellation") then            ctx:fail("task cancellation failed")            return        end        if not task:cancel("ignored replacement") then            ctx:fail("task cancellation was not idempotent")            return        end        task:wait()        local outcome = task:result()        if outcome == nil or not outcome.cancelled or            outcome.error ~= "test cancellation" then            ctx:fail("cancelled task result is incorrect")            return        end        ctx:complete("timeout:cancelled")    end,}) clm.tool_register("complete_with_live_task", {    description = "exercise completion with a live task",    params_schema = { type = "object" },    no_prompt = true,    invoke = function(_, ctx)        clm.spawn(function()            clm.sleep(30000)        end)        ctx:complete("must not succeed")    end,}) clm.tool_register("complete_with_unobserved_error", {    description = "exercise completion with an unobserved task error",    params_schema = { type = "object" },    no_prompt = true,    invoke = function(_, ctx)        local task = clm.spawn(function()            error("unobserved boom")        end)        task:wait()        ctx:complete("must not succeed")    end,}) clm.tool_register("unawaited_task", {    description = "exercise abandoned task cancellation",    params_schema = { type = "object" },    no_prompt = true,    invoke = function()        clm.spawn(function()            while true do                clm.sleep(30000)            end        end)    end,})