@hailer/mcp 1.2.1 → 2.0.0-beta.1

package/dist/public-chat/knowledge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"knowledge.js","sourceRoot":"","sources":["../../src/public-chat/knowledge.ts"],"names":[],"mappings":";AAAA,yEAAyE;AACzE,iEAAiE;AACjE,EAAE;AACF,oBAAoB;AACpB,oCAAoC;;;AAEvB,QAAA,uBAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgzCtC,CAAC;AAEW,QAAA,sBAAsB,GAAG,+BAAuB,CAAC,MAAM,CAAC"}

package/dist/public-chat/rate-limit.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Simple in-memory IP rate limiter for the public chat endpoint.
+ *
+ * Sliding window: each IP gets `LIMIT` requests per `WINDOW_MS`. Older
+ * timestamps fall out of the window naturally. Good enough for a prototype on
+ * a single instance; swap for Redis if we ever run multiple replicas.
+ */
+export interface RateCheck {
+    ok: boolean;
+    remaining: number;
+    retryAfterSec?: number;
+}
+export declare function checkRate(ip: string, limit?: number): RateCheck;
+/** Test-only — clears all rate-limit state. */
+export declare function _resetForTests(): void;
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/public-chat/rate-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../src/public-chat/rate-limit.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAyBH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,OAAO,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,GAAE,MAAc,GAAG,SAAS,CAgBtE;AAED,+CAA+C;AAC/C,wBAAgB,cAAc,IAAI,IAAI,CAGrC"}

package/dist/public-chat/rate-limit.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Simple in-memory IP rate limiter for the public chat endpoint.
+ *
+ * Sliding window: each IP gets `LIMIT` requests per `WINDOW_MS`. Older
+ * timestamps fall out of the window naturally. Good enough for a prototype on
+ * a single instance; swap for Redis if we ever run multiple replicas.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRate = checkRate;
+exports._resetForTests = _resetForTests;
+const WINDOW_MS = 60 * 60 * 1000; // 1 hour
+const LIMIT = 30; // requests per IP per hour
+const buckets = new Map();
+let lastSweep = Date.now();
+const SWEEP_INTERVAL_MS = 5 * 60 * 1000; // 5 min
+function sweep(now) {
+    if (now - lastSweep < SWEEP_INTERVAL_MS)
+        return;
+    lastSweep = now;
+    for (const [ip, hits] of buckets) {
+        const fresh = hits.filter((t) => now - t < WINDOW_MS);
+        if (fresh.length === 0) {
+            buckets.delete(ip);
+            continue;
+        }
+        if (fresh.length !== hits.length) {
+            buckets.set(ip, fresh);
+        }
+    }
+}
+function checkRate(ip, limit = LIMIT) {
+    const now = Date.now();
+    sweep(now);
+    const hits = buckets.get(ip) ?? [];
+    const fresh = hits.filter((t) => now - t < WINDOW_MS);
+    if (fresh.length >= limit) {
+        const oldest = Math.min(...fresh);
+        const retryAfterSec = Math.ceil((WINDOW_MS - (now - oldest)) / 1000);
+        return { ok: false, remaining: 0, retryAfterSec };
+    }
+    fresh.push(now);
+    buckets.set(ip, fresh);
+    return { ok: true, remaining: limit - fresh.length };
+}
+/** Test-only — clears all rate-limit state. */
+function _resetForTests() {
+    buckets.clear();
+    lastSweep = Date.now();
+}
+//# sourceMappingURL=rate-limit.js.map

package/dist/public-chat/rate-limit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.js","sourceRoot":"","sources":["../../src/public-chat/rate-limit.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AA+BH,8BAgBC;AAGD,wCAGC;AAnDD,MAAM,SAAS,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,SAAS;AAC3C,MAAM,KAAK,GAAG,EAAE,CAAC,CAAkB,2BAA2B;AAE9D,MAAM,OAAO,GAAG,IAAI,GAAG,EAAoB,CAAC;AAE5C,IAAI,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;AAC3B,MAAM,iBAAiB,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,QAAQ;AAEjD,SAAS,KAAK,CAAC,GAAW;IACxB,IAAI,GAAG,GAAG,SAAS,GAAG,iBAAiB;QAAE,OAAO;IAChD,SAAS,GAAG,GAAG,CAAC;IAChB,KAAK,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,OAAO,EAAE,CAAC;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC;QACtD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACnB,SAAS;QACX,CAAC;QACD,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC;YACjC,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;AACH,CAAC;AAQD,SAAgB,SAAS,CAAC,EAAU,EAAE,QAAgB,KAAK;IACzD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,KAAK,CAAC,GAAG,CAAC,CAAC;IAEX,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC;IACnC,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,SAAS,CAAC,CAAC;IAEtD,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,EAAE,CAAC;QAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;QAClC,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,SAAS,GAAG,CAAC,GAAG,GAAG,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QACrE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC;IACpD,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAChB,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IACvB,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;AACvD,CAAC;AAED,+CAA+C;AAC/C,SAAgB,cAAc;IAC5B,OAAO,CAAC,KAAK,EAAE,CAAC;IAChB,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;AACzB,CAAC"}

package/dist/public-chat/session-store.d.ts

@@ -0,0 +1,41 @@
+/**
+ * In-memory chat history store keyed by client-generated sessionId.
+ *
+ * Scope — this is for CLIENT CONVENIENCE ONLY:
+ * - The chat handler does NOT consult this store when shaping the prompt;
+ *   it trusts the client-supplied `history` field on each POST. The store
+ *   only exists so the `/api/public-chat/history` GET can return prior
+ *   turns when a visitor reloads the demo (or later signs in) and the
+ *   client's localStorage is gone.
+ * - As a corollary, a client that fabricates `history` only spoofs its own
+ *   prompt context — it cannot poison anyone else's session.
+ *
+ * Trade-offs for the prototype:
+ * - In-memory only. A server restart wipes everything. Fine for a demo;
+ *   a follow-up can swap this for Redis or Mongo with no call-surface
+ *   change.
+ * - TTL'd: entries are dropped after PUBLIC_CHAT_SESSION_TTL_MS of inactivity.
+ * - Bounded: at most PUBLIC_CHAT_SESSION_MAX_SESSIONS sessions; evicts the
+ *   least-recently-updated when full. Per-session turn cap is enforced too.
+ */
+export interface StoredTurn {
+    role: 'user' | 'assistant';
+    content: string;
+    at: number;
+}
+export declare class PublicChatSessionStore {
+    private sessions;
+    /** Append a user/assistant exchange to the session. Creates the session if needed. */
+    append(sessionId: string, userText: string, assistantText: string): void;
+    /** Returns stored turns for a session, or null if unknown / expired. */
+    get(sessionId: string): StoredTurn[] | null;
+    /** Removes a session entirely (e.g., visitor clicked Reset). */
+    clear(sessionId: string): void;
+    /** Test/debug helper. */
+    size(): number;
+    private evictExpired;
+    private evictOldest;
+}
+/** Singleton used by the public-chat route. */
+export declare const publicChatSessionStore: PublicChatSessionStore;
+//# sourceMappingURL=session-store.d.ts.map

package/dist/public-chat/session-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-store.d.ts","sourceRoot":"","sources":["../../src/public-chat/session-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;CACZ;AAaD,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAoC;IAEpD,sFAAsF;IACtF,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,IAAI;IAyBxE,wEAAwE;IACxE,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU,EAAE,GAAG,IAAI;IAO3C,gEAAgE;IAChE,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAI9B,yBAAyB;IACzB,IAAI,IAAI,MAAM;IAId,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,WAAW;CAapB;AAED,+CAA+C;AAC/C,eAAO,MAAM,sBAAsB,wBAA+B,CAAC"}

package/dist/public-chat/session-store.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * In-memory chat history store keyed by client-generated sessionId.
+ *
+ * Scope — this is for CLIENT CONVENIENCE ONLY:
+ * - The chat handler does NOT consult this store when shaping the prompt;
+ *   it trusts the client-supplied `history` field on each POST. The store
+ *   only exists so the `/api/public-chat/history` GET can return prior
+ *   turns when a visitor reloads the demo (or later signs in) and the
+ *   client's localStorage is gone.
+ * - As a corollary, a client that fabricates `history` only spoofs its own
+ *   prompt context — it cannot poison anyone else's session.
+ *
+ * Trade-offs for the prototype:
+ * - In-memory only. A server restart wipes everything. Fine for a demo;
+ *   a follow-up can swap this for Redis or Mongo with no call-surface
+ *   change.
+ * - TTL'd: entries are dropped after PUBLIC_CHAT_SESSION_TTL_MS of inactivity.
+ * - Bounded: at most PUBLIC_CHAT_SESSION_MAX_SESSIONS sessions; evicts the
+ *   least-recently-updated when full. Per-session turn cap is enforced too.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicChatSessionStore = exports.PublicChatSessionStore = void 0;
+const PUBLIC_CHAT_SESSION_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const PUBLIC_CHAT_SESSION_MAX_SESSIONS = 1000;
+const PUBLIC_CHAT_SESSION_MAX_TURNS = 50;
+class PublicChatSessionStore {
+    sessions = new Map();
+    /** Append a user/assistant exchange to the session. Creates the session if needed. */
+    append(sessionId, userText, assistantText) {
+        this.evictExpired();
+        let session = this.sessions.get(sessionId);
+        if (!session) {
+            if (this.sessions.size >= PUBLIC_CHAT_SESSION_MAX_SESSIONS) {
+                this.evictOldest();
+            }
+            const now = Date.now();
+            session = {
+                sessionId,
+                turns: [],
+                createdAt: now,
+                updatedAt: now,
+            };
+            this.sessions.set(sessionId, session);
+        }
+        const now = Date.now();
+        session.turns.push({ role: 'user', content: userText, at: now });
+        session.turns.push({ role: 'assistant', content: assistantText, at: now });
+        if (session.turns.length > PUBLIC_CHAT_SESSION_MAX_TURNS) {
+            session.turns = session.turns.slice(-PUBLIC_CHAT_SESSION_MAX_TURNS);
+        }
+        session.updatedAt = now;
+    }
+    /** Returns stored turns for a session, or null if unknown / expired. */
+    get(sessionId) {
+        this.evictExpired();
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return null;
+        return session.turns;
+    }
+    /** Removes a session entirely (e.g., visitor clicked Reset). */
+    clear(sessionId) {
+        this.sessions.delete(sessionId);
+    }
+    /** Test/debug helper. */
+    size() {
+        return this.sessions.size;
+    }
+    evictExpired() {
+        const now = Date.now();
+        for (const [id, s] of this.sessions) {
+            if (now - s.updatedAt > PUBLIC_CHAT_SESSION_TTL_MS) {
+                this.sessions.delete(id);
+            }
+        }
+    }
+    evictOldest() {
+        let oldestId = null;
+        let oldestUpdatedAt = Infinity;
+        for (const [id, s] of this.sessions) {
+            if (s.updatedAt < oldestUpdatedAt) {
+                oldestUpdatedAt = s.updatedAt;
+                oldestId = id;
+            }
+        }
+        if (oldestId !== null) {
+            this.sessions.delete(oldestId);
+        }
+    }
+}
+exports.PublicChatSessionStore = PublicChatSessionStore;
+/** Singleton used by the public-chat route. */
+exports.publicChatSessionStore = new PublicChatSessionStore();
+//# sourceMappingURL=session-store.js.map

package/dist/public-chat/session-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-store.js","sourceRoot":"","sources":["../../src/public-chat/session-store.ts"],"names":[],"mappings":"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"}

package/dist/public-chat/studio-prewarm.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Studio session pre-warm (headless).
+ *
+ * On graduation, mcp-server creates a one-shot Hailer Studio "builder"
+ * session for the freshly-provisioned workspace via a single
+ * server-to-server POST to Studio's headless endpoint:
+ *
+ *   POST {STUDIO_SESSIONS_CREATE_URL}
+ *   headers: { content-type: application/json, hlrkey: <apiKey> }
+ *   body: { apiKey, workspaceId, systemMessage?, initialPrompt? }
+ *
+ * `apiKey` + `workspaceId` are required; `systemMessage` + `initialPrompt`
+ * are optional. When we have demo context we send both: a fixed
+ * autonomous-builder `systemMessage` (Studio persona) plus an
+ * `initialPrompt` derived from the visitor's demo conversation — Studio
+ * then builds the whole workspace + app UI one-shot, and the session is
+ * waiting in the user's Studio session list when they land there.
+ *
+ * The endpoint does not return a session id yet, so the frontend lands the
+ * visitor in the Studio app generally rather than deep-linking a specific
+ * session. When/if an id is returned, pass it forward for a precise link.
+ *
+ * Fire-and-forget from the caller's perspective. Errors are logged; no
+ * exception escapes.
+ */
+/**
+ * Fixed Studio persona for graduation-created sessions: an autonomous
+ * workspace builder that turns a single brief into a complete workspace +
+ * app with no further input. Paired with an `initialPrompt`; only sent when
+ * we have a brief to give it (otherwise Studio runs its default behaviour).
+ */
+export declare const STUDIO_BUILDER_SYSTEM_MESSAGE: string;
+interface CreateStudioSessionParams {
+    apiKey: string;
+    workspaceId: string;
+    systemMessage?: string;
+    initialPrompt?: string;
+}
+/**
+ * Create the headless Studio session. Resolves once Studio has accepted the
+ * create request (the one-shot build then runs server-side). Never throws —
+ * a failed prewarm leaves the graduated workspace + bot intact; the user can
+ * still start a Studio session manually.
+ */
+export declare function createStudioSession(params: CreateStudioSessionParams): Promise<void>;
+/**
+ * Build the `initialPrompt` (the one-shot build brief) from the demo
+ * conversation. The visitor told the demo bot what they want; we hand that
+ * to Studio's autonomous builder so it continues the same intent in a real
+ * workspace. Returns `undefined` when there's nothing to build from — the
+ * caller then sends neither prompt and Studio runs its default session.
+ */
+export declare function buildStudioInitialPrompt(turns: ReadonlyArray<{
+    role: 'user' | 'assistant';
+    content: string;
+}>, viewedSlides?: ReadonlyArray<string>, opts?: {
+    helperBotUserId?: string;
+    helperBotActivityId?: string;
+}): string | undefined;
+export {};
+//# sourceMappingURL=studio-prewarm.d.ts.map

package/dist/public-chat/studio-prewarm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"studio-prewarm.d.ts","sourceRoot":"","sources":["../../src/public-chat/studio-prewarm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAUH;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,QAO5B,CAAC;AAEf,UAAU,yBAAyB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgD1F;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACpC,KAAK,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,EACrE,YAAY,GAAE,aAAa,CAAC,MAAM,CAAM,EACxC,IAAI,GAAE;IAAE,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAAO,GACtE,MAAM,GAAG,SAAS,CAsDpB"}

package/dist/public-chat/studio-prewarm.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * Studio session pre-warm (headless).
+ *
+ * On graduation, mcp-server creates a one-shot Hailer Studio "builder"
+ * session for the freshly-provisioned workspace via a single
+ * server-to-server POST to Studio's headless endpoint:
+ *
+ *   POST {STUDIO_SESSIONS_CREATE_URL}
+ *   headers: { content-type: application/json, hlrkey: <apiKey> }
+ *   body: { apiKey, workspaceId, systemMessage?, initialPrompt? }
+ *
+ * `apiKey` + `workspaceId` are required; `systemMessage` + `initialPrompt`
+ * are optional. When we have demo context we send both: a fixed
+ * autonomous-builder `systemMessage` (Studio persona) plus an
+ * `initialPrompt` derived from the visitor's demo conversation — Studio
+ * then builds the whole workspace + app UI one-shot, and the session is
+ * waiting in the user's Studio session list when they land there.
+ *
+ * The endpoint does not return a session id yet, so the frontend lands the
+ * visitor in the Studio app generally rather than deep-linking a specific
+ * session. When/if an id is returned, pass it forward for a precise link.
+ *
+ * Fire-and-forget from the caller's perspective. Errors are logged; no
+ * exception escapes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STUDIO_BUILDER_SYSTEM_MESSAGE = void 0;
+exports.createStudioSession = createStudioSession;
+exports.buildStudioInitialPrompt = buildStudioInitialPrompt;
+const logger_1 = require("../lib/logger");
+const config_1 = require("../config");
+const auth_1 = require("../mcp/auth");
+const logger = (0, logger_1.createLogger)({ component: 'studio-prewarm' });
+const POST_REQUEST_TIMEOUT_MS = 30000;
+/**
+ * Fixed Studio persona for graduation-created sessions: an autonomous
+ * workspace builder that turns a single brief into a complete workspace +
+ * app with no further input. Paired with an `initialPrompt`; only sent when
+ * we have a brief to give it (otherwise Studio runs its default behaviour).
+ */
+exports.STUDIO_BUILDER_SYSTEM_MESSAGE = [
+    "You are Hailer Studio's autonomous workspace builder. Your working directory is ALREADY a fully initialized, authenticated @hailer/sdk project for the target workspace: `@hailer/sdk init` has run, `npm install` is done, and `npm run pull` has populated `workspace/` with the workspace's current configuration. Turn a single natural-language brief into a complete, working Hailer workspace — workflows, fields, phases, sample data, and a custom app UI — with no further input.",
+    "# Division of labour (IMPORTANT)\n- Workspace STRUCTURE (workflows, fields, phases, teams, groups, insights, templates) is managed AS CODE with the @hailer/sdk CLI via this project's npm scripts. Edit the TypeScript files under `workspace/` and push them. Do NOT create structure through MCP.\n- The APP UI is scaffolded with @hailer/create-app, built against @hailer/app-sdk, and published with the project's publish script. Do NOT build app structure through MCP.\n- The Hailer MCP tools are for LIVE DATA only — seeding sample activities (create_activity) and quick reads (list_workflows, list_activities) to verify your work.",
+    "# Hailer mental model\n- Workflow (process): a pipeline with PHASES (stages) and FIELDS (typed columns).\n- Activity: one record flowing through a workflow's phases.\n- Field types: text, textarea, number, money, date, dropdown (textpredefinedoptions), checkbox, user/member, activitylink (a relation to another workflow's activities), and function (computed, e.g. line totals).\n- App: a React UI (@hailer/app-sdk) that reads/writes activities across your workflows.",
+    "# Hard rules\n1. NEVER ask the user questions — interactive prompts are denied. When the brief is ambiguous, choose sensible defaults and state every assumption in your final summary. Always pass --force / non-interactive flags to CLI commands.\n2. Begin by reading current state: `npm run pull`, then read `workspace/workflows.ts`, `workspace/enums.ts`, and any existing `workspace/<Workflow>_<id>/` files. Reuse what fits; do not duplicate existing workflows.\n3. A field is INVISIBLE in activities until its ID is listed in the phase's `fields` array. After creating fields you MUST add their IDs to the right phase(s) and push phases.\n4. Follow the SDK ordering, and re-pull after each step to pick up server-generated IDs:\na. New workflow: add an entry WITHOUT `_id` to `workspace/workflows.ts` → `npm run workflows-sync` → `npm run pull` (generates the `WorkflowName_id/` folder).\nb. Fields: edit `workspace/<Workflow>_<id>/fields.ts` → `npm run fields-push` → `npm run pull`.\nc. Phases: edit `phases.ts`, add each new field ID to the phase `fields` arrays → `npm run phases-push` → `npm run pull`. Reference IDs through `enums.ts`, never hand-typed hex. Use activitylink fields for relations instead of duplicating data.\n5. If a push fails, read the error, fix the TypeScript, and retry — never silently skip.",
+    "# Building the app (@hailer/create-app)\n1. Scaffold non-interactively: `npm create @hailer/app@latest <app-name> --template react-ts`, then `cd <app-name> && npm install`.\n2. Build the UI with @hailer/app-sdk: use the `useApp()` hook, read workflows/activities (e.g. `hailer.activity.list(...)`), and reference fields by KEY via the generated field-resolver so the app stays workspace-portable. Admin-configurable settings go in `public/manifest.json` under `config.fields`.\n3. Publish with the project's publish script for THIS environment, creating the app on first publish, e.g.:\nnpm run publish-<env> -- --create --app-name '<App Name>' --user-api-key <key> --force\nThe user API key and target API URL are in the project's `.env` / config — read them and pick the `publish-<env>` script whose API URL matches this workspace. The tool writes the new `appId` back into `manifest.json`.",
+    "# Finish\nEnd with a concise summary of what you built: the workflows/fields/phases you created, the app and what it does and where it's published, and every assumption you made. Work autonomously from start to finish. Quality and completeness matter more than speed.",
+].join('\n\n');
+/**
+ * Create the headless Studio session. Resolves once Studio has accepted the
+ * create request (the one-shot build then runs server-side). Never throws —
+ * a failed prewarm leaves the graduated workspace + bot intact; the user can
+ * still start a Studio session manually.
+ */
+async function createStudioSession(params) {
+    const url = config_1.environment.STUDIO_SESSIONS_CREATE_URL;
+    if (!url) {
+        logger.debug('STUDIO_SESSIONS_CREATE_URL not set; skipping Studio session create');
+        return;
+    }
+    const { apiKey, workspaceId, systemMessage, initialPrompt } = params;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), POST_REQUEST_TIMEOUT_MS);
+    try {
+        const body = { apiKey, workspaceId };
+        if (systemMessage) {
+            body.systemMessage = systemMessage;
+        }
+        if (initialPrompt) {
+            body.initialPrompt = initialPrompt;
+        }
+        // safeFetch (not raw fetch) so a self-signed cert on a local cluster
+        // (*.local.gd, NODE_ENV=development) is accepted — same path the rest
+        // of the mcp REST calls use.
+        const res = await (0, auth_1.safeFetch)(url, {
+            method: 'POST',
+            redirect: 'manual',
+            // hlrkey carries the user apiKey; Studio accepts hlrkey or
+            // Authorization for this server-to-server call. No Origin needed.
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            headers: { 'content-type': 'application/json', hlrkey: apiKey },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        if (res.status >= 400) {
+            const text = await res.text().catch(() => '');
+            throw new Error(`Studio /api/sessions/create returned ${res.status}: ${text.slice(0, 240)}`);
+        }
+        logger.info('Studio session created', {
+            workspaceId,
+            status: res.status,
+            hasSystemMessage: !!systemMessage,
+            hasInitialPrompt: !!initialPrompt,
+        });
+    }
+    catch (err) {
+        logger.error('Studio session create failed', {
+            workspaceId, err: err instanceof Error ? err.message : String(err),
+        });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Build the `initialPrompt` (the one-shot build brief) from the demo
+ * conversation. The visitor told the demo bot what they want; we hand that
+ * to Studio's autonomous builder so it continues the same intent in a real
+ * workspace. Returns `undefined` when there's nothing to build from — the
+ * caller then sends neither prompt and Studio runs its default session.
+ */
+function buildStudioInitialPrompt(turns, viewedSlides = [], opts = {}) {
+    const conversation = turns
+        .map(turn => {
+        const speaker = turn.role === 'user' ? 'Visitor' : 'Hailer Helper';
+        const text = turn.content.replace(/\s+/g, ' ').trim();
+        return text ? `${speaker}: ${text}` : '';
+    })
+        .filter(Boolean)
+        .join('\n');
+    if (!conversation && viewedSlides.length === 0) {
+        return undefined;
+    }
+    const parts = [
+        'A potential customer just finished an interactive Hailer demo and chose to continue building in their own workspace. '
+            + 'Based on what they described, build a complete, working Hailer workspace end-to-end — workflows, fields, phases, '
+            + 'sample data, and a custom app UI — and assume sensible defaults where the brief is ambiguous.',
+    ];
+    if (conversation) {
+        parts.push(`Here is the demo conversation that captures what they want:\n\n${conversation}`);
+    }
+    if (viewedSlides.length > 0) {
+        parts.push(`During the demo they explored these areas of Hailer: ${viewedSlides.join(', ')}.`);
+    }
+    parts.push('Infer the business and the use-case they care about, then deliver a polished result: relate records with '
+        + 'activitylink fields, seed a few realistic sample activities, and build an app UI that makes the workflow useful '
+        + 'from day one. When done, post a concise summary of what you built and the assumptions you made.');
+    // Hand the visitor back to the Hailer Helper bot once the build is done.
+    // Only emit this when the bot actually provisioned (its user id is known)
+    // and we have its activity id to locate the discussion — otherwise there's
+    // no reliable channel to reach it. The Helper bot is reactive (it never
+    // initiates), so this triggering message is what gets it to offer a tour.
+    // You run as the workspace owner, so a message you post is authored BY the
+    // user — write it in the first person so the Helper replies to them.
+    if (opts.helperBotUserId && opts.helperBotActivityId) {
+        parts.push(`As soon as you have finished the workspace structure and data — the workflows, fields, phases, and the seeded `
+            + `sample activities (the datasets) — and BEFORE you move on to building the app UI, hand the user back to their `
+            + `Hailer Helper assistant for a guided tour. Do this at that point, not at the very end, so they can start `
+            + `exploring the workflows while you keep building the app. The Helper bot only responds when messaged, so you `
+            + `must message it: resolve the Helper bot's activity (activity id ${opts.helperBotActivityId}) to its discussion `
+            + `— e.g. show_activity_by_id returns the activity's discussion id, or find it via list_my_discussions — then use `
+            + `add_discussion_message to post ONE short message into that discussion. You are acting as the workspace owner, `
+            + `so write it in the FIRST PERSON as them, e.g.: "Thanks — the workflows and data are all set up. Can you give `
+            + `me a quick guided tour of what's here?" That message will reach the Helper bot (Hailer user id `
+            + `${opts.helperBotUserId}) and prompt it to offer the tour. Do not describe the build in that message — keep it `
+            + `to a one- or two-sentence tour request. After sending it, continue building the app UI and finish with your `
+            + `usual summary.`);
+    }
+    return parts.join('\n\n');
+}
+//# sourceMappingURL=studio-prewarm.js.map

package/dist/public-chat/studio-prewarm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"studio-prewarm.js","sourceRoot":"","sources":["../../src/public-chat/studio-prewarm.ts"],"names":[],"mappings":"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"}

package/dist/public-chat/system-prompt.d.ts

@@ -0,0 +1,22 @@
+/**
+ * System-prompt builder for the public (login-page) chatbot.
+ *
+ * The prompt is layered into three text blocks so we can mark the static
+ * portions as cached for Anthropic's prompt cache:
+ *  1. Persona + instructions  (small, cached)
+ *  2. Bot-action protocol     (cached)
+ *  3. Knowledge corpus        (large, cached)
+ *
+ * Only the user message changes per request; everything in `system` is reused
+ * across requests in the cache window.
+ */
+export interface SystemPromptBlock {
+    type: 'text';
+    text: string;
+    cache_control?: {
+        type: 'ephemeral';
+    };
+}
+export declare function buildPublicChatSystem(): SystemPromptBlock[];
+export declare const KNOWLEDGE_BYTES: number;
+//# sourceMappingURL=system-prompt.d.ts.map

package/dist/public-chat/system-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-prompt.d.ts","sourceRoot":"","sources":["../../src/public-chat/system-prompt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE;QAAE,IAAI,EAAE,WAAW,CAAA;KAAE,CAAC;CACvC;AA4ZD,wBAAgB,qBAAqB,IAAI,iBAAiB,EAAE,CAE3D;AAED,eAAO,MAAM,eAAe,QAAyB,CAAC"}