@setluca/mcp 0.1.1 → 0.2.1

package/dist/task-tools/analytics.js

@@ -0,0 +1,168 @@
+import { Effect, Record } from "effect";
+import * as z from "zod/v4";
+import { formatError } from "../errors.js";
+import { WORKSPACE_INPUT_FIELDS } from "../operations.js";
+import { optionalField } from "../optional-field.js";
+import { listingIds, numberInput, taskRequest, } from "./runtime.js";
+const DEFAULT_CAMPAIGN_LIMIT = 5;
+const CAMPAIGN_BROADCAST_LIMIT = 10;
+const getAnalytics = {
+    name: "luca_analytics_rollup",
+    title: "Get campaign and broadcast analytics",
+    description: "Roll up performance across the coach's campaigns (per-campaign analytics for up to 5 recent campaigns) and recent broadcasts. Example: call with {} for the default rollup, or { campaignLimit: 3 }.",
+    inputSchema: {
+        ...WORKSPACE_INPUT_FIELDS,
+        campaignLimit: z
+            .number()
+            .int()
+            .min(1)
+            .max(5)
+            .optional()
+            .describe("How many recent campaigns to include (default 5)."),
+    },
+    readOnly: true,
+    untrustedContent: false,
+    composes: ["campaigns.list", "campaigns.analytics", "broadcasts.list"],
+    run: (api, operationById, input) => Effect.gen(function* () {
+        const campaignLimit = numberInput(input.campaignLimit, DEFAULT_CAMPAIGN_LIMIT);
+        const campaignPage = yield* api.request(taskRequest(operationById("campaigns.list"), input, {
+            query: { limit: campaignLimit },
+        }));
+        // broadcasts.list doesn't depend on the per-campaign analytics loop, so
+        // it runs alongside it instead of after it. Effect.all defaults to
+        // concurrency 1 (sequential), so without `concurrency: "unbounded"` here
+        // the broadcasts call would still wait on the whole loop below.
+        const [perCampaign, broadcasts] = yield* Effect.all([
+            Effect.forEach(listingIds(campaignPage, campaignLimit), (id) => api
+                .request(taskRequest(operationById("campaigns.analytics"), input, {
+                pathParams: { id },
+            }))
+                .pipe(Effect.catchAll((error) => 
+            // Structured formatter (see draft-belt note above): preserves
+            // the failing campaign's status/requestId instead of "[object …]".
+            Effect.succeed({ analyticsError: formatError(error) })), Effect.map((analytics) => [
+                id,
+                analytics,
+            ])), 
+            // Effect.forEach also defaults to concurrency 1. campaignLimit caps
+            // this at 5 independent per-campaign lookups, so unbounded is fine.
+            { concurrency: "unbounded" }),
+            api.request(taskRequest(operationById("broadcasts.list"), input, {
+                query: { limit: CAMPAIGN_BROADCAST_LIMIT },
+            })),
+        ], { concurrency: "unbounded" });
+        return { campaigns: Record.fromEntries(perCampaign), broadcasts };
+    }),
+};
+const ANALYTICS_PERIOD_VALUES = [
+    "this_week",
+    "this_month",
+    "last_week",
+    "last_month",
+    "last_30_days",
+];
+/**
+ * Every analytics read either task tool below can compose. magic_monday and
+ * deep_dive each build their own list from these entries rather than
+ * hand-listing operation ids a second time, so the two tools cannot drift
+ * apart on order, ids, or which reads are period-scoped.
+ */
+const ANALYTICS_READS = {
+    funnel: { key: "funnel", id: "analytics.funnel", periodScoped: true },
+    revenue: { key: "revenue", id: "analytics.revenue", periodScoped: true },
+    speedImpact: {
+        key: "speedImpact",
+        id: "analytics.speedImpact",
+        periodScoped: true,
+    },
+    forecast: {
+        key: "forecast",
+        id: "analytics.forecast",
+        periodScoped: false,
+    },
+    callIntelligence: {
+        key: "callIntelligence",
+        id: "analytics.callIntelligence",
+        periodScoped: true,
+    },
+    ghostedLeads: {
+        key: "ghostedLeads",
+        id: "analytics.ghostedLeads",
+        periodScoped: true,
+    },
+    trustScore: {
+        key: "trustScore",
+        id: "analytics.trustScore",
+        periodScoped: true,
+    },
+};
+/** The five reads luca_analytics_magic_monday composes, always this_week. */
+const MAGIC_MONDAY_READS = [
+    ANALYTICS_READS.funnel,
+    ANALYTICS_READS.revenue,
+    ANALYTICS_READS.speedImpact,
+    ANALYTICS_READS.forecast,
+    ANALYTICS_READS.callIntelligence,
+];
+/** magic_monday's five reads plus the two extra deep-dive-only reads. */
+const DEEP_DIVE_READS = [
+    ...MAGIC_MONDAY_READS,
+    ANALYTICS_READS.ghostedLeads,
+    ANALYTICS_READS.trustScore,
+];
+/**
+ * Run a list of analytics reads in parallel and return them keyed by `key`.
+ * Effect.all defaults to concurrency 1 (sequential); these reads don't depend
+ * on each other, so serializing them would only add latency, not correctness.
+ */
+function analyticsFanOut(api, operationById, input, period, reads) {
+    return Effect.all(reads.map((read) => api
+        .request(taskRequest(operationById(read.id), input, {
+        ...optionalField("query", read.periodScoped ? { period } : undefined),
+    }))
+        .pipe(Effect.map((value) => [read.key, value]))), { concurrency: "unbounded" }).pipe(Effect.map((entries) => Record.fromEntries(entries)));
+}
+const magicMonday = {
+    name: "luca_analytics_magic_monday",
+    title: "Get the Magic Monday report",
+    description: "Return the coach's weekly business intelligence report: pipeline funnel, revenue and ROI, response-speed impact, a point-in-time revenue forecast, and call intelligence (show/close rates), all for the current week. Composes five analytics reads into a single call. Example: call with {} on Monday morning for the week's report.",
+    inputSchema: {
+        ...WORKSPACE_INPUT_FIELDS,
+    },
+    readOnly: true,
+    untrustedContent: false,
+    composes: MAGIC_MONDAY_READS.map((read) => read.id),
+    run: (api, operationById, input) => analyticsFanOut(api, operationById, input, "this_week", MAGIC_MONDAY_READS),
+};
+const analyticsDeepDive = {
+    name: "luca_analytics_deep_dive",
+    title: "Run a deep-dive analytics investigation",
+    description: 'Answer a specific business question by composing all seven analytics reads in one call: pipeline funnel, revenue and ROI, response-speed impact, a point-in-time revenue forecast, call intelligence (show/close rates), ghosted-lead recovery, and coach trust/auto-send status. Broader than luca_analytics_magic_monday (which is the fixed weekly report); use this when the coach asks a specific question that needs cross-referencing several of these numbers together. Example: call with {question: "why did close rate drop this month?", period: "this_month"}.',
+    inputSchema: {
+        ...WORKSPACE_INPUT_FIELDS,
+        question: z
+            .string()
+            .min(1)
+            .max(500)
+            .describe("The coach's specific question driving this investigation, e.g. 'why did close rate drop this month?'. Not sent to any API — captured so the caller's reasoning stays anchored to what the coach actually asked."),
+        period: z
+            .enum(ANALYTICS_PERIOD_VALUES)
+            .optional()
+            .describe("Period for the period-scoped reads (funnel, revenue, speedImpact, callIntelligence, ghostedLeads, trustScore). Forecast ignores this — it is always point-in-time. Defaults to this_month."),
+    },
+    readOnly: true,
+    untrustedContent: false,
+    composes: DEEP_DIVE_READS.map((read) => read.id),
+    run: (api, operationById, input) => {
+        const parsedPeriod = z
+            .enum(ANALYTICS_PERIOD_VALUES)
+            .safeParse(input.period);
+        const period = parsedPeriod.success ? parsedPeriod.data : "this_month";
+        return analyticsFanOut(api, operationById, input, period, DEEP_DIVE_READS);
+    },
+};
+export const analyticsTaskTools = [
+    getAnalytics,
+    magicMonday,
+    analyticsDeepDive,
+];

package/dist/task-tools/bookings.js

@@ -0,0 +1,157 @@
+import { Effect, Option } from "effect";
+import * as z from "zod/v4";
+import { WORKSPACE_INPUT_FIELDS } from "../operations.js";
+import { optionalField } from "../optional-field.js";
+import { independentWrite, numberInput, stringInput, taskRequest, } from "./runtime.js";
+/** How far past the requested slot to look when offering alternatives. */
+const AVAILABILITY_WINDOW_MS = 24 * 60 * 60 * 1000;
+/**
+ * The slots the provider reports as open in the window starting at `slotAt`.
+ *
+ * `Option.none()` means "we could not tell", which is different from "nothing
+ * is open". The availability route answers with `source: "fallback"` or
+ * `"provider_error"` when it could not reach the provider, and it defaults to
+ * Calendly when the caller names no provider, so a coach on Cal.com asking
+ * without one gets a confident-looking answer about the wrong calendar. Only a
+ * `live_provider` read is worth blocking a booking over.
+ */
+const openSlotsAt = (api, operationById, input, slotAt) => Effect.gen(function* () {
+    const start = new Date(slotAt);
+    if (Number.isNaN(start.getTime())) {
+        return Option.none();
+    }
+    const page = yield* Effect.catchAll(api.request(taskRequest(operationById("bookings.availability"), input, {
+        query: {
+            start: start.toISOString(),
+            end: new Date(start.getTime() + AVAILABILITY_WINDOW_MS).toISOString(),
+            ...optionalField("provider", input.provider),
+        },
+    })), 
+    // A failed availability read must not block the booking. The agent is no
+    // worse off than before this check existed.
+    () => Effect.succeed(null));
+    const parsed = AvailabilityPageSchema.safeParse(page);
+    if (!parsed.success || parsed.data.source !== "live_provider") {
+        return Option.none();
+    }
+    return Option.some(parsed.data.slots.map((slot) => slot.startsAt));
+});
+const AvailabilityPageSchema = z.object({
+    source: z.string(),
+    slots: z.array(z.object({ startsAt: z.string() })),
+});
+/**
+ * Whether two ISO-8601 instants name the same moment, whatever their offset.
+ *
+ * An unparseable instant is `NaN`, which is not equal to itself, so a garbled
+ * slot on either side answers false without a guard of its own.
+ */
+function sameInstant(left, right) {
+    return new Date(left).getTime() === new Date(right).getTime();
+}
+const bookCall = {
+    name: "luca_book_call",
+    title: "Book a call with a lead",
+    description: 'Book a lead into a slot the provider confirms is open. Checks availability first and returns the open slots instead of booking when the requested one is taken. Example: call with { leadId, slotAt: "2026-07-14T15:00:00Z" } after the lead agreed to a time.',
+    inputSchema: {
+        ...WORKSPACE_INPUT_FIELDS,
+        leadId: z.string().min(1).describe("The lead to book."),
+        slotAt: z.string().describe("ISO-8601 start time for the call."),
+        provider: z
+            .string()
+            .optional()
+            .describe("The coach's booking provider. Pass it when the coach is not on Calendly, or the availability check reads the wrong calendar."),
+        idempotencyKey: z
+            .string()
+            .optional()
+            .describe("Reuse the same key when retrying this exact booking."),
+    },
+    readOnly: false,
+    untrustedContent: false,
+    composes: ["bookings.availability", "bookings.create"],
+    run: (api, operationById, input) => Effect.gen(function* () {
+        const slotAt = stringInput(input.slotAt);
+        const open = yield* openSlotsAt(api, operationById, input, slotAt);
+        // Refuse only on a confident "that slot is not open". Handing back the
+        // real slots lets the agent pick again in one turn instead of writing a
+        // booking the provider will reject later.
+        if (Option.isSome(open) &&
+            !open.value.some((candidate) => sameInstant(candidate, slotAt))) {
+            return {
+                booked: false,
+                reason: "slot_not_available",
+                requestedSlotAt: slotAt,
+                openSlots: open.value,
+            };
+        }
+        return yield* api.request(taskRequest(operationById("bookings.create"), input, {
+            body: { leadId: input.leadId, slotAt: input.slotAt },
+        }));
+    }),
+};
+/** How long a reschedule link stays usable when the caller names no window. */
+const DEFAULT_GUEST_LINK_HOURS = 168;
+const rescheduleCall = {
+    name: "luca_reschedule_call",
+    title: "Move a call to a new time",
+    description: 'Move a booked call to a new time and hand back a fresh reschedule link for the lead. Checks the new slot is open first and returns the open slots instead of moving the call when it is taken. Example: call with { bookingId, slotAt: "2026-07-16T15:00:00Z" } after the lead asked to push the call. The lead is not messaged \u2014 send them the link yourself, or draft the message through the review queue.',
+    inputSchema: {
+        ...WORKSPACE_INPUT_FIELDS,
+        bookingId: z.string().min(1).describe("The booking to move."),
+        slotAt: z.string().describe("ISO-8601 start time to move the call to."),
+        provider: z
+            .string()
+            .optional()
+            .describe("The coach's booking provider. Pass it when the coach is not on Calendly, or the availability check reads the wrong calendar."),
+        expiresInHours: z
+            .number()
+            .int()
+            .min(1)
+            .max(720)
+            .optional()
+            .describe(`How long the new reschedule link stays usable. Defaults to ${DEFAULT_GUEST_LINK_HOURS} hours.`),
+        idempotencyKey: z
+            .string()
+            .optional()
+            .describe("Reuse the same key when retrying this exact reschedule."),
+    },
+    readOnly: false,
+    untrustedContent: false,
+    composes: [
+        "bookings.availability",
+        "bookings.update",
+        "bookings.guestLinks.create",
+    ],
+    run: (api, operationById, input) => Effect.gen(function* () {
+        const slotAt = stringInput(input.slotAt);
+        const bookingId = stringInput(input.bookingId);
+        const open = yield* openSlotsAt(api, operationById, input, slotAt);
+        if (Option.isSome(open) &&
+            !open.value.some((candidate) => sameInstant(candidate, slotAt))) {
+            return {
+                rescheduled: false,
+                reason: "slot_not_available",
+                requestedSlotAt: slotAt,
+                openSlots: open.value,
+            };
+        }
+        const booking = yield* api.request(taskRequest(operationById("bookings.update"), input, {
+            pathParams: { id: bookingId },
+            body: { slotAt },
+        }));
+        // The call has already moved by the time the link is minted. Failing the
+        // whole tool here would tell the agent the reschedule did not happen,
+        // when the only thing missing is a link it can mint again.
+        const guestLinks = yield* independentWrite("guestLinksError", api.request(taskRequest(operationById("bookings.guestLinks.create"), input, {
+            pathParams: { id: bookingId },
+            body: {
+                expiresInHours: numberInput(input.expiresInHours, DEFAULT_GUEST_LINK_HOURS),
+            },
+        })));
+        return { rescheduled: true, booking, guestLinks };
+    }),
+};
+export const bookingTaskTools = [
+    bookCall,
+    rescheduleCall,
+];

package/dist/task-tools/cadences.js

@@ -0,0 +1,65 @@
+import * as z from "zod/v4";
+import { confirmInput, WORKSPACE_INPUT_FIELDS } from "../operations.js";
+import { stringInput, taskRequest, textBody, } from "./runtime.js";
+const rescueSilentLeads = {
+    name: "luca_rescue_silent_leads",
+    title: "Enroll silent leads into the rescue cadence",
+    description: 'Enroll one or more silent leads into the multi-day rescue cadence. THIS STARTS OUTBOUND TOUCHES to real leads over the coming days — pass confirm: true to proceed. cadenceTemplate is light | standard | aggressive (default standard). Example: { leadIds: ["..."], cadenceTemplate: "standard", confirm: true }.',
+    inputSchema: {
+        ...WORKSPACE_INPUT_FIELDS,
+        leadIds: z
+            .array(z.string())
+            .min(1)
+            .max(100)
+            .describe("Lead ids to enroll (max 100). Non-tenant ids are skipped."),
+        cadenceTemplate: z
+            .enum(["light", "standard", "aggressive"])
+            .optional()
+            .describe("Cadence intensity (default standard)."),
+        ...confirmInput,
+        idempotencyKey: z
+            .string()
+            .optional()
+            .describe("Reuse the same key when retrying this exact enrollment."),
+    },
+    readOnly: false,
+    untrustedContent: false,
+    confirmRequired: true,
+    composes: ["cadences.rescueStart"],
+    run: (api, operationById, input) => api.request(taskRequest(operationById("cadences.rescueStart"), input, {
+        body: {
+            leadIds: input.leadIds,
+            ...textBody("cadenceTemplate", input.cadenceTemplate),
+        },
+    })),
+};
+const pauseCadence = {
+    name: "luca_pause_cadence",
+    title: "Pause a lead's rescue cadence",
+    description: 'Cancel a lead\'s running rescue cadence so no further touches are sent. Safe to call twice (a no-op once cancelled). Example: call with { leadId, reason: "lead replied elsewhere" }.',
+    inputSchema: {
+        ...WORKSPACE_INPUT_FIELDS,
+        leadId: z.string().min(1).describe("The lead whose cadence to pause."),
+        reason: z
+            .string()
+            .min(1)
+            .max(500)
+            .optional()
+            .describe("Optional operator reason, stored on the cadence."),
+        idempotencyKey: z
+            .string()
+            .optional()
+            .describe("Reuse the same key when retrying this exact pause."),
+    },
+    readOnly: false,
+    untrustedContent: false,
+    composes: ["cadences.pause"],
+    run: (api, operationById, input) => api.request(taskRequest(operationById("cadences.pause"), input, {
+        pathParams: { id: stringInput(input.leadId) },
+        body: textBody("reason", input.reason),
+    })),
+};
+export const cadenceTaskTools = [
+    rescueSilentLeads,
+    pauseCadence,
+];

package/dist/task-tools/calls.js

@@ -0,0 +1,202 @@
+import { Effect, Option, Schema } from "effect";
+import * as z from "zod/v4";
+import { WORKSPACE_INPUT_FIELDS } from "../operations.js";
+import { optionalField } from "../optional-field.js";
+import { independentWrite, stringInput, taskRequest, textBody, } from "./runtime.js";
+const postCallQueue = {
+    name: "luca_post_call_queue",
+    title: "List the post-call work",
+    description: "Return everything waiting on the coach after a call: calls that still need a report on how they went, and attended calls with no revenue outcome recorded. The two halves are tracked separately by the API, so a call can sit on one list and not the other. Close an item with luca_close_call_loop. Example: call with {} after a day of calls.",
+    inputSchema: {
+        ...WORKSPACE_INPUT_FIELDS,
+    },
+    readOnly: true,
+    untrustedContent: true,
+    composes: ["callEvents.needingFeedback", "bookings.needsOutcome"],
+    run: (api, operationById, input) => 
+    // Neither read depends on the other, and Effect.all defaults to
+    // concurrency 1, so without this the second waits on the first for nothing.
+    Effect.all({
+        needingFeedback: api.request(taskRequest(operationById("callEvents.needingFeedback"), input)),
+        needingOutcome: api.request(taskRequest(operationById("bookings.needsOutcome"), input)),
+    }, { concurrency: "unbounded" }),
+};
+/**
+ * The id of the call event attached to a booking, if the API has one. A booking
+ * whose call has not happened yet answers 404, which is the normal case rather
+ * than a failure. So is any other read error here, because the outcome write
+ * below is worth doing on its own.
+ */
+const CallEventId = Schema.Struct({
+    callEvent: Schema.Struct({ id: Schema.String }),
+});
+const decodeCallEventId = Schema.decodeUnknownOption(CallEventId);
+const ATTENDANCE_VALUES = [
+    "completed",
+    "no_show",
+    "rescheduled",
+    "cancelled",
+];
+const OUTCOME_VALUES = ["won", "lost", "open"];
+/**
+ * The revenue half of the body, shaped by the status it carries. The API takes
+ * one of three variants and rejects a mix, so building it here keeps the tool
+ * from sending, say, an amount alongside a loss reason.
+ */
+function outcomeBody(input) {
+    const common = {
+        status: input.status,
+        ...textBody("note", input.note),
+        ...optionalField("expectedVersion", input.expectedVersion),
+    };
+    if (input.status === "won") {
+        return {
+            ...common,
+            ...optionalField("amountMinor", input.amountMinor),
+            ...textBody("currency", input.currency),
+        };
+    }
+    if (input.status === "lost") {
+        return {
+            ...common,
+            lossReasonDefinitionId: stringInput(input.lossReasonDefinitionId),
+        };
+    }
+    return {
+        ...common,
+        nextFollowUpAt: stringInput(input.nextFollowUpAt),
+        followUpTimezone: stringInput(input.followUpTimezone),
+    };
+}
+const closeCallLoop = {
+    name: "luca_close_call_loop",
+    title: "Close the loop on a call",
+    description: 'File what happened on a call and what it was worth, in one call. Reports attendance on the call event (completed, no_show, rescheduled, or cancelled) and, when an outcome is given, records the booking outcome: won with an amount, lost with a reason id from luca_bookings_outcomeReasons_list, or open with the next follow-up. Nothing is sent to the lead. Example: { bookingId, attendance: "completed", outcome: "won", amountMinor: 250000, currency: "USD" }.',
+    inputSchema: {
+        ...WORKSPACE_INPUT_FIELDS,
+        bookingId: z
+            .string()
+            .min(1)
+            .describe("The booking whose call just happened."),
+        attendance: z
+            .enum(ATTENDANCE_VALUES)
+            .describe("What happened to the call itself."),
+        rating: z
+            .number()
+            .int()
+            .min(1)
+            .max(5)
+            .optional()
+            .describe("The coach's 1-5 rating of the call."),
+        notes: z
+            .string()
+            .min(1)
+            .max(4000)
+            .optional()
+            .describe("The coach's notes on the call, stored on the call event."),
+        outcome: z
+            .enum(OUTCOME_VALUES)
+            .optional()
+            .describe("The revenue outcome. Leave it off to report attendance only and record the money later."),
+        amountMinor: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("Deal value in minor units (cents) when outcome is won."),
+        currency: z
+            .string()
+            .length(3)
+            .optional()
+            .describe("ISO-4217 currency for amountMinor, uppercase."),
+        lossReasonDefinitionId: z
+            .string()
+            .optional()
+            .describe("Required when outcome is lost: a reason id from luca_bookings_outcomeReasons_list."),
+        nextFollowUpAt: z
+            .string()
+            .optional()
+            .describe("Required when outcome is open: ISO-8601 follow-up time."),
+        followUpTimezone: z
+            .string()
+            .optional()
+            .describe("Required when outcome is open: IANA timezone the follow-up is scheduled in."),
+        outcomeNote: z
+            .string()
+            .min(1)
+            .max(5000)
+            .optional()
+            .describe("Note stored on the revenue outcome, separate from notes."),
+        expectedVersion: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe("The outcome version you read, when correcting an earlier outcome. A stale version returns 409 with the current one."),
+        idempotencyKey: z
+            .string()
+            .optional()
+            .describe("Reuse the same key when retrying this exact report. Both writes are scoped by route, so one key covers the pair."),
+    },
+    readOnly: false,
+    untrustedContent: true,
+    composes: [
+        "callEvents.byBooking",
+        "callEvents.feedback",
+        "bookings.outcome.record",
+    ],
+    run: (api, operationById, input) => Effect.gen(function* () {
+        const bookingId = stringInput(input.bookingId);
+        const page = yield* Effect.catchAll(api.request(taskRequest(operationById("callEvents.byBooking"), input, {
+            pathParams: { bookingId },
+        })), () => Effect.succeed(null));
+        const feedback = yield* Option.match(decodeCallEventId(page), {
+            onNone: () => 
+            // No call event means attendance has nowhere to go. The revenue write
+            // below still runs, and that is the half the coach is usually after.
+            Effect.succeed({
+                reported: false,
+                reason: "no_call_event_for_booking",
+            }),
+            onSome: (decoded) => 
+            // The revenue write below is worth doing even when the attendance
+            // report fails, so this failure becomes a field rather than ending
+            // the tool call.
+            independentWrite("feedbackError", api.request(taskRequest(operationById("callEvents.feedback"), input, {
+                pathParams: { id: decoded.callEvent.id },
+                body: {
+                    outcome: input.attendance,
+                    ...optionalField("rating", input.rating),
+                    ...textBody("notes", input.notes),
+                },
+            }))),
+        });
+        const outcomeStatus = z
+            .enum(OUTCOME_VALUES)
+            .safeParse(input.outcome ?? undefined);
+        if (!outcomeStatus.success) {
+            return { feedback };
+        }
+        // The attendance report already landed. Failing the whole tool here
+        // would tell the agent nothing was written and invite a retry that files
+        // the attendance twice under a fresh key.
+        const outcome = yield* independentWrite("outcomeError", api.request(taskRequest(operationById("bookings.outcome.record"), input, {
+            pathParams: { id: bookingId },
+            body: outcomeBody({
+                status: outcomeStatus.data,
+                note: input.outcomeNote,
+                amountMinor: input.amountMinor,
+                currency: input.currency,
+                lossReasonDefinitionId: input.lossReasonDefinitionId,
+                nextFollowUpAt: input.nextFollowUpAt,
+                followUpTimezone: input.followUpTimezone,
+                expectedVersion: input.expectedVersion,
+            }),
+        })));
+        return { feedback, outcome };
+    }),
+};
+export const callTaskTools = [
+    postCallQueue,
+    closeCallLoop,
+];