@setluca/mcp 0.2.1 → 0.3.0

package/dist/task-tools/analytics.js

@@ -1,59 +1,15 @@
-import { Effect, Record } from "effect";
-import * as z from "zod/v4";
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as R from "effect/Record";
+import * as Result from "effect/Result";
+import * as Schema from "effect/Schema";
 import { formatError } from "../errors.js";
-import { WORKSPACE_INPUT_FIELDS } from "../operations.js";
+import { NonEmptyString, WORKSPACE_INPUT_FIELDS } from "../fields.js";
 import { optionalField } from "../optional-field.js";
-import { listingIds, numberInput, taskRequest, } from "./runtime.js";
+import { failureAsField, listingIds, numberInput, operationResult, resultOrError, sectionResult, taskTool, } 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",
@@ -61,11 +17,12 @@ const ANALYTICS_PERIOD_VALUES = [
     "last_month",
     "last_30_days",
 ];
+const decodeAnalyticsPeriod = Schema.decodeUnknownOption(Schema.Literals(ANALYTICS_PERIOD_VALUES));
 /**
  * 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.
+ * deep_dive each build their own list from these entries, so the two tools
+ * cannot drift apart on order or on which reads are period-scoped. A read whose
+ * id is missing from the tool's `composes` does not compile.
  */
 const ANALYTICS_READS = {
     funnel: { key: "funnel", id: "analytics.funnel", periodScoped: true },
@@ -110,57 +67,159 @@ const DEEP_DIVE_READS = [
     ANALYTICS_READS.ghostedLeads,
     ANALYTICS_READS.trustScore,
 ];
+/** A section the report left out because its read failed. */
+const FailedSection = Schema.Struct({
+    section: Schema.String,
+    error: Schema.String,
+});
+/**
+ * Each read's response under the key it lands at, present when the read
+ * succeeded, plus `failedSections` naming each read that did not.
+ */
+function analyticsOutput(reads) {
+    return Schema.Struct({
+        ...R.fromEntries(reads.map((read) => [
+            read.key,
+            Schema.optionalKey(operationResult(read.id)),
+        ])),
+        failedSections: Schema.optionalKey(Schema.Array(FailedSection).annotate({
+            description: "Sections missing from this report because their read failed. The report is partial whenever this is present.",
+        })),
+    });
+}
+/**
+ * Fold the outcome of each section into one report. A failed section is left
+ * out and named in `failedSections`, so the numbers that did load still reach
+ * the coach. The call fails only when every section does, since an empty
+ * report answers nothing.
+ */
+function collectSections(outcomes) {
+    const sections = outcomes.flatMap(({ key, result }) => Result.isSuccess(result) ? [[key, result.success]] : []);
+    const failures = outcomes.flatMap(({ key, result }) => Result.isFailure(result) ? [{ key, error: result.failure }] : []);
+    return Arr.match(failures, {
+        onEmpty: () => Effect.succeed(R.fromEntries(sections)),
+        onNonEmpty: (failed) => Arr.isReadonlyArrayEmpty(sections)
+            ? Effect.fail(Arr.headNonEmpty(failed).error)
+            : Effect.succeed({
+                ...R.fromEntries(sections),
+                failedSections: failed.map(({ key, error }) => ({
+                    section: key,
+                    error: formatError(error),
+                })),
+            }),
+    });
+}
 /**
  * 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.
+ *
+ * One failed read leaves its section out and names it in `failedSections`; see
+ * {@link collectSections}. A refused token or missing scope fails the whole
+ * report instead, see {@link sectionResult}.
  */
-function analyticsFanOut(api, operationById, input, period, reads) {
-    return Effect.all(reads.map((read) => api
-        .request(taskRequest(operationById(read.id), input, {
+function analyticsFanOut(call, period, reads) {
+    return Effect.forEach(reads, (read) => sectionResult(call(read.id, {
         ...optionalField("query", read.periodScoped ? { period } : undefined),
-    }))
-        .pipe(Effect.map((value) => [read.key, value]))), { concurrency: "unbounded" }).pipe(Effect.map((entries) => Record.fromEntries(entries)));
+    })).pipe(Effect.map((result) => ({ key: read.key, result }))), { concurrency: "unbounded" }).pipe(Effect.flatMap(collectSections));
 }
-const magicMonday = {
+/**
+ * Analytics for each campaign on a listing page, keyed by campaign id. One
+ * campaign's failure is reported in its slot rather than dropping the rollup
+ * for every other campaign, unless it is an authorization failure, see
+ * {@link failureAsField}.
+ */
+function campaignAnalytics(call, page, limit) {
+    return Effect.forEach(listingIds(page, limit), (id) => failureAsField("analyticsError", call("campaigns.analytics", { pathParams: { id } })).pipe(Effect.map((analytics) => [id, analytics])), 
+    // Effect.forEach also defaults to concurrency 1. The limit caps this at 5
+    // independent per-campaign lookups, so unbounded is fine.
+    { concurrency: "unbounded" }).pipe(Effect.map(R.fromEntries));
+}
+const getAnalytics = taskTool({
+    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. When one half fails to load, the other still comes back and failedSections names the one that is missing. Example: call with {} for the default rollup, or { campaignLimit: 3 }.",
+    inputSchema: {
+        ...WORKSPACE_INPUT_FIELDS,
+        campaignLimit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 5 })).annotate({
+            description: "How many recent campaigns to include (default 5).",
+        })),
+    },
+    outputSchema: Schema.Struct({
+        campaigns: Schema.optionalKey(Schema.Record(Schema.String, resultOrError("campaigns.analytics", "analyticsError"))),
+        broadcasts: Schema.optionalKey(operationResult("broadcasts.list")),
+        failedSections: Schema.optionalKey(Schema.Array(FailedSection).annotate({
+            description: "Sections missing from this rollup because their read failed (campaigns, broadcasts). The rollup is partial whenever this is present.",
+        })),
+    }),
+    composes: ["campaigns.list", "campaigns.analytics", "broadcasts.list"],
+    run: (call, input) => Effect.gen(function* () {
+        const campaignLimit = numberInput(input.campaignLimit, DEFAULT_CAMPAIGN_LIMIT);
+        const campaignPage = yield* sectionResult(call("campaigns.list", { 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 [campaigns, broadcasts] = yield* Effect.all([
+            Result.match(campaignPage, {
+                onFailure: (error) => Effect.succeed(Result.fail(error)),
+                onSuccess: (page) => sectionResult(campaignAnalytics(call, page, campaignLimit)),
+            }),
+            sectionResult(call("broadcasts.list", {
+                query: { limit: CAMPAIGN_BROADCAST_LIMIT },
+            })),
+        ], { concurrency: "unbounded" });
+        return yield* collectSections([
+            { key: "campaigns", result: campaigns },
+            { key: "broadcasts", result: broadcasts },
+        ]);
+    }),
+});
+const magicMonday = taskTool({
     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 = {
+    outputSchema: analyticsOutput(MAGIC_MONDAY_READS),
+    composes: [
+        "analytics.funnel",
+        "analytics.revenue",
+        "analytics.speedImpact",
+        "analytics.forecast",
+        "analytics.callIntelligence",
+    ],
+    run: (call) => analyticsFanOut(call, "this_week", MAGIC_MONDAY_READS),
+});
+const analyticsDeepDive = taskTool({
     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."),
+        question: Schema.optionalKey(NonEmptyString.check(Schema.isMaxLength(500)).annotate({
+            description: "Optional. The coach's question behind this investigation, e.g. 'why did close rate drop this month?'. Not sent to any API; it only records what the coach asked.",
+        })),
+        period: Schema.optionalKey(Schema.Literals(ANALYTICS_PERIOD_VALUES).annotate({
+            description: "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);
+    outputSchema: analyticsOutput(DEEP_DIVE_READS),
+    composes: [
+        "analytics.funnel",
+        "analytics.revenue",
+        "analytics.speedImpact",
+        "analytics.forecast",
+        "analytics.callIntelligence",
+        "analytics.ghostedLeads",
+        "analytics.trustScore",
+    ],
+    run: (call, input) => {
+        const period = Option.getOrElse(decodeAnalyticsPeriod(input.period), () => "this_month");
+        return analyticsFanOut(call, period, DEEP_DIVE_READS);
     },
-};
+});
 export const analyticsTaskTools = [
     getAnalytics,
     magicMonday,

package/dist/task-tools/bookings.js

@@ -1,44 +1,100 @@
-import { Effect, Option } from "effect";
-import * as z from "zod/v4";
-import { WORKSPACE_INPUT_FIELDS } from "../operations.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { IsoDateTime, NonEmptyString, WORKSPACE_INPUT_FIELDS, } from "../fields.js";
 import { optionalField } from "../optional-field.js";
-import { independentWrite, numberInput, stringInput, taskRequest, } from "./runtime.js";
+import { failureAsField, idempotencyKeyInput, isPartialFailure, numberInput, operationResult, resultOrError, stringInput, taskTool, } from "./runtime.js";
+/** The providers the API accepts on an availability read and on a booking. */
+const BOOKING_PROVIDERS = [
+    "manual",
+    "calendly",
+    "cal_com",
+    "google_calendar",
+    "iclosed",
+    "gohighlevel",
+];
+/**
+ * Whether the caller is retrying under a key. A retry may follow a booking that
+ * landed while its response was lost, so the slot can be taken by that very
+ * booking. Checking availability first would answer slot_not_available and
+ * never reach the API's replay of the first result.
+ */
+function isRetry(input) {
+    return input.idempotencyKey !== undefined;
+}
 /** How far past the requested slot to look when offering alternatives. */
 const AVAILABILITY_WINDOW_MS = 24 * 60 * 60 * 1000;
+const AvailabilityPage = Schema.Struct({
+    source: Schema.String,
+    slots: Schema.Array(Schema.Struct({ startsAt: Schema.String })),
+});
+const decodeAvailabilityPage = Schema.decodeUnknownOption(AvailabilityPage);
+const ManagedAvailabilityPage = Schema.Struct({
+    slots: Schema.Array(Schema.Struct({ startsAt: Schema.String })),
+});
+const decodeManagedAvailabilityPage = Schema.decodeUnknownOption(ManagedAvailabilityPage);
+const BookingBookingType = Schema.Struct({
+    booking: Schema.Struct({
+        bookingTypeId: Schema.optionalKey(Schema.NullOr(Schema.String)),
+    }),
+});
+const decodeBookingBookingType = Schema.decodeUnknownOption(BookingBookingType);
 /**
- * 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
+ * Open slots from the provider route. It 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.
+ * `live_provider` read counts.
+ */
+const providerSlots = (call, input, window) => call("bookings.availability", {
+    query: { ...window, ...optionalField("provider", input.provider) },
+}).pipe(Effect.map((page) => decodeAvailabilityPage(page).pipe(Option.filter((parsed) => parsed.source === "live_provider"), Option.map((parsed) => parsed.slots))));
+/**
+ * Open slots for one booking type, from Luca's own scheduler. The provider
+ * route knows nothing of booking types, so it would judge the slot against
+ * the wrong calendar. Times are compared as instants, so the display timezone
+ * does not matter.
+ */
+const bookingTypeSlots = (call, bookingTypeId, window) => call("bookings.managedAvailability", {
+    query: { ...window, bookingTypeId, timezone: "UTC" },
+}).pipe(Effect.map((page) => decodeManagedAvailabilityPage(page).pipe(Option.map((parsed) => parsed.slots))));
+/**
+ * The booking type a booking was made under, read from the booking itself.
+ *
+ * `Option.none()` means the read failed, and `Option.some(null)` is a booking
+ * on no booking type. Both are judged against the provider calendar, as before
+ * this read existed. A refused token still ends the call, see
+ * isPartialFailure.
+ */
+const bookingTypeOf = (call, bookingId) => call("bookings.get", { pathParams: { id: bookingId } }).pipe(Effect.map((page) => decodeBookingBookingType(page).pipe(Option.map((parsed) => parsed.booking.bookingTypeId ?? null))), Effect.catchIf(isPartialFailure, () => Effect.succeedNone));
+/**
+ * The slots `readSlots` reports open in the window starting at `slotAt`.
+ *
+ * `Option.none()` means "we could not tell", which is different from "nothing
+ * is open", and never blocks a booking. A call that carries an idempotency key
+ * skips the read, see {@link isRetry}.
  */
-const openSlotsAt = (api, operationById, input, slotAt) => Effect.gen(function* () {
+const openSlotsAt = (input, slotAt, readSlots) => Effect.gen(function* () {
+    // A keyed call is a retry, and the API replays the first answer for it.
+    if (isRetry(input)) {
+        return Option.none();
+    }
+    // oxlint-disable-next-line effect/use-clock-service -- parse date value from stored data
     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),
-        },
-    })), 
+    const window = {
+        start: start.toISOString(),
+        // oxlint-disable-next-line effect/use-clock-service -- parse date value from stored data
+        end: new Date(start.getTime() + AVAILABILITY_WINDOW_MS).toISOString(),
+    };
+    const slots = yield* readSlots(window).pipe(
     // 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() })),
+    // worse off than before this check existed. A refused token still ends
+    // the call, see isPartialFailure.
+    Effect.catchIf(isPartialFailure, () => Effect.succeedNone));
+    return Option.map(slots, (open) => open.map((slot) => slot.startsAt));
 });
 /**
  * Whether two ISO-8601 instants name the same moment, whatever their offset.
@@ -47,31 +103,52 @@ const AvailabilityPageSchema = z.object({
  * slot on either side answers false without a guard of its own.
  */
 function sameInstant(left, right) {
+    // oxlint-disable-next-line effect/use-clock-service -- parse date value from stored data
     return new Date(left).getTime() === new Date(right).getTime();
 }
-const bookCall = {
+/** What a booking tool returns instead of writing when the slot is taken. */
+function slotNotAvailable(key) {
+    return Schema.Struct({
+        [key]: Schema.Literal(false),
+        reason: Schema.Literal("slot_not_available"),
+        requestedSlotAt: Schema.String,
+        openSlots: Schema.Array(Schema.String),
+    });
+}
+const bookCall = taskTool({
     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.',
+    description: 'Book a lead into a slot the provider confirms is open. Checks availability first, against the schedule of the booking type when bookingTypeId is given, and returns the open slots instead of booking when the requested one is taken. A call with an idempotencyKey skips that check so a retry gets the original result back. Booking moves the lead to booked and notifies the coach\'s webhook subscribers, so pass confirm: true only after the coach approves this exact slot. Example: call with { leadId, slotAt: "2026-07-14T15:00:00Z", confirm: true } 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."),
+        leadId: NonEmptyString.annotate({ description: "The lead to book." }),
+        slotAt: IsoDateTime.annotate({
+            description: "ISO-8601 start time for the call, with an offset.",
+        }),
+        provider: Schema.optionalKey(Schema.Literals(BOOKING_PROVIDERS).annotate({
+            description: "The coach's booking provider. Sent with the booking and used for the availability check. Pass it when the coach is not on Calendly, or the availability check reads the wrong calendar. Left off, the check reads Calendly and the API records the booking as manual.",
+        })),
+        bookingTypeId: Schema.optionalKey(NonEmptyString.annotate({
+            description: "The booking type to book under, from luca_bookings_types_list. Required when provider is google_calendar, and it must be an active google_calendar type.",
+        })),
+        ...idempotencyKeyInput("Reuse the same key when retrying this exact booking. A keyed call skips the availability check and lets the API replay the first result."),
     },
-    readOnly: false,
-    untrustedContent: false,
-    composes: ["bookings.availability", "bookings.create"],
-    run: (api, operationById, input) => Effect.gen(function* () {
+    outputSchema: Schema.Union([
+        slotNotAvailable("booked"),
+        operationResult("bookings.create"),
+    ]),
+    composes: [
+        "bookings.availability",
+        "bookings.managedAvailability",
+        "bookings.create",
+    ],
+    run: (call, input) => Effect.gen(function* () {
         const slotAt = stringInput(input.slotAt);
-        const open = yield* openSlotsAt(api, operationById, input, slotAt);
+        // A booking type has its own schedule, which the provider route knows
+        // nothing of.
+        const open = yield* openSlotsAt(input, slotAt, (window) => input.bookingTypeId === undefined
+            ? providerSlots(call, input, window)
+            : bookingTypeSlots(call, stringInput(input.bookingTypeId), window));
         // 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.
@@ -84,48 +161,61 @@ const bookCall = {
                 openSlots: open.value,
             };
         }
-        return yield* api.request(taskRequest(operationById("bookings.create"), input, {
-            body: { leadId: input.leadId, slotAt: input.slotAt },
-        }));
+        return yield* call("bookings.create", {
+            body: {
+                leadId: input.leadId,
+                slotAt: input.slotAt,
+                ...optionalField("provider", input.provider),
+                ...optionalField("bookingTypeId", input.bookingTypeId),
+            },
+        });
     }),
-};
+});
 /** How long a reschedule link stays usable when the caller names no window. */
 const DEFAULT_GUEST_LINK_HOURS = 168;
-const rescheduleCall = {
+const rescheduleCall = taskTool({
     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.',
+    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, against the schedule of its booking type when it has one, and returns the open slots instead of moving the call when it is taken. A call with an idempotencyKey skips that check so a retry gets the original result back. Moving the call updates the connected calendar and re-arms the lead\'s reminder for the new time, so pass confirm: true only after the coach approves the move. Example: call with { bookingId, slotAt: "2026-07-16T15:00:00Z", confirm: true } after the lead asked to push the call. No message about the move is sent: send the lead 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."),
+        bookingId: NonEmptyString.annotate({ description: "The booking to move." }),
+        slotAt: IsoDateTime.annotate({
+            description: "ISO-8601 start time to move the call to, with an offset.",
+        }),
+        provider: Schema.optionalKey(Schema.Literals(BOOKING_PROVIDERS).annotate({
+            description: "The coach's booking provider. Used only for the availability check, and only when the booking has no booking type. The booking keeps the provider it already has. Pass it when the coach is not on Calendly, or the availability check reads the wrong calendar.",
+        })),
+        expiresInHours: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 720 })).annotate({
+            description: `How long the new reschedule link stays usable. Defaults to ${DEFAULT_GUEST_LINK_HOURS} hours.`,
+        })),
+        ...idempotencyKeyInput("Reuse the same key when retrying this exact reschedule. A keyed call skips the availability check and lets the API replay the first result."),
     },
-    readOnly: false,
-    untrustedContent: false,
+    outputSchema: Schema.Union([
+        slotNotAvailable("rescheduled"),
+        Schema.Struct({
+            rescheduled: Schema.Literal(true),
+            booking: operationResult("bookings.update"),
+            guestLinks: resultOrError("bookings.guestLinks.create", "guestLinksError"),
+        }),
+    ]),
     composes: [
+        "bookings.get",
         "bookings.availability",
+        "bookings.managedAvailability",
         "bookings.update",
         "bookings.guestLinks.create",
     ],
-    run: (api, operationById, input) => Effect.gen(function* () {
+    run: (call, input) => Effect.gen(function* () {
         const slotAt = stringInput(input.slotAt);
         const bookingId = stringInput(input.bookingId);
-        const open = yield* openSlotsAt(api, operationById, input, slotAt);
+        // A booking made under a booking type keeps that type's own schedule, so
+        // the provider calendar would judge the new slot against the wrong
+        // availability. The read happens only when the availability check does.
+        const open = yield* openSlotsAt(input, slotAt, (window) => Effect.flatMap(bookingTypeOf(call, bookingId), (bookingType) => Option.match(Option.flatMapNullishOr(bookingType, (id) => id), {
+            onNone: () => providerSlots(call, input, window),
+            onSome: (bookingTypeId) => bookingTypeSlots(call, bookingTypeId, window),
+        })));
         if (Option.isSome(open) &&
             !open.value.some((candidate) => sameInstant(candidate, slotAt))) {
             return {
@@ -135,23 +225,20 @@ const rescheduleCall = {
                 openSlots: open.value,
             };
         }
-        const booking = yield* api.request(taskRequest(operationById("bookings.update"), input, {
+        const booking = yield* call("bookings.update", {
             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, {
+        const guestLinks = yield* failureAsField("guestLinksError", call("bookings.guestLinks.create", {
             pathParams: { id: bookingId },
             body: {
                 expiresInHours: numberInput(input.expiresInHours, DEFAULT_GUEST_LINK_HOURS),
             },
-        })));
+        }));
         return { rescheduled: true, booking, guestLinks };
     }),
-};
-export const bookingTaskTools = [
-    bookCall,
-    rescheduleCall,
-];
+});
+export const bookingTaskTools = [bookCall, rescheduleCall];