@jsm-mit/sultana-agent-tools-package 0.3.0 → 0.4.0

package/README.md

@@ -1,7 +1,8 @@
 # sultana-agent-tools-package
 
-`@jsm-mit/sultana-agent-tools-package` — the tool layer that lets an LLM agent edit a Sultana
-salon by conversation: services, promos and working hours.
+`@jsm-mit/sultana-agent-tools-package` — the tool layer that lets an LLM agent work in Sultana by
+conversation: a salon owner's set (services, promos and working hours) and a customer's set
+(search, free times, booking on the customer's behalf).
 
 It is **framework-agnostic**. A tool is `{ name, description, parameters, progress, execute }`, which is what
 OpenAI, Anthropic and `@jsm-mit/chat-agent-package` all want from a function tool, so wiring this
@@ -128,6 +129,45 @@ never sent to the model. A write tool previewing with `confirmed: false` shows t
 `createSalonTools` returns all 21; `createSalonReadTools` returns `list_services`, `list_promos`
 and `find_service_type`.
 
+## Customer tools
+
+The second set works for ONE customer instead of one salon: it searches across all salons and
+books, lists and cancels visits **on the customer's behalf**. The host passes the customer's lent
+identity (an Internet Identity delegation) and the position the app sent; neither is ever a tool
+argument, so a model holding these tools can act for nobody else and search around nowhere else.
+
+```ts
+import { createCustomerTools, createCustomerReadTools, CUSTOMER_AGENT_PERSONA_PL } from "@jsm-mit/sultana-agent-tools-package";
+
+const tools = session
+    ? createCustomerTools({ canisterId, identity: session.identity, location: session.location, confirmations: ledger.forTurn() })
+    : createCustomerReadTools({ canisterId, location });   // no identity: search only, nothing books
+```
+
+| tool | writes | needs identity | progress |
+|---|---|---|---|
+| `find_service_type` | | | Szukam typu usługi… |
+| `search_slots` | | | Szukam wolnych terminów w okolicy… |
+| `get_salon` | | | Sprawdzam salon… |
+| `get_free_times` | | | Sprawdzam wolne godziny… |
+| `book_appointment` | yes | yes | Rezerwuję wizytę… |
+| `list_my_appointments` | | yes | Sprawdzam Twoje wizyty… |
+| `cancel_appointment` | yes | yes | Odwołuję wizytę… |
+
+- `search_slots` without `date`/`time` is the package's "as soon as possible" search (the next
+  hour, else up to 24 h ahead); with them it probes from 30 min before to 60 min after the moment.
+  Results: at most 6 salons, soonest first, each with its services and up to 6 free moments.
+- A model reads and sends local time: `date` `"YYYY-MM-DD"`, `time` `"HH:mm"`.
+  `get_free_times` folds the 5-minute start grid into ranges.
+- `book_appointment` picks the first free worker, like the app, and checks the slot on the preview
+  AND on the confirmed call — a booking the canister refuses still spends the customer's daily quota.
+- The public reads go out anonymously even with an identity; only booking, the visits and
+  cancelling are signed.
+- **The host process must run in the salons' time zone** (`TZ=Europe/Warsaw`): the canister wrapper
+  takes every offset from the process clock. While it does not, every time-dependent tool answers
+  `unavailable` instead of booking hours off (`timeZone: null` skips the guard; `hostTimeZoneProblem`
+  lets a host check at start-up).
+
 ## What the tools guarantee
 
 - **`execute` never throws.** Every call returns `{status: "ok" | "confirmation_required" | "error"}`
@@ -160,6 +200,7 @@ and `find_service_type`.
 | `npm run sandbox -- --fake` | talk to the tools against an in-memory salon |
 | `npm run sandbox` | the same conversation against a real canister |
 | `npm run test-tools` | the round trip against a live canister (creates its own salon) |
+| `npm run test-customer-tools` | the customer's round trip against a live, seeded canister: search, book, list, cancel (a fresh identity per run) |
 | `npm run publish-public` | publishes to npm from master — see below |
 
 ## Testing by talking

package/dist/customer/create-customer-tools.d.ts

@@ -0,0 +1,38 @@
+import type { TurnConfirmations } from "../confirmations.js";
+import type { AgentTool } from "../types.js";
+import type { CustomerCorePort } from "./customer-core-port.js";
+import { type IcCustomerCorePortOptions } from "./ic-customer-core-port.js";
+/** The zone Sultana's salons live in. The canister keeps no zone per salon. */
+export declare const DEFAULT_SALON_TIME_ZONE = "Europe/Warsaw";
+export interface CreateCustomerToolsFromPortOptions {
+    /** This turn's confirmations — `ledger.forTurn()`, as for the salon tools. */
+    confirmations?: TurnConfirmations;
+    /** The clock; defaults to the system's. */
+    now?: () => Date;
+    /**
+     * The salons' time zone. The host process MUST run in it (`TZ=Europe/Warsaw`): the canister
+     * wrapper takes every offset from the process clock. While it does not, every tool that
+     * touches a time answers with an error instead of booking hours off. `null` skips the guard.
+     */
+    timeZone?: string | null;
+}
+export interface CreateCustomerToolsOptions extends Omit<IcCustomerCorePortOptions, "language">, CreateCustomerToolsFromPortOptions {
+    /** Language of service-type labels. Defaults to Polish. */
+    language?: string;
+}
+/**
+ * The tool set of ONE customer: search, free times, booking, the customer's visits, cancelling.
+ * The customer's identity and position are captured here and never appear as tool arguments, so a
+ * model holding these tools can act for nobody else and search around nowhere else.
+ */
+export declare function createCustomerTools(options: CreateCustomerToolsOptions): AgentTool[];
+/** The same set over any port — the seam tests use. */
+export declare function createCustomerToolsFromPort(port: CustomerCorePort, options?: CreateCustomerToolsFromPortOptions): AgentTool[];
+export type CreateCustomerReadToolsOptions = Omit<CreateCustomerToolsOptions, "identity" | "confirmations">;
+/**
+ * The set for a customer whose delegation is missing or expired: everything that needs no
+ * identity — finding a service type, searching slots, a salon, its free times. Nothing books.
+ */
+export declare function createCustomerReadTools(options: CreateCustomerReadToolsOptions): AgentTool[];
+export declare function createCustomerReadToolsFromPort(port: CustomerCorePort, options?: Omit<CreateCustomerToolsFromPortOptions, "confirmations">): AgentTool[];
+//# sourceMappingURL=create-customer-tools.d.ts.map

package/dist/customer/create-customer-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-customer-tools.d.ts","sourceRoot":"","sources":["../../src/customer/create-customer-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAsB,KAAK,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAWhG,+EAA+E;AAC/E,eAAO,MAAM,uBAAuB,kBAAkB,CAAC;AAEvD,MAAM,WAAW,kCAAkC;IAC/C,8EAA8E;IAC9E,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,2CAA2C;IAC3C,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IACjB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,0BAA2B,SAAQ,IAAI,CAAC,yBAAyB,EAAE,UAAU,CAAC,EAAE,kCAAkC;IAC/H,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,SAAS,EAAE,CAKpF;AAED,uDAAuD;AACvD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,gBAAgB,EAAE,OAAO,GAAE,kCAAuC,GAAG,SAAS,EAAE,CASjI;AAED,MAAM,MAAM,8BAA8B,GAAG,IAAI,CAAC,0BAA0B,EAAE,UAAU,GAAG,eAAe,CAAC,CAAC;AAE5G;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,8BAA8B,GAAG,SAAS,EAAE,CAK5F;AAED,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,gBAAgB,EAAE,OAAO,GAAE,IAAI,CAAC,kCAAkC,EAAE,eAAe,CAAM,GAAG,SAAS,EAAE,CAE5J"}

package/dist/customer/create-customer-tools.js

@@ -0,0 +1,47 @@
+import { findServiceTypeTool } from "../tools/services.js";
+import { IcCustomerCorePort } from "./ic-customer-core-port.js";
+import { bookAppointmentTool, cancelAppointmentTool, getFreeTimesTool, getSalonTool, listMyAppointmentsTool, searchSlotsTool, } from "./tools.js";
+/** The zone Sultana's salons live in. The canister keeps no zone per salon. */
+export const DEFAULT_SALON_TIME_ZONE = "Europe/Warsaw";
+/**
+ * The tool set of ONE customer: search, free times, booking, the customer's visits, cancelling.
+ * The customer's identity and position are captured here and never appear as tool arguments, so a
+ * model holding these tools can act for nobody else and search around nowhere else.
+ */
+export function createCustomerTools(options) {
+    const { confirmations, now, timeZone, language, ...portOptions } = options;
+    const port = new IcCustomerCorePort({ ...portOptions, language: language ?? "pl" });
+    return createCustomerToolsFromPort(port, { confirmations, now, timeZone });
+}
+/** The same set over any port — the seam tests use. */
+export function createCustomerToolsFromPort(port, options = {}) {
+    const context = contextOf(port, options);
+    return [
+        ...readTools(context),
+        bookAppointmentTool(context, options.confirmations),
+        listMyAppointmentsTool(context),
+        cancelAppointmentTool(context, options.confirmations),
+    ];
+}
+/**
+ * The set for a customer whose delegation is missing or expired: everything that needs no
+ * identity — finding a service type, searching slots, a salon, its free times. Nothing books.
+ */
+export function createCustomerReadTools(options) {
+    const { now, timeZone, language, ...portOptions } = options;
+    const port = new IcCustomerCorePort({ ...portOptions, language: language ?? "pl" });
+    return createCustomerReadToolsFromPort(port, { now, timeZone });
+}
+export function createCustomerReadToolsFromPort(port, options = {}) {
+    return readTools(contextOf(port, options));
+}
+function contextOf(port, options) {
+    return {
+        port,
+        now: options.now ?? (() => new Date()),
+        timeZone: options.timeZone === null ? undefined : options.timeZone ?? DEFAULT_SALON_TIME_ZONE,
+    };
+}
+function readTools(context) {
+    return [findServiceTypeTool(context.port), searchSlotsTool(context), getSalonTool(context), getFreeTimesTool(context)];
+}

package/dist/customer/customer-core-port.d.ts

@@ -0,0 +1,94 @@
+import type { ServiceTypeView, TimeRange } from "../salon-core-port.js";
+/**
+ * Everything the customer tools may do on the core canister, in plain JSON. Unlike
+ * `SalonCorePort` it is bound to no salon — a customer looks across all of them — but to ONE
+ * customer: the identity behind the port (the customer's lent delegation) and the place the
+ * customer searches around. Neither ever appears as a tool argument.
+ *
+ * Moments are Unix milliseconds; a day is the LOCAL date `"YYYY-MM-DD"`.
+ */
+export interface Coordinates {
+    lat: number;
+    lng: number;
+}
+/** A salon's service as a visitor sees it (active services only). */
+export interface CustomerServiceView {
+    id: string;
+    salonId: string;
+    name: string;
+    pricePln: number;
+    durationMinutes: number;
+    serviceTypeIds: string[];
+    /** Workers who can perform it; the tools pick the first free one, like the app does. */
+    workerIds: string[];
+}
+export interface SalonView {
+    id: string;
+    name: string;
+    address: string;
+}
+export interface CustomerPromoView {
+    name: string;
+    textLines: string[];
+    discountCode?: string;
+    /** The service the promo leads to; absent = the salon itself. */
+    targetServiceId?: string;
+}
+/** One salon's answer to a slot search. */
+export interface SalonSlotsView {
+    salonId: string;
+    distanceKm: number;
+    /** The salon's services of the searched type. */
+    services: CustomerServiceView[];
+    /** Free start moments, ascending. */
+    availableAt: number[];
+    /** Asap only: the soonest moment the customer can still reach from the search location. */
+    soonestAt: number | null;
+}
+export interface SlotSearchView {
+    /** Asap only. "extended": nothing reachable within the hour, so the scan went on up to 24 h. */
+    phase?: "soon" | "extended";
+    salons: SalonSlotsView[];
+    /** Probes whose canister call failed — an empty list with failures means "could not check". */
+    failedProbes: number;
+}
+export type AppointmentStatusView = "Pending" | "Confirmed" | "Cancelled" | "Completed" | "NoShow";
+export interface AppointmentView {
+    id: string;
+    salonId: string;
+    serviceId: string;
+    startAt: number;
+    durationMinutes: number;
+    pricePln: number;
+    status: AppointmentStatusView;
+    discountCode?: string;
+}
+export interface BookingInput {
+    salonId: string;
+    serviceId: string;
+    workerId: string;
+    startAt: number;
+    notes: string;
+    discountCode?: string;
+}
+export interface CustomerCorePort {
+    /** Where the customer searches around; `null` when the app sent no position. */
+    readonly location: Coordinates | null;
+    findServiceTypes(query: string): Promise<ServiceTypeView[]>;
+    /** "As soon as possible" around `location`. */
+    searchAsap(serviceTypeId: string, radiusKm: number, now: Date): Promise<SlotSearchView>;
+    /** The given start moments around `location`. */
+    searchAtMoments(serviceTypeId: string, radiusKm: number, moments: number[]): Promise<SlotSearchView>;
+    getSalons(salonIds: string[]): Promise<SalonView[]>;
+    listSalonServices(salonId: string): Promise<CustomerServiceView[]>;
+    listSalonPromos(salonId: string): Promise<CustomerPromoView[]>;
+    /** One worker's free windows on a local day. A worker with no hours that day gives `[]`. */
+    freeWindows(salonId: string, workerId: string, day: string): Promise<TimeRange[]>;
+    /** Needs the customer's identity. Returns the appointment id. */
+    book(input: BookingInput): Promise<string>;
+    /** Needs the customer's identity. Every appointment of the customer, past and cancelled too. */
+    listMyAppointments(): Promise<AppointmentView[]>;
+    /** Needs the customer's identity. */
+    cancel(appointmentId: string): Promise<void>;
+}
+//# sourceMappingURL=customer-core-port.d.ts.map

package/dist/customer/customer-core-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customer-core-port.d.ts","sourceRoot":"","sources":["../../src/customer/customer-core-port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAExE;;;;;;;GAOG;AAEH,MAAM,WAAW,WAAW;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACf;AAED,qEAAqE;AACrE,MAAM,WAAW,mBAAmB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,wFAAwF;IACxF,SAAS,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,SAAS;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iEAAiE;IACjE,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,2CAA2C;AAC3C,MAAM,WAAW,cAAc;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,qCAAqC;IACrC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,2FAA2F;IAC3F,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc;IAC3B,gGAAgG;IAChG,KAAK,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAC5B,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,+FAA+F;IAC/F,YAAY,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,MAAM,qBAAqB,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,GAAG,QAAQ,CAAC;AAEnG,MAAM,WAAW,eAAe;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,qBAAqB,CAAC;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC7B,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAC;IAEtC,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IAE5D,+CAA+C;IAC/C,UAAU,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IACxF,iDAAiD;IACjD,eAAe,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAErG,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IACpD,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAC;IACnE,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAAC;IAE/D,4FAA4F;IAC5F,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAElF,iEAAiE;IACjE,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3C,gGAAgG;IAChG,kBAAkB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IACjD,qCAAqC;IACrC,MAAM,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD"}

package/dist/customer/customer-core-port.js

@@ -0,0 +1 @@
+export {};

package/dist/customer/ic-customer-core-port.d.ts

@@ -0,0 +1,45 @@
+import type { Identity } from "@icp-sdk/core/agent";
+import type { ServiceTypeView, TimeRange } from "../salon-core-port.js";
+import type { AppointmentView, BookingInput, Coordinates, CustomerCorePort, CustomerPromoView, CustomerServiceView, SalonView, SlotSearchView } from "./customer-core-port.js";
+export interface IcCustomerCorePortOptions {
+    canisterId: string;
+    /** The customer's lent delegation. Omit it and every read still works (they are public
+     * queries), while booking, the customer's appointments and cancelling are refused. */
+    identity?: Identity;
+    /** Where the customer searches around — the position the app sent with the session. */
+    location?: Coordinates;
+    /** Language of service-type labels. */
+    language: string;
+}
+/**
+ * The customer port over the published canister wrapper. Conversions live here and nowhere
+ * else: the canister speaks `bigint`, `Principal` and nanoseconds, the tools speak numbers,
+ * strings and milliseconds.
+ *
+ * The public reads go out ANONYMOUSLY even when an identity is present: they answer the same
+ * either way, and a signed query would only spend the customer's delegation on nothing.
+ */
+export declare class IcCustomerCorePort implements CustomerCorePort {
+    readonly location: Coordinates | null;
+    private readonly language;
+    private readonly search;
+    private readonly salons;
+    private readonly services;
+    private readonly serviceTypes;
+    private readonly promo;
+    private readonly availability;
+    private readonly appointments;
+    constructor(options: IcCustomerCorePortOptions);
+    findServiceTypes(query: string): Promise<ServiceTypeView[]>;
+    searchAsap(serviceTypeId: string, radiusKm: number, now: Date): Promise<SlotSearchView>;
+    searchAtMoments(serviceTypeId: string, radiusKm: number, moments: number[]): Promise<SlotSearchView>;
+    getSalons(salonIds: string[]): Promise<SalonView[]>;
+    listSalonServices(salonId: string): Promise<CustomerServiceView[]>;
+    listSalonPromos(salonId: string): Promise<CustomerPromoView[]>;
+    freeWindows(salonId: string, workerId: string, day: string): Promise<TimeRange[]>;
+    book(input: BookingInput): Promise<string>;
+    listMyAppointments(): Promise<AppointmentView[]>;
+    cancel(appointmentId: string): Promise<void>;
+    private requireLocation;
+}
+//# sourceMappingURL=ic-customer-core-port.d.ts.map

package/dist/customer/ic-customer-core-port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ic-customer-core-port.d.ts","sourceRoot":"","sources":["../../src/customer/ic-customer-core-port.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAepD,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACxE,OAAO,KAAK,EAER,eAAe,EACf,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EAEnB,SAAS,EACT,cAAc,EACjB,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,yBAAyB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB;0FACsF;IACtF,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,uFAAuF;IACvF,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;CACpB;AAaD;;;;;;;GAOG;AACH,qBAAa,kBAAmB,YAAW,gBAAgB;IACvD,SAAgB,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAC;IAE7C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;IACjD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;IACjD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;gBAErC,OAAO,EAAE,yBAAyB;IAajC,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAU3D,UAAU,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,GAAG,OAAO,CAAC,cAAc,CAAC;IAWvF,eAAe,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,cAAc,CAAC;IAWpG,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAQnD,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAKlE,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;IAa9D,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAUjF,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC;IAW1C,kBAAkB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAehD,MAAM,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIzD,OAAO,CAAC,eAAe;CAI1B"}

package/dist/customer/ic-customer-core-port.js

@@ -0,0 +1,132 @@
+import { Principal } from "@icp-sdk/core/principal";
+import { AppointmentsActor, AvailabilityActor, filterServiceTypes, PromoActor, SalonServicesActor, SalonsActor, searchAsapAsyncUnsafe, searchAtMomentsAsyncUnsafe, SearchActor, ServiceTypesActor, } from "@jsm-mit/sultana-core-motoko-package";
+/**
+ * The customer port over the published canister wrapper. Conversions live here and nowhere
+ * else: the canister speaks `bigint`, `Principal` and nanoseconds, the tools speak numbers,
+ * strings and milliseconds.
+ *
+ * The public reads go out ANONYMOUSLY even when an identity is present: they answer the same
+ * either way, and a signed query would only spend the customer's delegation on nothing.
+ */
+export class IcCustomerCorePort {
+    location;
+    language;
+    search;
+    salons;
+    services;
+    serviceTypes;
+    promo;
+    availability;
+    appointments;
+    constructor(options) {
+        this.location = options.location ?? null;
+        this.language = options.language;
+        this.search = new SearchActor(options.canisterId);
+        this.salons = new SalonsActor(options.canisterId);
+        this.services = new SalonServicesActor(options.canisterId);
+        this.serviceTypes = new ServiceTypesActor(options.canisterId);
+        this.promo = new PromoActor(options.canisterId);
+        this.availability = new AvailabilityActor(options.canisterId);
+        this.appointments = new AppointmentsActor(options.canisterId, options.identity);
+    }
+    async findServiceTypes(query) {
+        const catalog = await this.serviceTypes.getServiceTypesCatalogAsyncUnsafe(this.language);
+        return filterServiceTypes(catalog, query).map((entry) => ({
+            id: entry.id,
+            label: entry.text,
+            category: entry.category,
+        }));
+    }
+    async searchAsap(serviceTypeId, radiusKm, now) {
+        const state = await searchAsapAsyncUnsafe(this.search, {
+            location: this.requireLocation(),
+            serviceTypeId,
+            radiusKm,
+            now,
+        });
+        return { phase: state.phase, salons: state.results.map(toSalonSlots), failedProbes: state.failedProbes };
+    }
+    async searchAtMoments(serviceTypeId, radiusKm, moments) {
+        const state = await searchAtMomentsAsyncUnsafe(this.search, {
+            location: this.requireLocation(),
+            serviceTypeId,
+            radiusKm,
+            moments,
+        });
+        return { salons: state.results.map(toSalonSlots), failedProbes: state.failedProbes };
+    }
+    async getSalons(salonIds) {
+        if (salonIds.length === 0)
+            return [];
+        // The canister answers for at most 100 ids per call.
+        const salons = await this.salons.getSalonsPublicInfoAsyncUnsafe(salonIds.slice(0, 100));
+        return salons.map((salon) => ({ id: salon.id, name: salon.name, address: salon.address }));
+    }
+    async listSalonServices(salonId) {
+        const services = await this.services.getSalonServicesPublicAsyncUnsafe(salonId);
+        return services.map(toService);
+    }
+    async listSalonPromos(salonId) {
+        const promos = await this.promo.getSalonPromosAsyncUnsafe(salonId);
+        return promos
+            .filter((promo) => promo.active)
+            .map((promo) => ({
+            name: promo.name,
+            textLines: [...promo.textLines],
+            discountCode: promo.cta.discountCode[0],
+            targetServiceId: "SalonService" in promo.target ? promo.target.SalonService : undefined,
+        }));
+    }
+    async freeWindows(salonId, workerId, day) {
+        // `day` stays a "YYYY-MM-DD" string: the wrapper reads a date's UTC parts, so a Date of
+        // local midnight would land a day early. The offset is the one of that day's noon, so a
+        // day on the far side of a clock change is read with its own offset.
+        const [year, month, date] = day.split("-").map(Number);
+        const offsetSlots = BigInt(-new Date(year, month - 1, date, 12).getTimezoneOffset() / 5);
+        return this.availability.getEffectiveMaskForSalonAsyncUnsafe(day, salonId, Principal.fromText(workerId), offsetSlots);
+    }
+    async book(input) {
+        return this.appointments.bookAppointmentAsyncUnsafe(input.notes, input.salonId, input.serviceId, input.startAt, input.workerId, input.discountCode);
+    }
+    async listMyAppointments() {
+        const appointments = await this.appointments.getMyAppointmentsAsyncUnsafe();
+        return appointments.map((appointment) => ({
+            id: appointment.id,
+            salonId: appointment.salonId,
+            serviceId: appointment.salonServiceId,
+            startAt: Number(appointment.startTimeUTC / 1000000n),
+            durationMinutes: Number(appointment.durationMinutes),
+            pricePln: Number(appointment.priceSnapshot),
+            status: Object.keys(appointment.status)[0],
+            discountCode: appointment.discountCode[0],
+        }));
+    }
+    async cancel(appointmentId) {
+        await this.appointments.cancelAppointmentAsyncUnsafe(appointmentId);
+    }
+    requireLocation() {
+        if (!this.location)
+            throw new Error("IcCustomerCorePort: no location — the tools check it before they search");
+        return this.location;
+    }
+}
+function toService(service) {
+    return {
+        id: service.id,
+        salonId: service.salonId,
+        name: service.name,
+        pricePln: Number(service.price),
+        durationMinutes: Number(service.duration),
+        serviceTypeIds: [...service.serviceTypeIds],
+        workerIds: service.workerIds.map((worker) => worker.toText()),
+    };
+}
+function toSalonSlots(found) {
+    return {
+        salonId: found.salonId,
+        distanceKm: found.distanceKm,
+        services: found.services.map(toService),
+        availableAt: [...found.availableAt],
+        soonestAt: found.soonest ? found.soonest.at : null,
+    };
+}

package/dist/customer/persona.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The operating rules of the customer tools, as a system prompt — next to the tools for the same
+ * reason as the salon persona: they describe the tool contract. A host appends who the agent is.
+ */
+export declare const CUSTOMER_AGENT_PERSONA_PL = "Jeste\u015B asystentem klienta w aplikacji Sultana: pomagasz znale\u017A\u0107 salon i wolny termin,\nrezerwujesz i odwo\u0142ujesz wizyty w imieniu klienta. Rozmawiasz po polsku, kr\u00F3tko i konkretnie.\n\nZasady pracy:\n- Szukasz zawsze wok\u00F3\u0142 pozycji klienta, kt\u00F3r\u0105 poda\u0142a aplikacja. Nie pytaj o adres.\n- Typ us\u0142ugi ustal przez find_service_type (np. \u201Estrzy\u017Cenie m\u0119skie\u201D). Nigdy nie wymy\u015Blaj id.\n  Gdy pasuje kilka typ\u00F3w, dopytaj klienta, o kt\u00F3ry chodzi.\n- Terminy znajd\u017A przez search_slots: bez daty = jak najszybciej, z date i time = okolice tej godziny.\n  Dzisiejsz\u0105 dat\u0119 we\u017A z get_current_date \u2014 \u201Ejutro o 10\u201D przelicz na RRRR-MM-DD i GG:MM.\n- Poka\u017C klientowi najwy\u017Cej kilka propozycji: salon, us\u0142uga, cena, odleg\u0142o\u015B\u0107, godzina. Nie pokazuj id.\n- Inne godziny w wybranym salonie sprawd\u017A przez get_free_times.\n- Rezerwacja i odwo\u0142anie to dwa kroki w dw\u00F3ch r\u00F3\u017Cnych wiadomo\u015Bciach klienta:\n  1. Wywo\u0142aj book_appointment albo cancel_appointment z confirmed=false. Poka\u017C klientowi zdanie\n     z pola summary, zapytaj o zgod\u0119 i na tym zako\u0144cz odpowied\u017A.\n  2. Dopiero gdy w swojej NAST\u0118PNEJ wiadomo\u015Bci wyra\u017Anie si\u0119 zgodzi, wywo\u0142aj to samo narz\u0119dzie\n     z confirmed=true, z confirmationId z tego podgl\u0105du i z tymi samymi argumentami (pole echo).\n  Nigdy nie potwierdzaj w tej samej odpowiedzi, w kt\u00F3rej pokaza\u0142e\u015B podgl\u0105d.\n- Kod rabatowy podawaj tylko wtedy, gdy klient go wpisa\u0142 albo wybra\u0142 promocj\u0119 z get_salon.\n- Je\u015Bli masz tylko narz\u0119dzia do szukania (bez book_appointment), nie mo\u017Cesz rezerwowa\u0107 \u2014\n  powiedz, \u017Ce klient musi si\u0119 zalogowa\u0107 ponownie w aplikacji i otworzy\u0107 czat jeszcze raz.\n- Je\u015Bli narz\u0119dzie zwr\u00F3ci status \"error\", przeczytaj summary i powiedz klientowi, co posz\u0142o nie tak.\n  Nie powtarzaj tego samego wywo\u0142ania w k\u00F3\u0142ko: nieudana pr\u00F3ba rezerwacji zu\u017Cywa dzienny limit klienta.\n- Nie obiecuj rezerwacji, kt\u00F3rej nie wykona\u0142e\u015B narz\u0119dziem.";
+//# sourceMappingURL=persona.d.ts.map

package/dist/customer/persona.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persona.d.ts","sourceRoot":"","sources":["../../src/customer/persona.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,eAAO,MAAM,yBAAyB,isEAsBqB,CAAC"}

package/dist/customer/persona.js

@@ -0,0 +1,27 @@
+/**
+ * The operating rules of the customer tools, as a system prompt — next to the tools for the same
+ * reason as the salon persona: they describe the tool contract. A host appends who the agent is.
+ */
+export const CUSTOMER_AGENT_PERSONA_PL = `Jesteś asystentem klienta w aplikacji Sultana: pomagasz znaleźć salon i wolny termin,
+rezerwujesz i odwołujesz wizyty w imieniu klienta. Rozmawiasz po polsku, krótko i konkretnie.
+
+Zasady pracy:
+- Szukasz zawsze wokół pozycji klienta, którą podała aplikacja. Nie pytaj o adres.
+- Typ usługi ustal przez find_service_type (np. „strzyżenie męskie”). Nigdy nie wymyślaj id.
+  Gdy pasuje kilka typów, dopytaj klienta, o który chodzi.
+- Terminy znajdź przez search_slots: bez daty = jak najszybciej, z date i time = okolice tej godziny.
+  Dzisiejszą datę weź z get_current_date — „jutro o 10” przelicz na RRRR-MM-DD i GG:MM.
+- Pokaż klientowi najwyżej kilka propozycji: salon, usługa, cena, odległość, godzina. Nie pokazuj id.
+- Inne godziny w wybranym salonie sprawdź przez get_free_times.
+- Rezerwacja i odwołanie to dwa kroki w dwóch różnych wiadomościach klienta:
+  1. Wywołaj book_appointment albo cancel_appointment z confirmed=false. Pokaż klientowi zdanie
+     z pola summary, zapytaj o zgodę i na tym zakończ odpowiedź.
+  2. Dopiero gdy w swojej NASTĘPNEJ wiadomości wyraźnie się zgodzi, wywołaj to samo narzędzie
+     z confirmed=true, z confirmationId z tego podglądu i z tymi samymi argumentami (pole echo).
+  Nigdy nie potwierdzaj w tej samej odpowiedzi, w której pokazałeś podgląd.
+- Kod rabatowy podawaj tylko wtedy, gdy klient go wpisał albo wybrał promocję z get_salon.
+- Jeśli masz tylko narzędzia do szukania (bez book_appointment), nie możesz rezerwować —
+  powiedz, że klient musi się zalogować ponownie w aplikacji i otworzyć czat jeszcze raz.
+- Jeśli narzędzie zwróci status "error", przeczytaj summary i powiedz klientowi, co poszło nie tak.
+  Nie powtarzaj tego samego wywołania w kółko: nieudana próba rezerwacji zużywa dzienny limit klienta.
+- Nie obiecuj rezerwacji, której nie wykonałeś narzędziem.`;

package/dist/customer/time.d.ts

@@ -0,0 +1,27 @@
+import type { TimeRange } from "../salon-core-port.js";
+/** The local day of a moment, `"YYYY-MM-DD"`. */
+export declare function localDayOf(at: number | Date): string;
+/** The local time of a moment, `"HH:mm"`. */
+export declare function localTimeOf(at: number | Date): string;
+/** `"YYYY-MM-DD HH:mm"` — what a model reads and sends back as `date` + `time`. */
+export declare function localStampOf(at: number | Date): string;
+export declare function isDay(text: string): boolean;
+/** Minutes from midnight of `"HH:mm"` (`"9:30"` too), or `null` when it is no time of day. */
+export declare function minutesOf(time: string): number | null;
+export declare function timeOfMinutes(minutes: number): string;
+/** The moment of a local day at minutes from its midnight. `day` must pass `isDay`. */
+export declare function momentOf(day: string, minutes: number): number;
+export declare function onSlotGrid(minutes: number): boolean;
+/** Start minutes, on the 5-minute grid, where a service of this duration fits in one window. */
+export declare function freeStartMinutes(windows: TimeRange[], durationMinutes: number): number[];
+/** Consecutive grid minutes folded into ranges — dozens of start times are noise to a model. */
+export declare function foldStartRanges(starts: number[]): {
+    from: string;
+    to: string;
+}[];
+/**
+ * Why this process must not book for salons in `expectedTimeZone`, or `null` when it may: the
+ * process clock has to run in that zone, because the canister wrapper takes every offset from it.
+ */
+export declare function hostTimeZoneProblem(expectedTimeZone: string, at?: Date): string | null;
+//# sourceMappingURL=time.d.ts.map

package/dist/customer/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../src/customer/time.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAevD,iDAAiD;AACjD,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAGpD;AAED,6CAA6C;AAC7C,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAGrD;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAEtD;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAO3C;AAED,8FAA8F;AAC9F,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQrD;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAErD;AAED,uFAAuF;AACvF,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAG7D;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,gGAAgG;AAChG,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,EAAE,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,EAAE,CAcxF;AAED,gGAAgG;AAChG,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAAE,CAUhF;AAqBD;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,gBAAgB,EAAE,MAAM,EAAE,EAAE,GAAE,IAAiB,GAAG,MAAM,GAAG,IAAI,CAalG"}

package/dist/customer/time.js

@@ -0,0 +1,113 @@
+/**
+ * Local-time arithmetic of the customer tools. "Local" is the zone of the HOST PROCESS: the
+ * canister wrapper derives every `timeOffset` from the process zone too, so the two cannot
+ * disagree — but the process zone must then be the salons' zone. `hostTimeZoneProblem` is the
+ * guard: a host in UTC would book every visit two hours off, and refusing is better than that.
+ */
+const SLOT_MINUTES = 5;
+const DAY_PATTERN = /^(\d{4})-(\d{2})-(\d{2})$/;
+const TIME_PATTERN = /^(\d{1,2}):(\d{2})$/;
+const pad = (value) => String(value).padStart(2, "0");
+/** The local day of a moment, `"YYYY-MM-DD"`. */
+export function localDayOf(at) {
+    const date = new Date(at);
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+/** The local time of a moment, `"HH:mm"`. */
+export function localTimeOf(at) {
+    const date = new Date(at);
+    return `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+}
+/** `"YYYY-MM-DD HH:mm"` — what a model reads and sends back as `date` + `time`. */
+export function localStampOf(at) {
+    return `${localDayOf(at)} ${localTimeOf(at)}`;
+}
+export function isDay(text) {
+    const match = DAY_PATTERN.exec(text);
+    if (!match)
+        return false;
+    const [year, month, day] = [Number(match[1]), Number(match[2]), Number(match[3])];
+    const date = new Date(year, month - 1, day);
+    return date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day;
+}
+/** Minutes from midnight of `"HH:mm"` (`"9:30"` too), or `null` when it is no time of day. */
+export function minutesOf(time) {
+    const match = TIME_PATTERN.exec(time.trim());
+    if (!match)
+        return null;
+    const [hours, minutes] = [Number(match[1]), Number(match[2])];
+    if (hours > 23 || minutes > 59)
+        return null;
+    return hours * 60 + minutes;
+}
+export function timeOfMinutes(minutes) {
+    return `${pad(Math.floor(minutes / 60))}:${pad(minutes % 60)}`;
+}
+/** The moment of a local day at minutes from its midnight. `day` must pass `isDay`. */
+export function momentOf(day, minutes) {
+    const [year, month, date] = day.split("-").map(Number);
+    return new Date(year, month - 1, date, Math.floor(minutes / 60), minutes % 60, 0, 0).getTime();
+}
+export function onSlotGrid(minutes) {
+    return minutes % SLOT_MINUTES === 0;
+}
+/** Start minutes, on the 5-minute grid, where a service of this duration fits in one window. */
+export function freeStartMinutes(windows, durationMinutes) {
+    const starts = new Set();
+    for (const window of windows) {
+        const from = minutesOf(window.startTime);
+        // The wrapper writes the end of the day as "24:00" or "00:00".
+        const to = window.endTime === "24:00" || window.endTime === "00:00" ? 24 * 60 : minutesOf(window.endTime);
+        if (from === null || to === null)
+            continue;
+        const first = Math.ceil(from / SLOT_MINUTES) * SLOT_MINUTES;
+        for (let start = first; start + durationMinutes <= to; start += SLOT_MINUTES)
+            starts.add(start);
+    }
+    return [...starts].sort((a, b) => a - b);
+}
+/** Consecutive grid minutes folded into ranges — dozens of start times are noise to a model. */
+export function foldStartRanges(starts) {
+    const ranges = [];
+    for (const start of starts) {
+        const last = ranges[ranges.length - 1];
+        if (last && start === last.to + SLOT_MINUTES)
+            last.to = start;
+        else
+            ranges.push({ from: start, to: start });
+    }
+    return ranges.map((range) => ({ from: timeOfMinutes(range.from), to: timeOfMinutes(range.to) }));
+}
+/** Minutes east of UTC of a named zone at a moment. */
+function zoneOffsetMinutes(timeZone, at) {
+    const parts = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        hourCycle: "h23",
+        year: "numeric",
+        month: "numeric",
+        day: "numeric",
+        hour: "numeric",
+        minute: "numeric",
+        second: "numeric",
+    }).formatToParts(at);
+    const read = (type) => Number(parts.find((part) => part.type === type)?.value);
+    const asUtc = Date.UTC(read("year"), read("month") - 1, read("day"), read("hour"), read("minute"), read("second"));
+    return Math.round((asUtc - at.getTime()) / 60_000);
+}
+/**
+ * Why this process must not book for salons in `expectedTimeZone`, or `null` when it may: the
+ * process clock has to run in that zone, because the canister wrapper takes every offset from it.
+ */
+export function hostTimeZoneProblem(expectedTimeZone, at = new Date()) {
+    let expected;
+    try {
+        expected = zoneOffsetMinutes(expectedTimeZone, at);
+    }
+    catch {
+        return `nieznana strefa czasowa „${expectedTimeZone}”`;
+    }
+    const actual = -at.getTimezoneOffset();
+    if (actual === expected)
+        return null;
+    return `proces działa w innej strefie czasowej niż salony (${expectedTimeZone}): różnica ${Math.abs(expected - actual)} min — ustaw TZ=${expectedTimeZone}`;
+}

package/dist/customer/tools.d.ts

@@ -0,0 +1,17 @@
+import type { TurnConfirmations } from "../confirmations.js";
+import { type AgentTool } from "../types.js";
+import type { CustomerCorePort } from "./customer-core-port.js";
+export interface CustomerToolsContext {
+    port: CustomerCorePort;
+    /** The clock — a test sets it. */
+    now: () => Date;
+    /** The salons' time zone the host process must run in; `undefined` skips the guard. */
+    timeZone?: string;
+}
+export declare function searchSlotsTool(context: CustomerToolsContext): AgentTool;
+export declare function getSalonTool(context: CustomerToolsContext): AgentTool;
+export declare function getFreeTimesTool(context: CustomerToolsContext): AgentTool;
+export declare function bookAppointmentTool(context: CustomerToolsContext, confirmations: TurnConfirmations | undefined): AgentTool;
+export declare function listMyAppointmentsTool(context: CustomerToolsContext): AgentTool;
+export declare function cancelAppointmentTool(context: CustomerToolsContext, confirmations: TurnConfirmations | undefined): AgentTool;
+//# sourceMappingURL=tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../src/customer/tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAI7D,OAAO,EAAW,KAAK,SAAS,EAAmB,MAAM,aAAa,CAAC;AACvE,OAAO,KAAK,EAAmB,gBAAgB,EAAkD,MAAM,yBAAyB,CAAC;AAejI,MAAM,WAAW,oBAAoB;IACjC,IAAI,EAAE,gBAAgB,CAAC;IACvB,kCAAkC;IAClC,GAAG,EAAE,MAAM,IAAI,CAAC;IAChB,uFAAuF;IACvF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAwCD,wBAAgB,eAAe,CAAC,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAgFxE;AAUD,wBAAgB,YAAY,CAAC,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAkCrE;AAkCD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,GAAG,SAAS,CA2CzE;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,iBAAiB,GAAG,SAAS,GAAG,SAAS,CA6E1H;AA6CD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,oBAAoB,GAAG,SAAS,CAkC/E;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,iBAAiB,GAAG,SAAS,GAAG,SAAS,CA4C5H"}

package/dist/customer/tools.js

@@ -0,0 +1,415 @@
+import { toToolError } from "../errors.js";
+import { ArgumentError, readBoolean, readOptionalNumber, readOptionalString, readString } from "../tools/args.js";
+import { writeGate } from "../tools/write-gate.js";
+import { err, ok } from "../types.js";
+import { foldStartRanges, freeStartMinutes, hostTimeZoneProblem, isDay, localDayOf, localStampOf, localTimeOf, minutesOf, momentOf, onSlotGrid, timeOfMinutes, } from "./time.js";
+const DEFAULT_RADIUS_KM = 10;
+const MAX_RADIUS_KM = 50;
+const MAX_SALONS_SHOWN = 6;
+const MAX_TIMES_SHOWN = 6;
+/** "Pick a time": the asked moment, a little before it and the hour after it. */
+const AROUND_TIME_MINUTES = [-30, -15, 0, 15, 30, 45, 60];
+const CONFIRMED_FIELD = {
+    type: "boolean",
+    description: "false = pokaż podgląd bez zapisu; true = wykonaj, dopiero po zgodzie klienta w jego następnej wiadomości.",
+};
+const NO_LOCATION = "Aplikacja nie podała pozycji klienta, więc nie wiem, gdzie szukać. Poproś klienta, żeby włączył lokalizację w aplikacji i otworzył czat ponownie.";
+/** Refuses every time-dependent tool while the host clock runs in the wrong zone. */
+function zoneRefusal(context) {
+    if (!context.timeZone)
+        return null;
+    const problem = hostTimeZoneProblem(context.timeZone, context.now());
+    return problem ? err("unavailable", `Rezerwacje są chwilowo wyłączone: ${problem}.`) : null;
+}
+function readDay(args, key) {
+    const day = readString(args, key);
+    if (!isDay(day))
+        throw new ArgumentError(`Pole "${key}" musi być datą w formacie RRRR-MM-DD.`);
+    return day;
+}
+function readTimeMinutes(args, key) {
+    const minutes = minutesOf(readString(args, key));
+    if (minutes === null)
+        throw new ArgumentError(`Pole "${key}" musi być godziną w formacie GG:MM.`);
+    return minutes;
+}
+function serviceLine(service) {
+    return { serviceId: service.id, name: service.name, pricePln: service.pricePln, durationMinutes: service.durationMinutes };
+}
+export function searchSlotsTool(context) {
+    const { port } = context;
+    return {
+        name: "search_slots",
+        progress: "Szukam wolnych terminów w okolicy…",
+        description: "Szuka salonów w okolicy klienta, które mają wolny termin na usługę danego typu. Bez date i time szuka „jak najszybciej” (najbliższa godzina, a gdy nic nie ma — do 24 godzin naprzód). Z date i time sprawdza okolice tej godziny (pół godziny wcześniej do godziny później). Zwraca salony z usługami (serviceId, cena, czas) i wolnymi terminami. serviceTypeId weź z find_service_type.",
+        parameters: {
+            type: "object",
+            properties: {
+                serviceTypeId: { type: "string", description: "Id typu usługi z find_service_type." },
+                date: { type: "string", description: "Dzień RRRR-MM-DD. Pomiń razem z time, żeby szukać jak najszybciej." },
+                time: { type: "string", description: "Godzina GG:MM. Wymagana, gdy podajesz date." },
+                radiusKm: { type: "number", description: `Promień szukania w km, domyślnie ${DEFAULT_RADIUS_KM}, najwyżej ${MAX_RADIUS_KM}.` },
+            },
+            required: ["serviceTypeId"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const refusal = zoneRefusal(context);
+                if (refusal)
+                    return refusal;
+                if (!port.location)
+                    return err("invalid_arguments", NO_LOCATION);
+                const serviceTypeId = readString(args, "serviceTypeId");
+                const radiusKm = Math.min(Math.max(readOptionalNumber(args, "radiusKm") ?? DEFAULT_RADIUS_KM, 1), MAX_RADIUS_KM);
+                const dayText = readOptionalString(args, "date");
+                const timeText = readOptionalString(args, "time");
+                const now = context.now();
+                if ((dayText === undefined) !== (timeText === undefined)) {
+                    throw new ArgumentError("Podaj date i time razem albo pomiń oba (jak najszybciej).");
+                }
+                let found;
+                let lead;
+                if (dayText === undefined) {
+                    found = await port.searchAsap(serviceTypeId, radiusKm, now);
+                    lead = found.phase === "extended" ? "W najbliższej godzinie nic wolnego, na które klient zdąży. Najbliższe terminy:" : "Najbliższe wolne terminy:";
+                }
+                else {
+                    const day = readDay(args, "date");
+                    const at = readTimeMinutes(args, "time");
+                    const moments = AROUND_TIME_MINUTES.map((shift) => momentOf(day, at) + shift * 60_000)
+                        // Only moments of the asked day's grid that are still ahead.
+                        .filter((moment) => moment > now.getTime() && onSlotGrid(new Date(moment).getMinutes()));
+                    if (moments.length === 0)
+                        return err("invalid_arguments", "Ten termin już minął. Zapytaj klienta o późniejszy.");
+                    found = await port.searchAtMoments(serviceTypeId, radiusKm, moments);
+                    lead = `Wolne terminy w okolicach ${day} ${timeOfMinutes(at)}:`;
+                }
+                if (found.salons.length === 0) {
+                    if (found.failedProbes > 0)
+                        return err("unavailable", "Nie udało się sprawdzić terminów — kanister nie odpowiadał. Spróbuj ponownie za chwilę.");
+                    return ok(`Nic wolnego w promieniu ${radiusKm} km. Zaproponuj inną godzinę, inny dzień albo większy promień.`, []);
+                }
+                const ranked = [...found.salons].sort(bySoonestThenNearest).slice(0, MAX_SALONS_SHOWN);
+                const names = new Map((await port.getSalons(ranked.map((salon) => salon.salonId))).map((salon) => [salon.id, salon]));
+                const data = ranked.map((salon) => ({
+                    salonId: salon.salonId,
+                    name: names.get(salon.salonId)?.name ?? "Salon",
+                    address: names.get(salon.salonId)?.address ?? "",
+                    distanceKm: Math.round(salon.distanceKm * 10) / 10,
+                    services: salon.services.map(serviceLine),
+                    freeAt: salon.availableAt.slice(0, MAX_TIMES_SHOWN).map(localStampOf),
+                }));
+                const more = found.salons.length > ranked.length ? ` Pokazuję ${ranked.length} z ${found.salons.length} salonów.` : "";
+                return ok(`${lead} ${ranked.length} salon(y).${more} Terminy to początek wizyty; inne godziny w danym salonie sprawdź przez get_free_times.`, data);
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się wyszukać terminów.");
+            }
+        },
+    };
+}
+function firstMoment(salon) {
+    return salon.soonestAt ?? salon.availableAt[0] ?? Number.MAX_SAFE_INTEGER;
+}
+function bySoonestThenNearest(a, b) {
+    return firstMoment(a) - firstMoment(b) || a.distanceKm - b.distanceKm;
+}
+export function getSalonTool(context) {
+    const { port } = context;
+    return {
+        name: "get_salon",
+        progress: "Sprawdzam salon…",
+        description: "Zwraca salon: nazwę, adres, AKTYWNE usługi z cenami (serviceId) i aktywne promocje z kodami rabatowymi. salonId weź z search_slots albo list_my_appointments.",
+        parameters: {
+            type: "object",
+            properties: { salonId: { type: "string", description: "Id salonu." } },
+            required: ["salonId"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const salonId = readString(args, "salonId");
+                const [salon] = await port.getSalons([salonId]);
+                if (!salon)
+                    return err("not_found", "Nie ma takiego salonu. Id weź z search_slots.");
+                const [services, promos] = await Promise.all([port.listSalonServices(salonId), port.listSalonPromos(salonId)]);
+                return ok(`${salon.name}, ${salon.address}: ${services.length} usług(i), ${promos.length} promocji.`, {
+                    salonId,
+                    name: salon.name,
+                    address: salon.address,
+                    services: services.map(serviceLine),
+                    promos,
+                });
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się odczytać salonu.");
+            }
+        },
+    };
+}
+/** The salon's active service, or the tool error that says why not. */
+async function findService(port, salonId, serviceId) {
+    const services = await port.listSalonServices(salonId);
+    const service = services.find((candidate) => candidate.id === serviceId);
+    if (!service)
+        return err("not_found", "Ten salon nie ma takiej aktywnej usługi. Id salonu i usługi weź z search_slots albo get_salon.");
+    if (service.workerIds.length === 0)
+        return err("not_found", `Usługi „${service.name}” nikt teraz nie wykonuje — nie da się jej zarezerwować.`);
+    return service;
+}
+/** Free start minutes of a service on a day → the first worker free then (the app's rule). */
+async function freeStartsByWorker(port, service, day) {
+    const perWorker = await Promise.all(service.workerIds.map(async (workerId) => {
+        try {
+            return { workerId, starts: freeStartMinutes(await port.freeWindows(service.salonId, workerId, day), service.durationMinutes) };
+        }
+        catch {
+            // A worker with no hours that day is refused by the canister; the others still count.
+            return { workerId, starts: [] };
+        }
+    }));
+    const workerAt = new Map();
+    for (const { workerId, starts } of perWorker) {
+        for (const start of starts)
+            if (!workerAt.has(start))
+                workerAt.set(start, workerId);
+    }
+    return workerAt;
+}
+export function getFreeTimesTool(context) {
+    const { port } = context;
+    return {
+        name: "get_free_times",
+        progress: "Sprawdzam wolne godziny…",
+        description: "Zwraca wolne godziny rozpoczęcia jednej usługi w jednym salonie w danym dniu, jako przedziały (wizyta może zacząć się co 5 minut od from do to włącznie).",
+        parameters: {
+            type: "object",
+            properties: {
+                salonId: { type: "string", description: "Id salonu." },
+                serviceId: { type: "string", description: "Id usługi z search_slots albo get_salon." },
+                date: { type: "string", description: "Dzień RRRR-MM-DD." },
+            },
+            required: ["salonId", "serviceId", "date"],
+            additionalProperties: false,
+        },
+        execute: async (args) => {
+            try {
+                const refusal = zoneRefusal(context);
+                if (refusal)
+                    return refusal;
+                const salonId = readString(args, "salonId");
+                const day = readDay(args, "date");
+                const now = context.now();
+                if (day < localDayOf(now))
+                    return err("invalid_arguments", "Ten dzień już minął.");
+                const service = await findService(port, salonId, readString(args, "serviceId"));
+                if ("status" in service)
+                    return service;
+                const nowMinutes = day === localDayOf(now) ? now.getHours() * 60 + now.getMinutes() : -1;
+                const starts = [...(await freeStartsByWorker(port, service, day)).keys()].filter((start) => start > nowMinutes).sort((a, b) => a - b);
+                if (starts.length === 0)
+                    return ok(`„${service.name}” — ${day}: brak wolnych godzin.`, []);
+                return ok(`„${service.name}” — ${day}: wolne godziny rozpoczęcia (${service.durationMinutes} min, ${service.pricePln} zł).`, foldStartRanges(starts));
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się sprawdzić wolnych godzin.");
+            }
+        },
+    };
+}
+export function bookAppointmentTool(context, confirmations) {
+    const { port } = context;
+    const gate = writeGate("book_appointment", confirmations);
+    return {
+        name: "book_appointment",
+        progress: "Rezerwuję wizytę…",
+        description: "Rezerwuje wizytę w imieniu klienta. Najpierw confirmed=false: dostaniesz podsumowanie do pokazania klientowi. Rezerwacja następuje dopiero przy confirmed=true po jego zgodzie. Pracownika dobiera system.",
+        parameters: gate.parameters({
+            type: "object",
+            properties: {
+                salonId: { type: "string", description: "Id salonu." },
+                serviceId: { type: "string", description: "Id usługi z search_slots albo get_salon." },
+                date: { type: "string", description: "Dzień wizyty RRRR-MM-DD." },
+                time: { type: "string", description: "Godzina rozpoczęcia GG:MM, wielokrotność 5 minut." },
+                discountCode: { type: "string", description: "Kod rabatowy, tylko gdy klient go podał albo pochodzi z promocji salonu." },
+                notes: { type: "string", description: "Uwagi klienta dla salonu." },
+                confirmed: CONFIRMED_FIELD,
+            },
+            required: ["salonId", "serviceId", "date", "time", "confirmed"],
+            additionalProperties: false,
+        }),
+        execute: async (args) => {
+            try {
+                const zone = zoneRefusal(context);
+                if (zone)
+                    return zone;
+                const salonId = readString(args, "salonId");
+                const serviceId = readString(args, "serviceId");
+                const day = readDay(args, "date");
+                const startMinutes = readTimeMinutes(args, "time");
+                const discountCode = readOptionalString(args, "discountCode");
+                const notes = readOptionalString(args, "notes");
+                if (!onSlotGrid(startMinutes))
+                    throw new ArgumentError("Wizyta może zacząć się tylko o pełnych 5 minutach (np. 10:00, 10:05).");
+                // The echo is the change in its normal form, whichever spelling the model used.
+                const echo = { salonId, serviceId, date: day, time: timeOfMinutes(startMinutes) };
+                if (discountCode !== undefined)
+                    echo.discountCode = discountCode;
+                if (notes !== undefined)
+                    echo.notes = notes;
+                const refusal = gate.refusal(args, echo);
+                if (refusal)
+                    return refusal;
+                const startAt = momentOf(day, startMinutes);
+                if (startAt <= context.now().getTime())
+                    return err("invalid_arguments", "Ten termin już minął. Zapytaj klienta o późniejszy.");
+                const service = await findService(port, salonId, serviceId);
+                if ("status" in service)
+                    return service;
+                // Checked on BOTH calls: a refused booking still spends the customer's daily quota,
+                // and the slot may have gone between the preview and the "yes".
+                const workerId = (await freeStartsByWorker(port, service, day)).get(startMinutes);
+                if (workerId === undefined) {
+                    return err("not_found", `Termin ${day} ${timeOfMinutes(startMinutes)} nie jest już wolny. Sprawdź inne godziny przez get_free_times.`);
+                }
+                const [salon] = await port.getSalons([salonId]);
+                const where = salon ? `${salon.name} (${salon.address})` : "salon";
+                const code = discountCode === undefined ? "" : `, z kodem rabatowym ${discountCode}`;
+                const what = `„${service.name}” w ${where}, ${day} o ${timeOfMinutes(startMinutes)}, ${service.durationMinutes} min, cena ${service.pricePln} zł${code}`;
+                if (!readBoolean(args, "confirmed"))
+                    return gate.preview(`Zarezerwuję: ${what}.`, echo);
+                const refused = gate.redeem(args, echo);
+                if (refused)
+                    return refused;
+                const appointmentId = await port.book({ salonId, serviceId, workerId, startAt, notes: notes ?? "", discountCode });
+                return ok(`Zarezerwowano: ${what}.${await pricePaidNote(port, appointmentId, service.pricePln)} Wizyta jest w zakładce „Wizyty”.`, { appointmentId });
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się zarezerwować wizyty.");
+            }
+        },
+    };
+}
+/** What the customer really pays, when a discount code changed it. Never fails a booking that is
+ * already made — and a query right after an update may not see it yet. */
+async function pricePaidNote(port, appointmentId, listPricePln) {
+    try {
+        const booked = (await port.listMyAppointments()).find((appointment) => appointment.id === appointmentId);
+        if (!booked || booked.pricePln === listPricePln)
+            return "";
+        return ` Cena po rabacie: ${booked.pricePln} zł.`;
+    }
+    catch {
+        return "";
+    }
+}
+/** The customer's visits still ahead, soonest first, with the names a person knows them by. */
+async function upcomingAppointments(port, now) {
+    const upcoming = (await port.listMyAppointments())
+        .filter((appointment) => (appointment.status === "Confirmed" || appointment.status === "Pending") && appointment.startAt > now.getTime())
+        .sort((a, b) => a.startAt - b.startAt);
+    const salonIds = [...new Set(upcoming.map((appointment) => appointment.salonId))];
+    const salons = new Map((await port.getSalons(salonIds)).map((salon) => [salon.id, salon]));
+    const serviceNames = new Map();
+    await Promise.all(salonIds.map(async (salonId) => {
+        try {
+            for (const service of await port.listSalonServices(salonId))
+                serviceNames.set(service.id, service.name);
+        }
+        catch {
+            // A visit is still worth listing without its service's name.
+        }
+    }));
+    return upcoming.map((appointment) => ({ ...appointment, salon: salons.get(appointment.salonId), serviceName: serviceNames.get(appointment.serviceId) }));
+}
+function describeAppointment(appointment) {
+    const what = appointment.serviceName ? `„${appointment.serviceName}”` : "wizyta";
+    const where = appointment.salon ? ` w ${appointment.salon.name} (${appointment.salon.address})` : "";
+    return `${what}${where}, ${localDayOf(appointment.startAt)} o ${localTimeOf(appointment.startAt)}`;
+}
+export function listMyAppointmentsTool(context) {
+    const { port } = context;
+    return {
+        name: "list_my_appointments",
+        progress: "Sprawdzam Twoje wizyty…",
+        description: "Zwraca nadchodzące wizyty klienta (potwierdzone, jeszcze nie odbyte): id wizyty, salon, usługę, termin i cenę.",
+        parameters: { type: "object", properties: {}, additionalProperties: false },
+        execute: async () => {
+            try {
+                const zone = zoneRefusal(context);
+                if (zone)
+                    return zone;
+                const upcoming = await upcomingAppointments(port, context.now());
+                if (upcoming.length === 0)
+                    return ok("Klient nie ma nadchodzących wizyt.", []);
+                return ok(`Nadchodzące wizyty: ${upcoming.length}.`, upcoming.map((appointment) => ({
+                    appointmentId: appointment.id,
+                    salonId: appointment.salonId,
+                    salonName: appointment.salon?.name ?? "Salon",
+                    address: appointment.salon?.address ?? "",
+                    serviceName: appointment.serviceName ?? "",
+                    start: localStampOf(appointment.startAt),
+                    durationMinutes: appointment.durationMinutes,
+                    pricePln: appointment.pricePln,
+                })));
+            }
+            catch (error) {
+                return toToolError(error, "Nie udało się odczytać wizyt.");
+            }
+        },
+    };
+}
+export function cancelAppointmentTool(context, confirmations) {
+    const { port } = context;
+    const gate = writeGate("cancel_appointment", confirmations);
+    return {
+        name: "cancel_appointment",
+        progress: "Odwołuję wizytę…",
+        description: "Odwołuje nadchodzącą wizytę klienta. Najpierw confirmed=false (podsumowanie dla klienta), potem confirmed=true po jego zgodzie. appointmentId weź z list_my_appointments.",
+        parameters: gate.parameters({
+            type: "object",
+            properties: {
+                appointmentId: { type: "string", description: "Id wizyty z list_my_appointments." },
+                confirmed: CONFIRMED_FIELD,
+            },
+            required: ["appointmentId", "confirmed"],
+            additionalProperties: false,
+        }),
+        execute: async (args) => {
+            try {
+                const zone = zoneRefusal(context);
+                if (zone)
+                    return zone;
+                const appointmentId = readString(args, "appointmentId");
+                const echo = { appointmentId };
+                const refusal = gate.refusal(args, echo);
+                if (refusal)
+                    return refusal;
+                const appointment = (await upcomingAppointments(port, context.now())).find((candidate) => candidate.id === appointmentId);
+                if (!appointment)
+                    return err("not_found", "Klient nie ma takiej nadchodzącej wizyty. Id weź z list_my_appointments.");
+                if (!readBoolean(args, "confirmed"))
+                    return gate.preview(`Odwołam wizytę: ${describeAppointment(appointment)}.`, echo);
+                const refused = gate.redeem(args, echo);
+                if (refused)
+                    return refused;
+                await port.cancel(appointmentId);
+                return ok(`Odwołano wizytę: ${describeAppointment(appointment)}.`, { appointmentId });
+            }
+            catch (error) {
+                if (error instanceof ArgumentError)
+                    return err("invalid_arguments", error.message);
+                return toToolError(error, "Nie udało się odwołać wizyty.");
+            }
+        },
+    };
+}

package/dist/index.d.ts

@@ -2,6 +2,13 @@ export { ConfirmationLedger, DEFAULT_CONFIRMATION_TTL_MS } from "./confirmations
 export type { ConfirmationLedgerOptions, ConfirmationRefusal, RedeemResult, TurnConfirmations, } from "./confirmations.js";
 export { createSalonReadTools, createSalonReadToolsFromPort, createSalonTools, createSalonToolsFromPort, } from "./create-salon-tools.js";
 export type { CreateSalonReadToolsOptions, CreateSalonToolsFromPortOptions, CreateSalonToolsOptions, } from "./create-salon-tools.js";
+export { createCustomerReadTools, createCustomerReadToolsFromPort, createCustomerTools, createCustomerToolsFromPort, DEFAULT_SALON_TIME_ZONE, } from "./customer/create-customer-tools.js";
+export type { CreateCustomerReadToolsOptions, CreateCustomerToolsFromPortOptions, CreateCustomerToolsOptions, } from "./customer/create-customer-tools.js";
+export type { AppointmentStatusView, AppointmentView, BookingInput, Coordinates, CustomerCorePort, CustomerPromoView, CustomerServiceView, SalonSlotsView, SalonView, SlotSearchView, } from "./customer/customer-core-port.js";
+export { IcCustomerCorePort } from "./customer/ic-customer-core-port.js";
+export type { IcCustomerCorePortOptions } from "./customer/ic-customer-core-port.js";
+export { CUSTOMER_AGENT_PERSONA_PL } from "./customer/persona.js";
+export { hostTimeZoneProblem } from "./customer/time.js";
 export { IcSalonCorePort } from "./ic-salon-core-port.js";
 export type { IcSalonCorePortOptions } from "./ic-salon-core-port.js";
 export { SALON_AGENT_PERSONA_PL, SALON_READ_PERSONA_PL } from "./persona.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AACrF,YAAY,EACR,yBAAyB,EACzB,mBAAmB,EACnB,YAAY,EACZ,iBAAiB,GACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACH,oBAAoB,EACpB,4BAA4B,EAC5B,gBAAgB,EAChB,wBAAwB,GAC3B,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACR,2BAA2B,EAC3B,+BAA+B,EAC/B,uBAAuB,GAC1B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,YAAY,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC7E,YAAY,EACR,iBAAiB,EACjB,gBAAgB,EAChB,SAAS,EACT,SAAS,EACT,eAAe,EACf,WAAW,EACX,aAAa,EACb,cAAc,EACd,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,iBAAiB,EACjB,SAAS,EACT,UAAU,GACb,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,GAAG,EAAE,iBAAiB,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AACxD,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AACrF,YAAY,EACR,yBAAyB,EACzB,mBAAmB,EACnB,YAAY,EACZ,iBAAiB,GACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACH,oBAAoB,EACpB,4BAA4B,EAC5B,gBAAgB,EAChB,wBAAwB,GAC3B,MAAM,yBAAyB,CAAC;AACjC,YAAY,EACR,2BAA2B,EAC3B,+BAA+B,EAC/B,uBAAuB,GAC1B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACH,uBAAuB,EACvB,+BAA+B,EAC/B,mBAAmB,EACnB,2BAA2B,EAC3B,uBAAuB,GAC1B,MAAM,qCAAqC,CAAC;AAC7C,YAAY,EACR,8BAA8B,EAC9B,kCAAkC,EAClC,0BAA0B,GAC7B,MAAM,qCAAqC,CAAC;AAC7C,YAAY,EACR,qBAAqB,EACrB,eAAe,EACf,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,SAAS,EACT,cAAc,GACjB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,YAAY,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AACrF,OAAO,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,YAAY,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC7E,YAAY,EACR,iBAAiB,EACjB,gBAAgB,EAChB,SAAS,EACT,SAAS,EACT,eAAe,EACf,WAAW,EACX,aAAa,EACb,cAAc,EACd,eAAe,EACf,WAAW,EACX,iBAAiB,EACjB,iBAAiB,EACjB,SAAS,EACT,UAAU,GACb,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,GAAG,EAAE,iBAAiB,EAAE,EAAE,EAAE,MAAM,YAAY,CAAC;AACxD,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,5 +1,9 @@
 export { ConfirmationLedger, DEFAULT_CONFIRMATION_TTL_MS } from "./confirmations.js";
 export { createSalonReadTools, createSalonReadToolsFromPort, createSalonTools, createSalonToolsFromPort, } from "./create-salon-tools.js";
+export { createCustomerReadTools, createCustomerReadToolsFromPort, createCustomerTools, createCustomerToolsFromPort, DEFAULT_SALON_TIME_ZONE, } from "./customer/create-customer-tools.js";
+export { IcCustomerCorePort } from "./customer/ic-customer-core-port.js";
+export { CUSTOMER_AGENT_PERSONA_PL } from "./customer/persona.js";
+export { hostTimeZoneProblem } from "./customer/time.js";
 export { IcSalonCorePort } from "./ic-salon-core-port.js";
 export { SALON_AGENT_PERSONA_PL, SALON_READ_PERSONA_PL } from "./persona.js";
 export { err, needsConfirmation, ok } from "./types.js";

package/dist/tools/services.d.ts

@@ -4,5 +4,6 @@ import { type AgentTool } from "../types.js";
 export declare function createServiceTools(port: SalonCorePort, confirmations?: TurnConfirmations): 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;
+/** Takes any port that can search the catalogue — the customer set shares this tool. */
+export declare function findServiceTypeTool(port: Pick<SalonCorePort, "findServiceTypes">): AgentTool;
 //# sourceMappingURL=services.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/tools/services.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAkC,MAAM,uBAAuB,CAAC;AACxG,OAAO,EAAW,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAwBtD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,aAAa,CAAC,EAAE,iBAAiB,GAAG,SAAS,EAAE,CAStG;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"}
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/tools/services.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAkC,MAAM,uBAAuB,CAAC;AACxG,OAAO,EAAW,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAwBtD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,aAAa,CAAC,EAAE,iBAAiB,GAAG,SAAS,EAAE,CAStG;AAoBD,8FAA8F;AAC9F,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,GAAE,WAAqB,GAAG,SAAS,CAmB9F;AAED,wFAAwF;AACxF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,kBAAkB,CAAC,GAAG,SAAS,CAiC5F"}

package/dist/tools/services.js

@@ -54,6 +54,7 @@ export function listServicesTool(port, access = "owner") {
         },
     };
 }
+/** Takes any port that can search the catalogue — the customer set shares this tool. */
 export function findServiceTypeTool(port) {
     return {
         name: "find_service_type",

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@jsm-mit/sultana-agent-tools-package",
-    "version": "0.3.0",
-    "description": "Agent tool layer for a Sultana salon: framework-agnostic tools (services, promos, schedule) over the Sultana core canister wrapper, plus a read-only set that needs no identity.",
+    "version": "0.4.0",
+    "description": "Agent tool layer for Sultana: framework-agnostic tools over the Sultana core canister wrapper — a salon owner's set (services, promos, schedule) and a customer's set (search, free times, booking), each with a read-only set that needs no identity.",
     "homepage": "https://github.com/JSM-Sultana/sultana-agent-tools-package#readme",
     "bugs": {
         "url": "https://github.com/JSM-Sultana/sultana-agent-tools-package/issues"
@@ -31,12 +31,13 @@
         "sandbox": "npx tsx --env-file-if-exists=.env sandbox/main.ts",
         "prepare": "npm run build",
         "test-tools": "npx tsx --env-file-if-exists=.env --test tests/integration/test-salon-tools.ts",
+        "test-customer-tools": "npx tsx --env-file-if-exists=.env --test tests/integration/test-customer-tools.ts",
         "whoami": "npx tsx --env-file-if-exists=.env sandbox/whoami.ts",
         "publish-public": "bash scripts/publish-public.sh"
     },
     "dependencies": {
         "@icp-sdk/core": "^6.1.0",
-        "@jsm-mit/sultana-core-motoko-package": "^0.17.0"
+        "@jsm-mit/sultana-core-motoko-package": "^0.21.1"
     },
     "devDependencies": {
         "@jsm-mit/utils-package": "^0.5.0",