@cosmoops/connect-sdk 0.37.0 → 0.38.0

package/dist/esm/server/resources/scheduling.js

@@ -31,6 +31,68 @@ export class SchedulingResource {
         // `undefined` past every status check in between.
         return result.eventTypes ?? [];
     }
+    /**
+     * The working-hours templates an appointment type can point at.
+     *
+     * Read this before offering to create one - a workspace that already has
+     * hours set does not need a second "Working hours" from your integration.
+     */
+    async listSchedules(workspaceId, options = {}) {
+        const result = await request(this.transport, {
+            method: "GET",
+            path: "/scheduling/schedules",
+            query: { workspaceId },
+            headers: actingAs(options.asUser),
+        });
+        return result.schedules ?? [];
+    }
+    /**
+     * Gives a workspace its first working hours.
+     *
+     * Narrower than what the workspace's own Calendar settings can do - no date
+     * overrides, and never owned by one person (`ownerMemberId` stays `null`
+     * server-side). Anything beyond that is a Console edit, not a second write
+     * path for your integration to maintain.
+     */
+    createSchedule(input) {
+        return request(this.transport, {
+            method: "POST",
+            path: "/scheduling/schedules",
+            json: {
+                workspaceId: input.workspaceId,
+                name: input.name,
+                timezone: input.timezone,
+                weeklyHours: input.weeklyHours,
+            },
+            headers: actingAs(input.asUser),
+        });
+    }
+    /**
+     * The first thing a workspace can be booked for.
+     *
+     * Needs a schedule - create or pick one with `listSchedules`/`createSchedule`
+     * first. The slug for a future public booking link is derived from `name`
+     * server-side; you cannot choose one.
+     */
+    createEventType(input) {
+        return request(this.transport, {
+            method: "POST",
+            path: "/scheduling/event-types",
+            json: {
+                workspaceId: input.workspaceId,
+                name: input.name,
+                description: input.description ?? null,
+                durationMinutes: input.durationMinutes,
+                bufferBeforeMinutes: input.bufferBeforeMinutes,
+                bufferAfterMinutes: input.bufferAfterMinutes,
+                hostMemberId: input.hostMemberId,
+                scheduleId: input.scheduleId,
+                location: input.location,
+                publicBookingEnabled: input.publicBookingEnabled ?? false,
+            },
+            headers: actingAs(input.asUser),
+        });
+    }
     /**
      * Free times for one appointment type over one window.
      *

package/dist/esm/server/resources/visitor.js

@@ -1,4 +1,4 @@
-import { request } from "../http.js";
+import { GENERATION_TIMEOUT_MS, request } from "../http.js";
 /**
  * The header a bridge forwards the visitor's own address on.
  *
@@ -97,6 +97,12 @@ export class VisitorResource {
             path: "/visitor/chat",
             json: input,
             headers: visitorHeaders(options),
+            /*
+             * Matches the route's own `maxDuration`. This endpoint does not send
+             * headers until the model's first token, so the default 20s bound was
+             * aborting any turn that opened with a tool call - see `RequestSpec.timeoutMs`.
+             */
+            timeoutMs: GENERATION_TIMEOUT_MS,
             raw: true,
             signal: options.signal,
         });

package/dist/types/client/components/availability-form.d.ts

@@ -0,0 +1,22 @@
+import type { AvailabilitySchedule } from "../../types.js";
+export interface ConnectAvailabilityFormModalProps {
+    isOpen: boolean;
+    onOpenChange: (isOpen: boolean) => void;
+    /** Called once the schedule is created, before the modal closes. */
+    onCreated?: (schedule: AvailabilitySchedule) => void;
+}
+/**
+ * Gives a workspace its first working hours, from inside a host application
+ * rather than a link-out to Connect.
+ *
+ * Deliberately narrower than Connect's own Calendar settings form: one
+ * interval per day (no split shifts), no date overrides, and the timezone
+ * defaults to the browser's own rather than asking. This is a first-run
+ * setup step, not a second copy of the Console editor - "Manage in Connect"
+ * is still where the rest of what a schedule can do lives.
+ *
+ * **Not optimistic.** `useCreateAvailabilitySchedule` settles the write
+ * against the server before this closes, the same posture every write in
+ * this package takes - see `ConnectBookingDialog`.
+ */
+export declare function ConnectAvailabilityFormModal({ isOpen, onOpenChange, onCreated, }: Readonly<ConnectAvailabilityFormModalProps>): import("react").JSX.Element;

package/dist/types/client/components/event-type-form.d.ts

@@ -0,0 +1,22 @@
+import type { BookableEventType } from "../../types.js";
+export interface ConnectEventTypeFormModalProps {
+    isOpen: boolean;
+    onOpenChange: (isOpen: boolean) => void;
+    /** Called once the appointment type is created, before the modal closes. */
+    onCreated?: (eventType: BookableEventType) => void;
+}
+/**
+ * Creates the first thing a workspace can be booked for, from inside a host
+ * application rather than a link-out to Connect.
+ *
+ * **Needs a schedule to exist first** - the picker reads `useAvailabilitySchedules`
+ * and renders "Set up availability first" with nothing to submit if none
+ * exists yet. Pair this with `ConnectAvailabilityFormModal` in a setup flow
+ * rather than assuming one.
+ *
+ * **Host is a specific member, never a team.** There is no groups read in
+ * this bridge, so a round-robin team host stays a Console-only capability -
+ * defaults to whoever is signed in, with an optional picker from the
+ * workspace's own roster.
+ */
+export declare function ConnectEventTypeFormModal({ isOpen, onOpenChange, onCreated, }: Readonly<ConnectEventTypeFormModalProps>): import("react").JSX.Element;

package/dist/types/client/index.d.ts

@@ -32,6 +32,7 @@ export type { ConnectUserButtonProps, ConnectProfileModalProps } from "./compone
 export { ConnectAccountSessions } from "./components/account-sessions.js";
 export type { ConnectAccountSessionsProps } from "./components/account-sessions.js";
 export type { ConnectUserMenuProps } from "./components/user-menu.js";
+export { connectPortalUrl, useConnectPortalUrl } from "./portal-links.js";
 export { AppShell } from "./components/app-shell.js";
 export type { AppShellProps } from "./components/app-shell.js";
 export { ConnectSidebar, ConnectSidebarHeader, ConnectSidebarBody, ConnectSidebarFooter, ConnectSidebarRow, } from "./components/sidebar.js";
@@ -104,5 +105,9 @@ export { useConnectWorkspaces, useConnectWorkspaceMembers } from "./provider.js"
 export { ConnectBookingCalendar } from "./components/booking-calendar.js";
 export type { ConnectBookingCalendarProps } from "./components/booking-calendar.js";
 export { ConnectBookingDialog, ConnectBookingDetail } from "./components/booking-dialogs.js";
-export { useBookableEventTypes, useAvailableSlots, useBookings, useBookingActions, type SlotQuery, type BookingsQuery, } from "./use-scheduling.js";
+export { ConnectAvailabilityFormModal } from "./components/availability-form.js";
+export type { ConnectAvailabilityFormModalProps } from "./components/availability-form.js";
+export { ConnectEventTypeFormModal } from "./components/event-type-form.js";
+export type { ConnectEventTypeFormModalProps } from "./components/event-type-form.js";
+export { useBookableEventTypes, useAvailabilitySchedules, useCreateAvailabilitySchedule, useCreateEventType, useAvailableSlots, useBookings, useBookingActions, type SlotQuery, type BookingsQuery, } from "./use-scheduling.js";
 export { layoutBookings, dayColumns, zonedInstant, type GridWindow, type PositionedBooking, } from "./components/booking-grid.js";

package/dist/types/client/portal-links.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Any Connect portal page, with the context it needs to offer a way back
+ * here - `connectPortalUrl(appUrl, clientId, "/profile")`,
+ * `connectPortalUrl(appUrl, clientId, "/calendar/settings")`, and so on.
+ *
+ * Connect answers any of these paths for a signed-in user on the bare URL -
+ * these two params only add the "Back to <your app>" banner
+ * (`ApplicationReturnBar` on Connect's side). It validates `return_to`
+ * against this `client_id`'s registered redirect origins and silently drops
+ * the banner if they don't match, so a wrong or stale `appUrl`/`clientId`
+ * pairing degrades to what linking there did before rather than erroring.
+ *
+ * `window.location.href` rather than a configured home URL: the point is to
+ * come back to the page they left, and only the browser knows which one that
+ * is.
+ */
+export declare function connectPortalUrl(appUrl: string, clientId: string, path: string): string;
+/**
+ * `connectPortalUrl`, with `appUrl`/`clientId` read from the provider instead
+ * of threaded through by every caller.
+ */
+export declare function useConnectPortalUrl(path: string): string;

package/dist/types/client/use-scheduling.d.ts

@@ -1,4 +1,4 @@
-import type { BookableEventType, Booking, BookingAttendee } from "../types.js";
+import type { AvailabilitySchedule, BookableEventType, Booking, BookingAttendee, WeeklyHours } from "../types.js";
 /**
  * The bridge's scheduling surface, as hooks.
  *
@@ -14,6 +14,54 @@ export declare function useBookableEventTypes(): {
     isLoading: boolean;
     error: string | null;
 };
+/**
+ * The working-hours templates an appointment type can point at.
+ *
+ * Read this before offering a "set up availability" step - a workspace that
+ * already has one does not need a second "Working hours" from your UI.
+ */
+export declare function useAvailabilitySchedules(): {
+    schedules: AvailabilitySchedule[];
+    isLoading: boolean;
+    error: string | null;
+};
+/**
+ * Gives a workspace its first working hours.
+ *
+ * **Not optimistic** - same posture as `useBookingActions`: this is one of
+ * the two writes a host's first-run setup makes, and a modal that closes on
+ * a failed create is worse than one that stays open with the reason shown.
+ */
+export declare function useCreateAvailabilitySchedule(): BookingActionsState & {
+    createSchedule(input: {
+        name: string;
+        timezone: string;
+        weeklyHours: WeeklyHours;
+    }): Promise<AvailabilitySchedule | null>;
+};
+/**
+ * Creates the first thing a workspace can be booked for.
+ *
+ * Host is a specific member, never a team - there is no groups read in this
+ * bridge, so a round-robin team host stays a Console-only capability
+ * reachable by following "Manage in Connect".
+ */
+export declare function useCreateEventType(): BookingActionsState & {
+    createEventType(input: {
+        name: string;
+        description?: string | null;
+        durationMinutes: number;
+        bufferBeforeMinutes?: number;
+        bufferAfterMinutes?: number;
+        hostMemberId: string;
+        scheduleId: string;
+        location: {
+            kind: "phone" | "address" | "link";
+            value?: string | null;
+        };
+        publicBookingEnabled?: boolean;
+    }): Promise<BookableEventType | null>;
+};
 export interface SlotQuery {
     eventTypeId: string;
     from: Date;

package/dist/types/server/client.d.ts

@@ -138,4 +138,4 @@ export declare class ConnectClient {
     constructor(options: ConnectClientOptions);
 }
 /** Kept in step with `package.json` by `sdk.test.ts`. */
-export declare const SDK_VERSION = "0.37.0";
+export declare const SDK_VERSION = "0.38.0";

package/dist/types/server/http.d.ts

@@ -1,4 +1,15 @@
 export type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+/**
+ * How long a *generating* endpoint may take to send its headers.
+ *
+ * One number, named once, and it is not a guess: it is what
+ * `POST /visitor/chat` and `POST /ai/chat` declare as their `maxDuration` on
+ * the far side. A client bound shorter than the route's own ceiling cannot be
+ * right - it can only abort work Connect is still allowed to be doing - and
+ * the two numbers drifting apart is exactly how a 20s client came to be
+ * fronting a 60s route.
+ */
+export declare const GENERATION_TIMEOUT_MS = 60000;
 export interface RequestSpec {
     /**
      * `PUT` and `DELETE` were added for the store resources. Both are idempotent
@@ -24,6 +35,30 @@ export interface RequestSpec {
      * Also stops `timeoutMs` from applying to the *body*: see `request`.
      */
     raw?: boolean;
+    /**
+     * Override the client's `timeoutMs` for this one call.
+     *
+     * The transport-wide default bounds how long a request may take to *reach*
+     * Connect, and 20 seconds is generous for every endpoint that answers from a
+     * read. It is the wrong bound for a **generating** endpoint, because of how
+     * those are built on the far side: `POST /visitor/chat` holds its response
+     * open until the first delta arrives, deliberately, so that a refusal is
+     * still an ordinary `{error}` envelope with a status rather than an event
+     * inside a stream nobody can change the status of. So "time to headers"
+     * there is time to the model's first token - after up to four tool-calling
+     * steps - and that route declares `maxDuration = 60` precisely because it
+     * can take that long.
+     *
+     * With one 20s number for everything, the client aborted at 20s, the abort
+     * read as `network_error`, and the bridge returned **502 after exactly
+     * 20.0s** on any conversation whose first token took longer - which is every
+     * conversation that starts with a tool call. It is the only route on the
+     * platform that exceeds the default; every other one declares 15 or 20.
+     *
+     * Set it where the endpoint's own `maxDuration` is larger, and nowhere else.
+     * It does not bound the stream once it has started - see the timer below.
+     */
+    timeoutMs?: number;
     signal?: AbortSignal;
     /**
      * Force this request into the retry path even though it is a `POST`.

package/dist/types/server/resources/scheduling.d.ts

@@ -1,5 +1,5 @@
 import { type TransportOptions } from "../http.js";
-import type { BookableEventType, Booking, RescheduledBooking, BookingAttendee, BookingSlots, BookingStatus, ListBookingsPage } from "../../types.js";
+import type { AvailabilitySchedule, BookableEventType, Booking, RescheduledBooking, BookingAttendee, BookingSlots, BookingStatus, ListBookingsPage, WeeklyHours } from "../../types.js";
 /**
  * Present on every method here.
  *
@@ -56,6 +56,48 @@ export interface ListBookingsInput extends ActingAsOption {
     cursor?: string;
     limit?: number;
 }
+export interface ListSchedulesInput extends ActingAsOption {
+    workspaceId: string;
+}
+/**
+ * What `createSchedule` takes - deliberately narrower than Connect's own
+ * Calendar settings form: no date overrides, and never owned by one person.
+ * Anything beyond this is a Console edit, not a second write path to
+ * maintain.
+ */
+export interface CreateScheduleInput extends ActingAsOption {
+    workspaceId: string;
+    name: string;
+    /** Validated against the IANA database server-side, e.g. `"Asia/Kolkata"`. */
+    timezone: string;
+    weeklyHours: WeeklyHours;
+}
+/**
+ * What `createEventType` takes.
+ *
+ * Host is a specific member, never a team - there is no groups read in this
+ * API, so a round-robin team host stays a Console-only capability, reachable
+ * by following "Manage in Connect".
+ */
+export interface CreateEventTypeInput extends ActingAsOption {
+    workspaceId: string;
+    name: string;
+    description?: string | null;
+    /** 5 to 480 minutes. */
+    durationMinutes: number;
+    /** Dead time reserved either side of the meeting. Both default to 5. */
+    bufferBeforeMinutes?: number;
+    bufferAfterMinutes?: number;
+    /** A `ConnectWorkspaceMember.memberId` - see `Booking.hostMemberIds`. */
+    hostMemberId: string;
+    scheduleId: string;
+    location: {
+        kind: "phone" | "address" | "link";
+        value?: string | null;
+    };
+    /** Off by default - most appointment types are booked by your integration or a member, not the public. */
+    publicBookingEnabled?: boolean;
+}
 export interface CreateBookingInput extends ActingAsOption {
     workspaceId: string;
     eventTypeId: string;
@@ -88,6 +130,30 @@ export declare class SchedulingResource {
     constructor(transport: TransportOptions);
     /** What this workspace offers as bookable. Active appointment types only. */
     listEventTypes(workspaceId: string, options?: ActingAsOption): Promise<BookableEventType[]>;
+    /**
+     * The working-hours templates an appointment type can point at.
+     *
+     * Read this before offering to create one - a workspace that already has
+     * hours set does not need a second "Working hours" from your integration.
+     */
+    listSchedules(workspaceId: string, options?: ActingAsOption): Promise<AvailabilitySchedule[]>;
+    /**
+     * Gives a workspace its first working hours.
+     *
+     * Narrower than what the workspace's own Calendar settings can do - no date
+     * overrides, and never owned by one person (`ownerMemberId` stays `null`
+     * server-side). Anything beyond that is a Console edit, not a second write
+     * path for your integration to maintain.
+     */
+    createSchedule(input: CreateScheduleInput): Promise<AvailabilitySchedule>;
+    /**
+     * The first thing a workspace can be booked for.
+     *
+     * Needs a schedule - create or pick one with `listSchedules`/`createSchedule`
+     * first. The slug for a future public booking link is derived from `name`
+     * server-side; you cannot choose one.
+     */
+    createEventType(input: CreateEventTypeInput): Promise<BookableEventType>;
     /**
      * Free times for one appointment type over one window.
      *

package/dist/types/types.d.ts

@@ -2003,6 +2003,33 @@ export interface ListBookingsPage {
     hasMore: boolean;
     totalCount: number;
 }
+/**
+ * One interval within a day, in minutes since midnight - `540` is 9am.
+ */
+export interface WeeklyInterval {
+    startMinute: number;
+    endMinute: number;
+}
+/**
+ * A week of working hours, one entry per weekday - `0` is Sunday. An empty
+ * array means closed that day; every key is required, so "closed on Sunday"
+ * is an array the caller had to mean rather than a key they forgot.
+ */
+export interface WeeklyHours {
+    0: WeeklyInterval[];
+    1: WeeklyInterval[];
+    2: WeeklyInterval[];
+    3: WeeklyInterval[];
+    4: WeeklyInterval[];
+    5: WeeklyInterval[];
+    6: WeeklyInterval[];
+}
+/** A working-hours template an appointment type points at. */
+export interface AvailabilitySchedule {
+    id: string;
+    name: string;
+    timezone: string;
+}
 /**
  * A phone or email on a contact.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmoops/connect-sdk",
-  "version": "0.37.0",
+  "version": "0.38.0",
   "description": "Official server-side SDK for the CosmoOps Connect platform API - Login with Connect, entitlements, billing and metering.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "commonjs",