@data-club/ai-hub-server 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Public entry point for `@data-club/ai-hub-server`.
+ *
+ * Step 2 ships:
+ *
+ * - `createFetchHandler({...})` — the canonical Web-Standard Fetch entry point.
+ * - `createNextRouteHandler({...})` — first-class Next.js App Router adapter.
+ * - `bootServer({...})` — convenience: env → DB → migrate → seed → handler.
+ * - The shared types re-exported from `@data-club/ai-hub`.
+ *
+ * Subsequent steps add: full `/auth/*` + role middleware (Step 3), `/admin/*`
+ * + `/sessions` + `/agents` + `/metrics` (Step 4), Letta integration + `/chat`
+ * SSE (Step 5), TPM recovery (Step 6).
+ *
+ * @see SPECIFICATIONS.md §6 — server responsibilities
+ * @see SPECIFICATIONS.md §6.2 — stack
+ * @see docs/IMPLEMENTATION_PLAN.md — step-by-step delivery schedule
+ */
+export type { AIHubRole, AIHubUser, Session, AIHubMessage, TurnStatus, RunningPhase, AIHubState, AIHubEventState, AIHubEvent, AIHubError, } from "@data-club/ai-hub";
+export { createFetchHandler, type CreateFetchHandlerOptions, type FetchHandler, } from "./handlers/fetch.js";
+export { createNextRouteHandler } from "./handlers/nextjs.js";
+export { bootServer, parseEnvConfig, type BootServerOptions, type BootedServer, type EnvConfig, type EnvLike, } from "./bootstrap.js";
+export { SUPER_ADMIN_SEED_PASSWORD, SUPER_ADMIN_SEED_USERNAME, } from "./db/seed.js";
+export { createDefaultLettaClient, type CreateLettaClientDeps, type LettaClient, type StreamUserMessageOpts, } from "./letta/client.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,YAAY,EACV,SAAS,EACT,SAAS,EACT,OAAO,EACP,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,UAAU,EACV,eAAe,EACf,UAAU,EACV,UAAU,GACX,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,kBAAkB,EAClB,KAAK,yBAAyB,EAC9B,KAAK,YAAY,GAClB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,OAAO,GACb,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,wBAAwB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,WAAW,EAChB,KAAK,qBAAqB,GAC3B,MAAM,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,24 @@
+/**
+ * Public entry point for `@data-club/ai-hub-server`.
+ *
+ * Step 2 ships:
+ *
+ * - `createFetchHandler({...})` — the canonical Web-Standard Fetch entry point.
+ * - `createNextRouteHandler({...})` — first-class Next.js App Router adapter.
+ * - `bootServer({...})` — convenience: env → DB → migrate → seed → handler.
+ * - The shared types re-exported from `@data-club/ai-hub`.
+ *
+ * Subsequent steps add: full `/auth/*` + role middleware (Step 3), `/admin/*`
+ * + `/sessions` + `/agents` + `/metrics` (Step 4), Letta integration + `/chat`
+ * SSE (Step 5), TPM recovery (Step 6).
+ *
+ * @see SPECIFICATIONS.md §6 — server responsibilities
+ * @see SPECIFICATIONS.md §6.2 — stack
+ * @see docs/IMPLEMENTATION_PLAN.md — step-by-step delivery schedule
+ */
+export { createFetchHandler, } from "./handlers/fetch.js";
+export { createNextRouteHandler } from "./handlers/nextjs.js";
+export { bootServer, parseEnvConfig, } from "./bootstrap.js";
+export { SUPER_ADMIN_SEED_PASSWORD, SUPER_ADMIN_SEED_USERNAME, } from "./db/seed.js";
+export { createDefaultLettaClient, } from "./letta/client.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAeH,OAAO,EACL,kBAAkB,GAGnB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAE9D,OAAO,EACL,UAAU,EACV,cAAc,GAKf,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,wBAAwB,GAIzB,MAAM,mBAAmB,CAAC"}

package/dist/letta/client.d.ts

@@ -0,0 +1,355 @@
+/**
+ * Hybrid Letta access layer.
+ *
+ * **Two SDKs, two roles:**
+ *
+ * - **`@letta-ai/letta-client`** owns *direct REST operations* —
+ *   `retrieveAgent`, `createConversation`, `listMessages`. These are
+ *   stable agent / conversation / message CRUD against the Letta
+ *   server's REST surface; they don't involve model routing or
+ *   provider shape.
+ * - **`@letta-ai/letta-code-sdk`** owns the *chat-streaming path* —
+ *   `streamUserMessage`. Spawns a Letta Code CLI subprocess per turn;
+ *   the CLI's internal Pi (Provider Interface) + bundled `models.json`
+ *   handle model selection, reasoning-tier presets, and provider
+ *   fallback routing (e.g. Anthropic → Bedrock Opus 4.7). This is what
+ *   keeps ai-hub current with model releases without code changes.
+ *
+ * **The hard rule from §6.4 is preserved** — every Letta interaction
+ * goes through one of these two SDKs; no raw HTTP, no parallel fetch.
+ *
+ * Configuration source: `admin_setting.letta_base_url` +
+ * `admin_setting.letta_api_key_encrypted` (decrypted with
+ * `AI_HUB_ENCRYPTION_KEY`). The Letta-Client wrapper memoizes one SDK
+ * instance per `(apiKey, baseURL)` pair so super-admin connection
+ * edits propagate without restart. The Letta-Code subprocess inherits
+ * `process.env` (which must carry `LETTA_BASE_URL` + `LETTA_API_KEY` —
+ * the boot script sets these from the same decrypted DB row).
+ *
+ * @see SPECIFICATIONS.md §6.4 — Letta integration
+ * @see SPECIFICATIONS.md §6.4.1 — first-class SDK surfaces
+ */
+import LettaSdkDefault from "@letta-ai/letta-client";
+import { resumeSession, type SDKMessage } from "@letta-ai/letta-code-sdk";
+import type { DrizzleDB } from "../db/connection.js";
+import { type SubprocessThrottle } from "./subprocessThrottle.js";
+import type { LettaMessage } from "./types.js";
+export { ServerOverloadedError, SubprocessThrottle } from "./subprocessThrottle.js";
+/**
+ * Thrown when `forkConversation(sourceId)` or `retrieveConversation(id)`
+ * resolves to "no such conversation" (Letta 404). The admin agents
+ * validator catches this and returns `400 fork_source_not_found` inline
+ * on the field; the chat route surfaces it as a 500 (admin-side
+ * validation should have caught it before any user-facing session
+ * create reached the fork path).
+ *
+ * @see docs/server/session-sandboxes.md
+ */
+export declare class ForkSourceNotFoundError extends Error {
+    readonly conversationId: string;
+    constructor(conversationId: string);
+}
+/**
+ * Provider-reported token usage for a single Letta run + the run's
+ * last assistant-message id (so callers can stamp the badge on the
+ * visible bubble). All token fields are nullable because the
+ * producing provider may not report every dimension — Anthropic
+ * reports `cache_write_tokens`, others don't; reasoning tokens come
+ * back only when the model produced any; etc.
+ *
+ * Sourced via a single `GET /v1/runs/{run_id}/messages` call.
+ */
+export interface RunUsageStats {
+    /**
+     * Id of the LAST `assistant_message`-typed entry in the run. `null`
+     * when the run had no assistant messages (rare — error-only runs).
+     * Callers stamp `message_usage` against this id.
+     */
+    lastAssistantMessageId: string | null;
+    promptTokens: number | null;
+    completionTokens: number | null;
+    totalTokens: number | null;
+    cachedInputTokens: number | null;
+    cacheWriteTokens: number | null;
+    reasoningTokens: number | null;
+    contextTokens: number | null;
+}
+/** Parameters for `streamUserMessage`. */
+export interface StreamUserMessageOpts {
+    /** The Letta conversation id (`session.letta_conversation_id`). */
+    conversationId: string;
+    /**
+     * The Letta agent id the session is against. Required so we can
+     * re-seed `~/.letta/settings.json` on every spawn — concurrent CLI
+     * subprocesses race on writes and can wipe the entry, so the
+     * agent-registration-time seed isn't reliable on its own. The
+     * seed-on-spawn call below is idempotent (no-op when the entry
+     * is already present with the same value).
+     */
+    lettaAgentId: string;
+    /**
+     * Plain-text user message body. Sent verbatim to Letta. The admin's
+     * system prompt is delivered through Letta's normal channel (the
+     * agent's persisted `system` field), so we don't re-inject it here.
+     */
+    userMessage: string;
+    /**
+     * Step-12.5 — optional working directory for the spawned Letta Code
+     * subprocess. When set, threaded into the SDK's `resumeSession({ cwd })`
+     * option (maps to the CLI's `--cwd` flag). Used to confine the agent's
+     * filesystem-tool access to a per-session sandbox folder; when
+     * provided, the spawn ALSO drops the `FILESYSTEM_TOOLS` group from
+     * the `disallowedTools` list so the agent can actually read / write
+     * inside that folder.
+     *
+     * When `undefined`, no `cwd` is passed (the CLI inherits the
+     * ai-hub-server process's working directory, as it always has) AND
+     * the filesystem tools remain disallowed — today's stateless agent
+     * shape.
+     *
+     * @see docs/server/session-sandboxes.md
+     */
+    cwd?: string;
+}
+/**
+ * Handle returned by `streamUserMessage`. Wraps the Letta Code SDK
+ * `Session` + the subprocess-throttle lease so the caller owns one
+ * resource bundle to drain, cancel, and clean up.
+ *
+ * Lifecycle expectations:
+ *
+ * 1. Caller iterates `events` to consume `SDKMessage`s in real time.
+ * 2. At any point, calling `abort()` sends an `interrupt` control to
+ *    the spawned CLI. Behavior depends on what the CLI is doing —
+ *    during model generation interrupts work cleanly; during a
+ *    long-running tool call the interrupt is currently queued (see
+ *    migration plan §7 open question 5).
+ * 3. Caller MUST call `close()` in a `finally` regardless of how the
+ *    iteration ended (done, cancelled, error). `close()` terminates
+ *    the CLI subprocess + releases the throttle lease. Idempotent.
+ */
+export interface ChatTurnHandle {
+    /** Async iterable of Letta Code SDK messages — caller drains this. */
+    events: AsyncIterable<SDKMessage>;
+    /**
+     * Sends an `interrupt` control to the spawned CLI. Best-effort; if
+     * the CLI is mid-tool the interrupt may be queued. The caller still
+     * needs to call `close()` to release subprocess + lease.
+     */
+    abort(): Promise<void>;
+    /**
+     * Tears down the Letta Code subprocess + releases the throttle slot.
+     * Idempotent — safe to call twice. Caller MUST invoke this in a
+     * `finally`. Sync because the SDK's `session.close()` is sync.
+     */
+    close(): void;
+}
+/**
+ * Project-shaped Letta client. The handlers depend on this interface,
+ * not on the underlying SDKs, so tests can plug a mock implementation
+ * in via `getLettaClient` on the server context.
+ *
+ * @see SPECIFICATIONS.md §6.4
+ */
+export interface LettaClient {
+    /**
+     * Retrieves a Letta agent by id (via `@letta-ai/letta-client`).
+     * Returns `null` (not throws) on miss so the agent-validation flow
+     * on `POST/PATCH /admin/agents` can return a 400
+     * `letta_agent_not_found` without try/catch noise. Any non-404 SDK
+     * error rethrows — the admin handler returns 500.
+     *
+     * @param lettaAgentId - candidate Letta-side agent id.
+     * @returns the agent state or `null` if not found.
+     */
+    retrieveAgent(lettaAgentId: string): Promise<{
+        id: string;
+        name: string;
+        /** Provider-prefixed model handle (e.g. `"anthropic/claude-opus-4-7"`). */
+        model: string;
+    } | null>;
+    /**
+     * Creates a fresh conversation against the given Letta agent (via
+     * `@letta-ai/letta-client`). Returns the conversation id we store
+     * on the new session row.
+     *
+     * @param lettaAgentId - the Letta-side agent id.
+     * @returns the new conversation's id.
+     */
+    createConversation(lettaAgentId: string): Promise<{
+        id: string;
+    }>;
+    /**
+     * Step-12.5 — retrieves a Letta conversation by id (via
+     * `client.conversations.retrieve`). Used by the admin agents
+     * validator to verify `fork_source_conversation_id` resolves to a
+     * real conversation AND that its `agent_id` matches the agent's
+     * `letta_agent_id` (Letta's fork API requires same-agent forking).
+     *
+     * Returns `null` on Letta 404 so the handler can surface
+     * `400 fork_source_not_found` without try/catch noise; non-404
+     * SDK errors propagate.
+     *
+     * @param conversationId - the candidate Letta conversation id.
+     * @returns `{ id, agentId }` or `null` if not found.
+     */
+    retrieveConversation(conversationId: string): Promise<{
+        id: string;
+        agentId: string;
+    } | null>;
+    /**
+     * Step-12.5 — forks an existing Letta conversation into a new
+     * conversation belonging to the same agent (via
+     * `client.conversations.fork`). The new conversation shares the
+     * source's in-context messages and gets a freshly compiled system
+     * message reflecting the agent's current memory-block values.
+     *
+     * Used by `POST /sessions` when the parent agent's
+     * `fork_source_conversation_id` is set. The admin endpoint validates
+     * source existence + agent match at write time, so this call is
+     * expected to succeed in the happy path; a 404 here is treated as
+     * "operator deleted the source conversation between admin-validate
+     * and user-session-create" and surfaced as `ForkSourceNotFoundError`.
+     *
+     * @param sourceConversationId - the Letta conversation id to fork.
+     * @returns the new conversation's `{ id, agentId }`.
+     * @throws ForkSourceNotFoundError on Letta 404.
+     */
+    forkConversation(sourceConversationId: string): Promise<{
+        id: string;
+        agentId: string;
+    }>;
+    /**
+     * Lists every message in a conversation, oldest first (via
+     * `@letta-ai/letta-client`). Used for `GET /sessions/{id}/messages`
+     * history rendering.
+     *
+     * @param conversationId - the Letta conversation id.
+     * @returns the (oldest-first) array of messages.
+     */
+    listMessages(conversationId: string): Promise<ReadonlyArray<LettaMessage>>;
+    /**
+     * Deletes a single message from an agent's history by id.
+     *
+     * The typed SDK only exposes `create` / `list` on conversation messages,
+     * so this reaches the Letta server's `DELETE /v1/agents/{agent_id}/messages/{message_id}`
+     * endpoint via the SDK's raw HTTP escape hatch (`sdk.delete(...)`) — the
+     * same pattern `getRunUsageStats` uses for `sdk.get(...)`. A 404 is treated
+     * as "already gone" and swallowed; other errors propagate.
+     *
+     * Used by the rotation runner to remove the prompt's `user_message` so a
+     * rotating starting message's prepared conversation opens with the agent's
+     * reply.
+     *
+     * @param lettaAgentId - the agent the message belongs to.
+     * @param messageId - the message id (from `listMessages`).
+     */
+    deleteMessage(lettaAgentId: string, messageId: string): Promise<void>;
+    /**
+     * Deletes an entire Letta conversation (via `client.conversations.delete`).
+     * Best-effort cleanup of a rotating message's previous prepared
+     * conversation after a successful rotation produces a fresh one — a 404 is
+     * swallowed; other errors propagate to the caller (which logs + continues).
+     *
+     * @param conversationId - the Letta conversation id to delete.
+     */
+    deleteConversation(conversationId: string): Promise<void>;
+    /**
+     * Fetches provider-reported token usage for a Letta run, including
+     * prompt-cache hit / write counts. The SDK's `session.stream()`
+     * drops `usage_statistics` messages, so we re-fetch via REST after
+     * the turn lands; the runner uses this to stamp a usage badge on
+     * the last assistant message.
+     *
+     * Returns `null` when:
+     *   - the run id is unknown to Letta (404),
+     *   - the run hasn't emitted a usage_statistics message yet,
+     *   - the network call fails (best-effort — the badge is a nicety,
+     *     not load-bearing).
+     *
+     * @param runId - Letta run id captured from `SDKAssistantMessage.runId`.
+     */
+    getRunUsageStats(runId: string): Promise<RunUsageStats | null>;
+    /**
+     * Spawns a Letta Code CLI subprocess and streams a chat turn against
+     * the given conversation. Returns a `ChatTurnHandle` the caller
+     * drains + cancels + closes.
+     *
+     * Pre-flight checks (in order, all may throw):
+     * 1. **Subprocess throttle.** `SubprocessThrottle.acquire()` runs
+     *    first — throws `ServerOverloadedError` if RAM is under the
+     *    threshold or the hard-cap is reached. The chat route catches
+     *    this and returns HTTP 503 `server_overloaded`.
+     * 2. **Session initialization.** `session.initialize()` may throw if
+     *    the CLI subprocess fails to spawn or can't reach Letta. The
+     *    lease is released before the throw so the throttle counter
+     *    doesn't leak.
+     *
+     * The Letta Code session is configured for the ai-hub use case:
+     * - `permissionMode: "bypassPermissions"` — no interactive approvals
+     *   (we don't expose them to end-users in v1).
+     * - `skillSources: []` — no auto-loaded skills (challenge 2 in the
+     *   migration brief).
+     * - `systemInfoReminder: false` — no first-turn environment dump.
+     * - `memfsStartup: "skip"` — no git-backed memory filesystem.
+     * - `disallowedTools: ["AskUserQuestion", "EnterPlanMode",
+     *   "ExitPlanMode"]` — tools that require runtime user input.
+     *
+     * Toolset suppression is handled out-of-band by the
+     * `seedAgentToolsetNone` upsert into `~/.letta/settings.json` at
+     * agent-registration time.
+     *
+     * @param opts - see `StreamUserMessageOpts`.
+     * @returns a `ChatTurnHandle` the caller drains and closes.
+     * @throws `ServerOverloadedError` when the throttle rejects.
+     */
+    streamUserMessage(opts: StreamUserMessageOpts): Promise<ChatTurnHandle>;
+}
+/** Dependency bundle for `createDefaultLettaClient`. */
+export interface CreateLettaClientDeps {
+    /** Drizzle handle. */
+    db: DrizzleDB;
+    /** Parsed encryption key for decrypting the Letta API key at rest. */
+    encryptionKey: Buffer;
+    /** Subprocess-spawn throttle (shared across the server instance). */
+    subprocessThrottle: SubprocessThrottle;
+    /**
+     * Env source — used as the fallback when the DB column is empty or
+     * whitespace. Production passes `process.env`; tests pass a synthesized
+     * record so the env precedence behaviour is exercisable without
+     * touching the real environment. Re-read on every `getSdk()` call so a
+     * server restart with a different `.env` reflects immediately.
+     */
+    envSource?: Record<string, string | undefined>;
+    /**
+     * Override the Letta Client SDK constructor — only used by tests.
+     * Production passes the SDK's `Letta` class (or omits to use the
+     * default).
+     */
+    sdkConstructor?: typeof LettaSdkDefault;
+    /**
+     * Override `resumeSession` from `@letta-ai/letta-code-sdk` — only
+     * used by tests, which inject a fake session factory.
+     */
+    resumeSessionFn?: typeof resumeSession;
+}
+/**
+ * Constructs the default `LettaClient` implementation.
+ *
+ * Reads `admin_setting.letta_base_url` + `letta_api_key_encrypted` on
+ * each Letta-Client call (no in-flight polling — fresh-on-demand) and
+ * memoizes the underlying SDK instance against `(apiKey, baseURL)` so
+ * super-admin connection-settings edits propagate without restart.
+ *
+ * Throws on the first Letta-Client call if `admin_setting` has no
+ * `letta_base_url` or no decryptable API key.
+ *
+ * @param deps - see `CreateLettaClientDeps`.
+ * @returns the project-shaped Letta client.
+ *
+ * @see SPECIFICATIONS.md §6.4
+ * @see SPECIFICATIONS.md §11 — `admin_setting` schema
+ */
+export declare function createDefaultLettaClient(deps: CreateLettaClientDeps): LettaClient;
+export type { LettaMessage, LettaSdk } from "./types.js";
+//# sourceMappingURL=client.d.ts.map

package/dist/letta/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/letta/client.ts"],"names":[],"mappings":"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"}