@teamscala/service-boot 0.23.326 → 0.23.327

package/src/fn-routers/chat-session-router.d.ts

@@ -0,0 +1,219 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * ORPC procedures for the AUTHENTICATED AI-chat conversation lifecycle —
+ * the org+user-keyed sibling of publicGptSessionRouter (which is contact-
+ * linked for anonymous public GPT visitors). One signed-in user chatting
+ * with one agent in one org owns a thread of `conversations` rows; this
+ * router createOrRestore-s the active one, saves turns, archives+news on
+ * clear, lists past threads, and loads a specific thread.
+ *
+ * Identity: the USER is resolved from the ORPC session context (`authed`
+ * middleware → `context.user.id`); the ORGANISATION is supplied by the
+ * client (it is the URL :orgId for org-scoped apps like scala-projects —
+ * the session does not carry it) and VERIFIED — the caller must be a
+ * member of that organisation, else FORBIDDEN. A caller cannot read or
+ * write another user's threads (ownership is user_id) or another org's
+ * (createOrRestore/list are membership-scoped to the supplied org).
+ *
+ * This restores the capability the portal AI chat lost when the June
+ * chat-engine migration severed `usePortalConversationId` + the
+ * `portalConversation` router (capability-named `chatSession` here per
+ * name-by-capability; the host-named orphan was deleted in the same change).
+ *
+ * Persistence model: the chat client owns writes via onMessagesPersist →
+ * saveMessages, and sends clientPersists:true so handle-chat-stream skips its
+ * own persistChatRun (single writer, no double-persist). Verbatim UIMessage
+ * parts are stored in messages.channel_data.parts so multi-step (tool-using)
+ * turns round-trip losslessly (apps/chat.md messages-stored-as-uimessage-verbatim).
+ */
+import * as v from "valibot";
+import { type Context } from "./auth-router.ts";
+export declare const chatSessionRouter: {
+    createOrRestore: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly agentId: v.StringSchema<undefined>;
+        readonly organisationId: v.StringSchema<undefined>;
+        /**
+         * SSR-only: the real user's id, passed by the AiChat serverLoader. The
+         * in-process server client is system-authed (context.user.id === "system"),
+         * so without this the conversation is created under user_id="system" and
+         * the real user's saveMessages hits assertOwns → FORBIDDEN. Only honoured
+         * when the caller is the system user (server-side SSR), never from a
+         * client-side ORPC call.
+         */
+        readonly userId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        conversationId: any;
+        model: any;
+        messages: {
+            id: any;
+            role: any;
+            content: any;
+            parts: unknown[] | undefined;
+            metadata: Record<string, unknown> | undefined;
+            created_at: any;
+            occurred_at: any;
+        }[];
+        tokenTotals: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+        hasMore: boolean;
+    }, {
+        conversationId: any;
+        model: any;
+        messages: {
+            id: any;
+            role: any;
+            content: any;
+            parts: unknown[] | undefined;
+            metadata: Record<string, unknown> | undefined;
+            created_at: any;
+            occurred_at: any;
+        }[];
+        tokenTotals: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+        hasMore: boolean;
+    }>, Record<never, never>, Record<never, never>>;
+    loadEarlier: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly conversationId: v.StringSchema<undefined>;
+        /** Cursor: the occurred_at (ISO) of the oldest currently-loaded message. */
+        readonly before: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, undefined>]>;
+        /** Cap; defaults to RECENT_MESSAGE_LIMIT, clamped to it. */
+        readonly limit: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        messages: {
+            id: any;
+            role: any;
+            content: any;
+            parts: unknown[] | undefined;
+            metadata: Record<string, unknown> | undefined;
+            created_at: any;
+            occurred_at: any;
+        }[];
+        hasMore: boolean;
+    }, {
+        messages: {
+            id: any;
+            role: any;
+            content: any;
+            parts: unknown[] | undefined;
+            metadata: Record<string, unknown> | undefined;
+            created_at: any;
+            occurred_at: any;
+        }[];
+        hasMore: boolean;
+    }>, Record<never, never>, Record<never, never>>;
+    saveMessages: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly conversationId: v.StringSchema<undefined>;
+        readonly messages: v.ArraySchema<v.ObjectSchema<{
+            readonly id: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+            readonly role: v.StringSchema<undefined>;
+            readonly content: v.StringSchema<undefined>;
+            readonly parts: v.OptionalSchema<v.ArraySchema<v.AnySchema, undefined>, undefined>;
+            readonly metadata: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        success: boolean;
+    }, {
+        success: boolean;
+    }>, Record<never, never>, Record<never, never>>;
+    clear: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly conversationId: v.StringSchema<undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        conversationId: any;
+        messages: never[];
+        tokenTotals: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+    }, {
+        conversationId: any;
+        messages: never[];
+        tokenTotals: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+    }>, Record<never, never>, Record<never, never>>;
+    list: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly agentId: v.StringSchema<undefined>;
+        readonly organisationId: v.StringSchema<undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        conversations: any;
+    }, {
+        conversations: any;
+    }>, Record<never, never>, Record<never, never>>;
+    load: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, v.ObjectSchema<{
+        readonly conversationId: v.StringSchema<undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        conversationId: any;
+        messages: {
+            id: any;
+            role: any;
+            content: any;
+            parts: unknown[] | undefined;
+            metadata: Record<string, unknown> | undefined;
+            created_at: any;
+            occurred_at: any;
+        }[];
+        tokenTotals: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+    }, {
+        conversationId: any;
+        messages: {
+            id: any;
+            role: any;
+            content: any;
+            parts: unknown[] | undefined;
+            metadata: Record<string, unknown> | undefined;
+            created_at: any;
+            occurred_at: any;
+        }[];
+        tokenTotals: {
+            inputTokens: number;
+            outputTokens: number;
+        };
+    }>, Record<never, never>, Record<never, never>>;
+};

package/src/fn-routers/email-defaults.d.ts

@@ -0,0 +1 @@
+export declare function getDefaultEmailSender(): Promise<string>;

package/src/fn-routers/email-link-ttl.d.ts

@@ -0,0 +1 @@
+export declare function getEmailLinkTtlMs(): Promise<number>;

package/src/fn-routers/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * Composes auth, tasks, work-items, plans, chat-session, public-gpt-session,
+ * public-agreement, and user-preferences routers into the `fn` namespace and
+ * registers it via registerCustomRouter.
+ * Called at boot by registerFnRouters() — invoked before any ORPC dispatch.
+ *
+ * Also exposes the `regions` namespace on the client /api/rpc mount: a single
+ * `loadPage` procedure (reusing puckPagesRouter.loadFromWebsite) so a client
+ * RegionPageSwap can fetch a region's Puck page on demand and render it into a
+ * slot — the no-reload half of `region-views-are-pages` (every region is a Puck
+ * page; switching a view loads a different page's content). loadById is NOT
+ * exposed (website+path is the client-facing contract, not raw page ids).
+ */
+export declare function registerFnRouters(): void;

package/src/fn-routers/index.ts

@@ -37,7 +37,6 @@ import { tasksRouter } from "./tasks-router.ts";
 import { userPreferencesRouter } from "./user-preferences-router.ts";
 import { userPreferencesRouter as portalPreferencesRouter } from "../page-server-orpc/user-preferences-router.ts";
 import { workItemsRouter } from "./work-items-router.ts";
-import { orchestratorRegistrationRouter } from "./orchestrator-registration-router.ts";
 
 export function registerFnRouters(): void {
 	registerCustomRouter("fn", {
@@ -54,7 +53,6 @@ export function registerFnRouters(): void {
 		tasks: tasksRouter,
 		taskSync: taskSyncRouter,
 		workItems: workItemsRouter,
-		orchestratorRegistration: orchestratorRegistrationRouter,
 		userPreferences: userPreferencesRouter,
 		portalPreferences: portalPreferencesRouter,
 		plans: plansRouter,

package/src/fn-routers/panel-data-router.d.ts

@@ -0,0 +1,19 @@
+import * as v from "valibot";
+interface Context {
+    prisma: {
+        builda_websites: {
+            findFirst: (args: unknown) => Promise<{
+                organisation_id?: string | null;
+            } | null>;
+        };
+    };
+}
+export declare const resolvePanelDataHandler: import("@orpc/server").DecoratedProcedure<Context & Record<never, never>, Context, v.ObjectSchema<{
+    readonly panelSlug: v.StringSchema<undefined>;
+    readonly websiteSlug: v.StringSchema<undefined>;
+    /** Tenant orgId (preferred over the website's organisation_id, which is
+     * the platform org on a multi-tenant portal — not the tenant). The
+     * caller (RegionPageSwap) threads this from __PAGE_DATA__.orgId. */
+    readonly orgId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>, import("@orpc/contract").Schema<Record<string, unknown> | null, Record<string, unknown> | null>, Record<never, never>, Record<never, never>>;
+export {};

package/src/fn-routers/persist-chat-messages.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * The ONE chat-message write surface for the session routers. Both the authed
+ * (chatSession) and public (publicGptSession) saveMessages procedures persist
+ * turns through here — they differ only in IDENTITY/ownership (user_id vs
+ * contact_email, resolved in the router before calling this), never in the
+ * write itself. Keeping the write in two routers was literal duplication
+ * (no-duplicate-canonical-units) and is why the stable-id fix had to be applied
+ * twice.
+ *
+ * Upserts each message on its SDK UIMessage id so a re-save of a turn (a retry,
+ * a reconnect after a network drop, or a stray dual-write) updates the one row
+ * in place instead of inserting a duplicate (chat-message-ids-server-stable);
+ * falls back to create only for legacy id-less callers. occurred_at is stamped
+ * with a 1ms step preserving array order so same-second saves restore in order.
+ */
+export interface ChatMessageInput {
+    id?: string;
+    role: string;
+    content: string;
+    parts?: unknown[];
+    /** The SDK UIMessage `metadata` — carries per-message token usage
+     * (`inputTokens`/`outputTokens`/`contextWindow`/`model`) the stream attaches
+     * via `messageMetadata`. Persisted so the context-usage gauge can rehydrate
+     * on reload and budget-enforcement can read per-message token counts; without
+     * it the save dropped the usage and the gauge came back blank on refresh. */
+    metadata?: Record<string, unknown> | null;
+}
+export declare function persistChatMessages(prisma: any, opts: {
+    conversationId: string;
+    organisationId: string | null;
+    messages: ChatMessageInput[];
+}): Promise<void>;

package/src/fn-routers/plans-router.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * ORPC procedures for plan creation with tasks and subtasks.
+ * Extracted from @teamscala/orpc/fn-router — primitives tier must not
+ * contain application-specific work_items logic.
+ */
+import { type Context } from "./auth-router.ts";
+export declare const plansRouter: {
+    save: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<import("./auth-router.ts").User | null>;
+        prisma: any;
+        user: import("./auth-router.ts").User;
+        orgId: string | null | undefined;
+    }>, import("@orpc/contract").Schema<unknown, unknown>, import("@orpc/contract").Schema<{
+        success: boolean;
+        data: any;
+    }, {
+        success: boolean;
+        data: any;
+    }>, Record<never, never>, Record<never, never>>;
+};

package/src/fn-routers/proposal-send-router.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @system service-boot
+ * @status handwritten
+ * @edit edit directly
+ *
+ * The proposal SEND router — the proposal twin of agreement-send-router. An
+ * authed portal caller POSTs {proposalId, baseUrl} to email the proposal's CRM
+ * contact a per-recipient magic-link (no email gate, no OTP — see
+ * attach-proposal-magic.ts) to view their proposal. Resend-backed.
+ */
+import * as v from "valibot";
+interface User {
+    id: string;
+    organisationId: string | null;
+}
+interface Context {
+    user: User | null | undefined;
+    headers: Headers;
+    resolveUser?: (headers: Headers, prisma: any) => Promise<User | null>;
+    prisma: any;
+}
+export declare const proposalSendRouter: {
+    send: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<Context & Record<never, never>, Context, Context>, import("@orpc/server").MergedCurrentContext<Context, {
+        headers: Headers;
+        resolveUser?: (headers: Headers, prisma: any) => Promise<User | null>;
+        prisma: any;
+        user: User;
+    }>, v.ObjectSchema<{
+        readonly proposalId: v.StringSchema<undefined>;
+        /** Public base URL of the proposals site, e.g. https://proposals-dev.scala.business (no trailing slash). */
+        readonly baseUrl: v.StringSchema<undefined>;
+    }, undefined>, import("@orpc/contract").Schema<{
+        ok: false;
+        error: string;
+        sentAt?: undefined;
+        url?: undefined;
+        email?: undefined;
+    } | {
+        error?: undefined;
+        ok: true;
+        sentAt: string;
+        url: string;
+        email: string;
+    }, {
+        ok: false;
+        error: string;
+        sentAt?: undefined;
+        url?: undefined;
+        email?: undefined;
+    } | {
+        error?: undefined;
+        ok: true;
+        sentAt: string;
+        url: string;
+        email: string;
+    }>, Record<never, never>, Record<never, never>>;
+};
+export {};