@jsm-mit/sultana-agent-tools-package 0.2.0

package/dist/tools/schedule.js

@@ -0,0 +1,300 @@
+import { formatMinutesToTime, parseTimeRangesToSlots, parseTimeToMinutes } from "@jsm-mit/sultana-core-motoko-package";
+import { toToolError } from "../errors.js";
+import { err, needsConfirmation, ok } from "../types.js";
+import { ArgumentError, readBoolean, readOptionalString, readString } from "./args.js";
+/** 0 = Monday, matching the canister's own day index. */
+const DAY_NAMES_PL = ["poniedziałek", "wtorek", "środa", "czwartek", "piątek", "sobota", "niedziela"];
+const CONFIRMED_FIELD = {
+    type: "boolean",
+    description: "false dla podglądu: narzędzie nic nie zapisze i odda opis zmiany do zatwierdzenia przez właściciela. true dopiero po potwierdzeniu.",
+};
+const WORKER_FIELD = { type: "string", description: "Id pracownika z list_workers." };
+const DATE_FIELD = { type: "string", description: "Dzień w formacie YYYY-MM-DD." };
+const RANGES_FIELD = {
+    type: "string",
+    description: 'Zakresy godzin oddzielone przecinkiem, np. "10-18" albo "9:30-13,14-18".',
+};
+export function createScheduleTools(port) {
+    return [
+        getWeeklyHoursTool(port),
+        setWeeklyHoursTool(port),
+        getDayScheduleTool(port),
+        setDayOffTool(port),
+        setBusyHoursTool(port),
+        clearDailyOverrideTool(port),
+    ];
+}
+function getWeeklyHoursTool(port) {
+    return {
+        name: "get_weekly_hours",
+        progress: "Sprawdzam grafik tygodniowy…",
+        description: "Zwraca tygodniowy grafik pracownika — godziny pracy dla każdego dnia tygodnia.",
+        parameters: {
+            type: "object",
+            properties: { workerId: WORKER_FIELD },
+            required: ["workerId"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const worker = await resolveWorker(port, readString(args, "workerId"));
+                const week = [];
+                for (let day = 0; day < DAY_NAMES_PL.length; day += 1) {
+                    const ranges = await port.getWeeklyHours(worker.id, day);
+                    week.push({ day, dayName: DAY_NAMES_PL[day], hours: formatRanges(ranges) });
+                }
+                return ok(`Grafik tygodniowy: ${worker.name}.`, week);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się odczytać grafiku.");
+            }
+        },
+    };
+}
+function setWeeklyHoursTool(port) {
+    return {
+        name: "set_weekly_hours",
+        progress: "Ustawiam grafik…",
+        description: "Ustawia godziny PRACY pracownika w wybranych dniach tygodnia. Zastępuje dotychczasowe godziny w tych dniach. Pusty zakres oznacza dzień niepracujący.",
+        parameters: {
+            type: "object",
+            properties: {
+                workerId: WORKER_FIELD,
+                days: {
+                    type: "array",
+                    items: { type: "integer" },
+                    description: "Dni tygodnia: 0 = poniedziałek, 6 = niedziela.",
+                },
+                ranges: RANGES_FIELD,
+                confirmed: CONFIRMED_FIELD,
+            },
+            required: ["workerId", "days", "ranges", "confirmed"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const worker = await resolveWorker(port, readString(args, "workerId"));
+                const days = readDays(args);
+                const parsed = normalizeRanges(readOptionalString(args, "ranges") ?? "");
+                const dayNames = days.map((day) => DAY_NAMES_PL[day]).join(", ");
+                const hours = parsed.ranges.length === 0 ? "dzień wolny" : formatRanges(parsed.ranges).join(", ");
+                if (!readBoolean(args, "confirmed")) {
+                    return needsConfirmation(`Ustawię ${worker.name}: ${dayNames} — ${hours}.${noteSuffix(parsed.notes)}`, {
+                        ...args,
+                        confirmed: true,
+                    });
+                }
+                for (const day of days) {
+                    await port.setWeeklyHours(worker.id, day, parsed.ranges);
+                }
+                return ok(`Ustawiono grafik: ${worker.name}, ${dayNames} — ${hours}.${noteSuffix(parsed.notes)}`);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się ustawić grafiku.");
+            }
+        },
+    };
+}
+function getDayScheduleTool(port) {
+    return {
+        name: "get_day_schedule",
+        progress: "Sprawdzam grafik na ten dzień…",
+        description: "Zwraca nadpisanie dla konkretnego dnia — godziny ZAJĘTE. Pusta lista oznacza, że tego dnia obowiązuje zwykły grafik tygodniowy.",
+        parameters: {
+            type: "object",
+            properties: { workerId: WORKER_FIELD, date: DATE_FIELD },
+            required: ["workerId", "date"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const worker = await resolveWorker(port, readString(args, "workerId"));
+                const date = readDate(args);
+                const busy = await port.getDailyBusy(worker.id, date);
+                if (busy.length === 0)
+                    return ok(`${worker.name}, ${date}: brak nadpisania, obowiązuje grafik tygodniowy.`, []);
+                return ok(`${worker.name}, ${date}: godziny zajęte.`, formatRanges(busy));
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się odczytać dnia.");
+            }
+        },
+    };
+}
+function setDayOffTool(port) {
+    return {
+        name: "set_day_off",
+        progress: "Ustawiam dzień wolny…",
+        description: "Oznacza cały wskazany dzień jako wolny dla pracownika.",
+        parameters: {
+            type: "object",
+            properties: { workerId: WORKER_FIELD, date: DATE_FIELD, confirmed: CONFIRMED_FIELD },
+            required: ["workerId", "date", "confirmed"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const worker = await resolveWorker(port, readString(args, "workerId"));
+                const date = readDate(args);
+                if (!readBoolean(args, "confirmed")) {
+                    return needsConfirmation(`Ustawię ${worker.name} dzień wolny: ${date}.`, { ...args, confirmed: true });
+                }
+                await port.setDayOff(worker.id, date);
+                return ok(`${worker.name} ma wolne ${date}.`);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się ustawić dnia wolnego.");
+            }
+        },
+    };
+}
+function setBusyHoursTool(port) {
+    return {
+        name: "set_busy_hours",
+        progress: "Zapisuję godziny zajęte…",
+        description: "Ustawia godziny ZAJĘTE w konkretnym dniu — nadpisuje grafik tygodniowy tylko tego dnia. Używaj do jednorazowych nieobecności („we wtorek jestem zajęta od 12 do 15”).",
+        parameters: {
+            type: "object",
+            properties: { workerId: WORKER_FIELD, date: DATE_FIELD, ranges: RANGES_FIELD, confirmed: CONFIRMED_FIELD },
+            required: ["workerId", "date", "ranges", "confirmed"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const worker = await resolveWorker(port, readString(args, "workerId"));
+                const date = readDate(args);
+                const parsed = normalizeRanges(readString(args, "ranges"));
+                if (parsed.ranges.length === 0) {
+                    throw new ArgumentError("Podaj godziny zajęte albo użyj clear_daily_override, żeby wrócić do grafiku tygodniowego.");
+                }
+                const hours = formatRanges(parsed.ranges).join(", ");
+                if (!readBoolean(args, "confirmed")) {
+                    return needsConfirmation(`Zaznaczę ${worker.name} jako zajętą ${date}: ${hours}.${noteSuffix(parsed.notes)}`, {
+                        ...args,
+                        confirmed: true,
+                    });
+                }
+                await port.setDailyBusy(worker.id, date, parsed.ranges);
+                return ok(`${worker.name}, ${date}: zajęte ${hours}.${noteSuffix(parsed.notes)}`);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się zapisać godzin zajętych.");
+            }
+        },
+    };
+}
+function clearDailyOverrideTool(port) {
+    return {
+        name: "clear_daily_override",
+        progress: "Przywracam grafik tygodniowy…",
+        description: "Usuwa nadpisanie dla wskazanego dnia — od tej chwili obowiązuje zwykły grafik tygodniowy.",
+        parameters: {
+            type: "object",
+            properties: { workerId: WORKER_FIELD, date: DATE_FIELD, confirmed: CONFIRMED_FIELD },
+            required: ["workerId", "date", "confirmed"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const worker = await resolveWorker(port, readString(args, "workerId"));
+                const date = readDate(args);
+                if (!readBoolean(args, "confirmed")) {
+                    return needsConfirmation(`Usunę nadpisanie dnia ${date} dla ${worker.name} — wróci grafik tygodniowy.`, {
+                        ...args,
+                        confirmed: true,
+                    });
+                }
+                await port.clearDailyOverride(worker.id, date);
+                return ok(`${worker.name}, ${date}: wrócił grafik tygodniowy.`);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się usunąć nadpisania.");
+            }
+        },
+    };
+}
+async function resolveWorker(port, workerId) {
+    const workers = await port.listWorkers();
+    const worker = workers.find((candidate) => candidate.id === workerId);
+    if (!worker)
+        throw new ArgumentError(`W tym salonie nie ma pracownika o id ${workerId}. Użyj list_workers.`);
+    return worker;
+}
+function readDays(args) {
+    const value = args.days;
+    const list = Array.isArray(value) ? value : [value];
+    const days = [];
+    for (const entry of list) {
+        const day = typeof entry === "number" ? entry : Number(entry);
+        if (!Number.isInteger(day) || day < 0 || day > 6) {
+            throw new ArgumentError("Dni tygodnia to liczby 0-6, gdzie 0 to poniedziałek.");
+        }
+        if (!days.includes(day))
+            days.push(day);
+    }
+    if (days.length === 0)
+        throw new ArgumentError('Brakuje pola "days".');
+    return days;
+}
+/** The wrapper keys a day by its UTC parts, so the date travels as a plain `YYYY-MM-DD` string all
+ * the way down — never as a `Date` built from local parts, which would land on the wrong day. */
+function readDate(args) {
+    const date = readString(args, "date");
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(date))
+        throw new ArgumentError(`Data musi mieć format YYYY-MM-DD, a jest "${date}".`);
+    const parsed = new Date(`${date}T00:00:00Z`);
+    if (Number.isNaN(parsed.getTime()))
+        throw new ArgumentError(`"${date}" nie jest istniejącą datą.`);
+    return date;
+}
+/** Availability is a grid of 5-minute slots, so every edge is snapped to the grid and the change is
+ * reported rather than applied quietly. */
+function normalizeRanges(input) {
+    if (input.trim() === "")
+        return { ranges: [], notes: [] };
+    let slots;
+    try {
+        slots = parseTimeRangesToSlots(input);
+    }
+    catch (error) {
+        throw new ArgumentError(error instanceof Error ? error.message : `Nie rozumiem zakresu godzin "${input}".`);
+    }
+    const notes = [];
+    const ranges = slots.map((slot) => ({
+        startTime: snap(slot.startTime, notes),
+        endTime: snap(slot.endTime, notes),
+    }));
+    for (const range of ranges) {
+        if (parseTimeToMinutes(range.startTime) >= parseTimeToMinutes(range.endTime)) {
+            throw new ArgumentError(`Zakres ${range.startTime}-${range.endTime} nie ma sensu — początek musi być przed końcem.`);
+        }
+    }
+    return { ranges, notes };
+}
+function snap(time, notes) {
+    const minutes = parseTimeToMinutes(time);
+    const snapped = Math.round(minutes / 5) * 5;
+    if (snapped === minutes)
+        return time;
+    const formatted = formatMinutesToTime(snapped);
+    notes.push(`godzinę ${time} wyrównano do ${formatted}`);
+    return formatted;
+}
+function formatRanges(ranges) {
+    return ranges.map((range) => `${range.startTime}-${range.endTime}`);
+}
+function noteSuffix(notes) {
+    return notes.length === 0 ? "" : ` Uwaga: ${notes.join("; ")}.`;
+}

package/dist/tools/services.d.ts

@@ -0,0 +1,7 @@
+import type { SalonAccess, SalonCorePort } from "../salon-core-port.js";
+import { type AgentTool } from "../types.js";
+export declare function createServiceTools(port: SalonCorePort): AgentTool[];
+/** `access` must match the port: `"public"` only for a port that reads the visitor's view. */
+export declare function listServicesTool(port: SalonCorePort, access?: SalonAccess): AgentTool;
+export declare function findServiceTypeTool(port: SalonCorePort): AgentTool;
+//# sourceMappingURL=services.d.ts.map

package/dist/tools/services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/tools/services.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAkC,MAAM,uBAAuB,CAAC;AACxG,OAAO,EAA8B,KAAK,SAAS,EAAmB,MAAM,aAAa,CAAC;AAoB1F,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,EAAE,CASnE;AAoBD,8FAA8F;AAC9F,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,GAAE,WAAqB,GAAG,SAAS,CAmB9F;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,CAiClE"}

package/dist/tools/services.js

@@ -0,0 +1,309 @@
+import { toToolError } from "../errors.js";
+import { err, needsConfirmation, ok } from "../types.js";
+import { ArgumentError, normalizeDuration, normalizePrice, phrasesMatch, readBoolean, readNumber, readOptionalNumber, readOptionalString, readOptionalStringArray, readString, } from "./args.js";
+const CONFIRMED_FIELD = {
+    type: "boolean",
+    description: "false dla podglądu: narzędzie nic nie zapisze i odda opis zmiany do zatwierdzenia przez właściciela. true dopiero po tym, jak właściciel potwierdzi.",
+};
+export function createServiceTools(port) {
+    return [
+        listServicesTool(port),
+        findServiceTypeTool(port),
+        listWorkersTool(port),
+        addServiceTool(port),
+        updateServiceTool(port),
+        removeServiceTool(port),
+    ];
+}
+/** What the model reads about the list depends on whose view the port returns: a public read has
+ * no switched-off services in it, and a text that implied otherwise would have the model tell the
+ * owner a service is gone when it is only hidden. */
+const LIST_SERVICES_TEXT = {
+    owner: {
+        description: "Zwraca katalog usług salonu: id, nazwę, cenę, czas trwania, status i przypisanych pracowników. Wywołaj je przed każdą zmianą usługi, żeby poznać id.",
+        empty: "Salon nie ma jeszcze żadnej usługi.",
+        count: (count) => `Salon ma ${count} usług(i).`,
+    },
+    public: {
+        description: "Zwraca AKTYWNE usługi salonu — te, które widzą klientki: id, nazwę, cenę w pełnych złotych, czas trwania w minutach i id typów usług. Usług wyłączonych tu nie ma.",
+        empty: "Salon nie ma żadnej aktywnej usługi.",
+        count: (count) => `Aktywne usługi salonu: ${count}.`,
+    },
+};
+/** `access` must match the port: `"public"` only for a port that reads the visitor's view. */
+export function listServicesTool(port, access = "owner") {
+    const text = LIST_SERVICES_TEXT[access];
+    return {
+        name: "list_services",
+        progress: "Sprawdzam listę usług…",
+        description: text.description,
+        parameters: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+            try {
+                const services = await port.listServices();
+                if (services.length === 0)
+                    return ok(text.empty, []);
+                return ok(text.count(services.length), services);
+            }
+            catch (error) {
+                return toToolError(error, "Nie udało się odczytać listy usług.");
+            }
+        },
+    };
+}
+export function findServiceTypeTool(port) {
+    return {
+        name: "find_service_type",
+        progress: "Szukam typu usługi…",
+        description: "Szuka w katalogu typów usług (np. „strzyżenie”, „koloryzacja”) i zwraca ich id wraz z etykietami. Każdy serviceTypeId musi pochodzić stąd — nie wymyślaj id.",
+        parameters: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Fragment nazwy typu usługi. Puste zapytanie zwraca cały katalog." },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const query = readOptionalString(args, "query") ?? "";
+                const matches = await port.findServiceTypes(query);
+                if (matches.length === 0)
+                    return ok(`Nic nie pasuje do „${query}”.`, []);
+                // A long catalog is noise in a conversation; the model only needs enough to choose.
+                const shown = matches.slice(0, 25);
+                const summary = matches.length > shown.length
+                    ? `Znaleziono ${matches.length} typów, pokazuję pierwsze ${shown.length}.`
+                    : `Znaleziono ${matches.length} typ(ów).`;
+                return ok(summary, shown);
+            }
+            catch (error) {
+                return toToolError(error, "Nie udało się odczytać katalogu typów usług.");
+            }
+        },
+    };
+}
+function listWorkersTool(port) {
+    return {
+        name: "list_workers",
+        progress: "Sprawdzam zespół…",
+        description: "Zwraca zespół salonu: id pracownika i imię. Potrzebne, żeby przypisać usługę albo ustawić grafik.",
+        parameters: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+            try {
+                const workers = await port.listWorkers();
+                if (workers.length === 0)
+                    return ok("Salon nie ma jeszcze żadnego pracownika.", []);
+                return ok(`Zespół liczy ${workers.length} osob(y).`, workers);
+            }
+            catch (error) {
+                return toToolError(error, "Nie udało się odczytać zespołu.");
+            }
+        },
+    };
+}
+function addServiceTool(port) {
+    return {
+        name: "add_service",
+        progress: "Dodaję usługę…",
+        description: "Dodaje nową usługę do katalogu salonu. Najpierw ustal typ usługi przez find_service_type i pracowników przez list_workers.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Nazwa usługi widoczna dla klientek." },
+                pricePln: { type: "number", description: "Cena w pełnych złotych." },
+                durationMinutes: { type: "number", description: "Czas trwania w minutach, wielokrotność 5." },
+                serviceTypeIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Id typów usług z find_service_type.",
+                },
+                workerIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Id pracowników z list_workers. Pusta lista oznacza usługę bez przypisanych osób.",
+                },
+                active: { type: "boolean", description: "Czy usługa ma być od razu widoczna. Domyślnie true." },
+                confirmed: CONFIRMED_FIELD,
+            },
+            required: ["name", "pricePln", "durationMinutes", "confirmed"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const draft = await buildDraft(port, args, null);
+                if (!readBoolean(args, "confirmed")) {
+                    return needsConfirmation(`Dodam usługę: ${await describe(port, draft.input)}.${noteSuffix(draft.notes)}`, {
+                        ...args,
+                        ...draft.input,
+                        confirmed: true,
+                    });
+                }
+                const serviceId = await port.addService(draft.input);
+                return ok(`Dodano usługę „${draft.input.name}”.${noteSuffix(draft.notes)}`, { serviceId });
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się dodać usługi.");
+            }
+        },
+    };
+}
+function updateServiceTool(port) {
+    return {
+        name: "update_service",
+        progress: "Zmieniam usługę…",
+        description: "Zmienia istniejącą usługę. Podaj tylko te pola, które mają się zmienić — reszta zostanie zachowana. Id weź z list_services.",
+        parameters: {
+            type: "object",
+            properties: {
+                salonServiceId: { type: "string", description: "Id usługi z list_services." },
+                name: { type: "string", description: "Nowa nazwa." },
+                pricePln: { type: "number", description: "Nowa cena w pełnych złotych." },
+                durationMinutes: { type: "number", description: "Nowy czas trwania w minutach, wielokrotność 5." },
+                serviceTypeIds: { type: "array", items: { type: "string" }, description: "Nowa lista typów usług." },
+                workerIds: { type: "array", items: { type: "string" }, description: "Nowa lista pracowników." },
+                active: { type: "boolean", description: "Czy usługa ma być widoczna." },
+                confirmed: CONFIRMED_FIELD,
+            },
+            required: ["salonServiceId", "confirmed"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const serviceId = readString(args, "salonServiceId");
+                const current = await findService(port, serviceId);
+                if (!current)
+                    return err("not_found", `W tym salonie nie ma usługi o id ${serviceId}.`);
+                const draft = await buildDraft(port, args, current);
+                if (!readBoolean(args, "confirmed")) {
+                    return needsConfirmation(`Zmienię usługę „${current.name}” na: ${await describe(port, draft.input)}.${noteSuffix(draft.notes)}`, { ...args, ...draft.input, confirmed: true });
+                }
+                await port.updateService(serviceId, draft.input);
+                return ok(`Zmieniono usługę „${draft.input.name}”.${noteSuffix(draft.notes)}`);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się zmienić usługi.");
+            }
+        },
+    };
+}
+function removeServiceTool(port) {
+    return {
+        name: "remove_service",
+        progress: "Usuwam usługę…",
+        description: "Usuwa usługę z katalogu. Operacja jest nieodwracalna — właściciel musi przepisać dokładną nazwę usługi w polu confirmationPhrase.",
+        parameters: {
+            type: "object",
+            properties: {
+                salonServiceId: { type: "string", description: "Id usługi z list_services." },
+                confirmationPhrase: { type: "string", description: "Dokładna nazwa usuwanej usługi, przepisana przez właściciela." },
+                confirmed: CONFIRMED_FIELD,
+            },
+            required: ["salonServiceId", "confirmed"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const serviceId = readString(args, "salonServiceId");
+                const current = await findService(port, serviceId);
+                if (!current)
+                    return err("not_found", `W tym salonie nie ma usługi o id ${serviceId}.`);
+                if (!readBoolean(args, "confirmed")) {
+                    return needsConfirmation(`Usunę usługę „${current.name}” (${current.pricePln} zł, ${current.durationMinutes} min). Tego nie da się cofnąć — poproś właściciela o przepisanie nazwy usługi.`, { salonServiceId: serviceId, confirmationPhrase: current.name, confirmed: true });
+                }
+                const phrase = readOptionalString(args, "confirmationPhrase");
+                if (!phrase || !phrasesMatch(phrase, current.name)) {
+                    return err("invalid_arguments", `Aby usunąć usługę, właściciel musi przepisać jej nazwę: „${current.name}”.`);
+                }
+                await port.removeService(serviceId);
+                return ok(`Usunięto usługę „${current.name}”.`);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się usunąć usługi.");
+            }
+        },
+    };
+}
+/**
+ * Builds the full record the canister needs. `current` is null for a new service and the existing
+ * record for an edit — **this merge is the whole point**: `updateSalonService` replaces every
+ * field, so a "just the price" call that forgot `workerIds` would unassign the entire team.
+ */
+async function buildDraft(port, args, current) {
+    const notes = [];
+    const name = current ? (readOptionalString(args, "name") ?? current.name) : readString(args, "name");
+    const rawPrice = readOptionalNumber(args, "pricePln");
+    const price = rawPrice === undefined ? current?.pricePln : normalizeOrNote(normalizePrice(rawPrice), notes);
+    if (price === undefined)
+        throw new ArgumentError('Brakuje pola "pricePln".');
+    const rawDuration = readOptionalNumber(args, "durationMinutes");
+    const duration = rawDuration === undefined ? current?.durationMinutes : normalizeOrNote(normalizeDuration(rawDuration), notes);
+    if (duration === undefined)
+        throw new ArgumentError('Brakuje pola "durationMinutes".');
+    const serviceTypeIds = readOptionalStringArray(args, "serviceTypeIds") ?? current?.serviceTypeIds ?? [];
+    const workerIds = readOptionalStringArray(args, "workerIds") ?? current?.workerIds ?? [];
+    const active = args.active === undefined || args.active === null ? (current?.active ?? true) : readBoolean(args, "active");
+    await assertKnownServiceTypes(port, serviceTypeIds);
+    await assertKnownWorkers(port, workerIds);
+    return { input: { name, pricePln: price, durationMinutes: duration, active, serviceTypeIds, workerIds }, notes };
+}
+function normalizeOrNote(normalized, notes) {
+    if (normalized.note)
+        notes.push(normalized.note);
+    return normalized.value;
+}
+function noteSuffix(notes) {
+    return notes.length === 0 ? "" : ` Uwaga: ${notes.join("; ")}.`;
+}
+/** The model must never invent a service-type id — the canister would take it and the service would
+ * then be invisible in search under a key nobody uses. */
+async function assertKnownServiceTypes(port, serviceTypeIds) {
+    if (serviceTypeIds.length === 0)
+        return;
+    const catalog = await port.findServiceTypes("");
+    const known = new Set(catalog.map((entry) => entry.id));
+    const unknown = serviceTypeIds.filter((id) => !known.has(id));
+    if (unknown.length > 0) {
+        throw new ArgumentError(`Nieznane typy usług: ${unknown.join(", ")}. Użyj find_service_type i podaj id z katalogu.`);
+    }
+}
+async function assertKnownWorkers(port, workerIds) {
+    if (workerIds.length === 0)
+        return;
+    const workers = await port.listWorkers();
+    const known = new Set(workers.map((worker) => worker.id));
+    const unknown = workerIds.filter((id) => !known.has(id));
+    if (unknown.length > 0) {
+        throw new ArgumentError(`Nieznani pracownicy: ${unknown.join(", ")}. Użyj list_workers i podaj id z zespołu.`);
+    }
+}
+/** The confirmation sentence is built from RESOLVED arguments — labels and names, not ids — so the
+ * owner confirms what will really happen rather than what the model believes it is doing. */
+async function describe(port, input) {
+    const parts = [`„${input.name}”`, `${input.pricePln} zł`, `${input.durationMinutes} min`];
+    if (input.serviceTypeIds.length > 0) {
+        const catalog = await port.findServiceTypes("");
+        const labels = input.serviceTypeIds.map((id) => catalog.find((entry) => entry.id === id)?.label ?? id);
+        parts.push(`typy: ${labels.join(", ")}`);
+    }
+    if (input.workerIds.length > 0) {
+        const workers = await port.listWorkers();
+        const names = input.workerIds.map((id) => workers.find((worker) => worker.id === id)?.name ?? id);
+        parts.push(`pracownicy: ${names.join(", ")}`);
+    }
+    else {
+        parts.push("bez przypisanych pracowników");
+    }
+    parts.push(input.active ? "widoczna" : "ukryta");
+    return parts.join(", ");
+}
+async function findService(port, serviceId) {
+    const services = await port.listServices();
+    return services.find((service) => service.id === serviceId) ?? null;
+}