@data-club/ai-hub-server 0.0.1

package/dist/letta/eventTranslator.js

@@ -0,0 +1,532 @@
+/**
+ * Pure function: Letta Code SDK message → ai-hub SSE events (§9).
+ *
+ * Input type: `SDKMessage` (Letta Code SDK's stdin/stdout JSON wire
+ * shape). Output type: ai-hub's stable SSE events from §9.
+ *
+ * The translator has **no I/O** — it takes one `SDKMessage` and the
+ * current translation state (running text length, open tool-call ids)
+ * and returns zero or more ai-hub event payloads + the next state.
+ * Persistence, `seq` assignment, and SSE writing are the caller's
+ * responsibility (see `state/turnRunner.ts`).
+ *
+ * ## SDK message variants we handle
+ *
+ * - `assistant` — streaming chunk of assistant text. Same `uuid` across
+ *   chunks of one logical assistant message; different `uuid` signals a
+ *   new logical step (multi-step turn). Emits `assistant_delta`.
+ * - `reasoning` — same as `assistant` but for the reasoning channel.
+ *   Emits `reasoning_delta`. Phase → `model_reasoning`.
+ * - `tool_call` — incremental tool-call event. Same `toolCallId` across
+ *   chunks; `rawArguments` carries one chunk of the partial JSON
+ *   arguments. First sighting emits `tool_call_started`; subsequent
+ *   sightings (or first sighting with a non-empty `rawArguments`) emit
+ *   `tool_call_input_delta`. Phase → `model_tool_input`.
+ * - `tool_result` — one event per call. Emits `tool_call_dispatched`
+ *   (if not already emitted for this id, with the assembled JSON input)
+ *   then `tool_call_result` (success or error variant).
+ * - `result` — terminal. `success: true` → `assistant_message_complete`
+ *   followed by `stream_end {done}`. `success: false` with
+ *   `errorCode: "interrupted"` → `stream_end {cancelled}`. Any other
+ *   failure → `error` + `stream_end {error}`.
+ * - `error` — non-terminal error inside the stream (rare; Letta Code
+ *   surfaces most errors through the terminal `result` event). Emits
+ *   `error` and does NOT change phase — the runner decides whether the
+ *   turn fails based on subsequent events.
+ * - `retry` — Letta Code's internal retry notice (its own TPM
+ *   recovery). We drop it; users don't need to see it in v1.x.
+ * - `init` — never appears on `stream()`; it's the return of
+ *   `session.initialize()`. We don't process it here.
+ * - `stream_event` — only emitted when `--include-partial-messages` is
+ *   set on the CLI. We don't enable that flag.
+ *
+ * @see SPECIFICATIONS.md §9 — wire protocol
+ * @see SPECIFICATIONS.md §10 — state machine
+ */
+/** Builds the per-turn initial state. */
+export function initialTranslatorState() {
+    return {
+        status: "running",
+        phase: "model_text",
+        assistantText: "",
+        reasoningText: "",
+        openToolCalls: new Set(),
+        toolCallArguments: new Map(),
+        dispatchedToolCalls: new Set(),
+        assistantMessageUuid: null,
+    };
+}
+/* ────────────────────────────────────────────────────────────────────────── */
+/*  Entry point                                                               */
+/* ────────────────────────────────────────────────────────────────────────── */
+/**
+ * Translates one SDK message into zero-or-more ai-hub events.
+ *
+ * Pure: no I/O, no module state, no clocks (the caller stamps
+ * timestamps).
+ *
+ * @param msg - the Letta Code SDK message.
+ * @param state - the translator state.
+ * @returns the events to emit + the next state.
+ */
+export function translateSdkMessage(msg, state) {
+    // Mid-stream step-boundary detection. A turn that runs in multiple
+    // steps (reasoning + tool + assistant text, then reasoning + tool +
+    // assistant text again …) produces multiple logical assistant
+    // messages within one streaming response. The boundary fires when
+    // we've already accumulated assistant text and the next event is
+    // either:
+    //
+    // - a `reasoning` chunk (new step's reasoning starting), or
+    // - a `tool_call` chunk (new step's first tool call), or
+    // - an `assistant` chunk with a different `uuid` than the one
+    //   currently being assembled.
+    if (isStepBoundary(msg, state)) {
+        const boundaryEvents = finalizeAssistantMessageMidStream(state);
+        const fresh = resetForNewStep(state);
+        const inner = translateInner(msg, fresh);
+        return {
+            events: [...boundaryEvents, ...inner.events],
+            state: inner.state,
+        };
+    }
+    return translateInner(msg, state);
+}
+/**
+ * Returns true when `msg` signals that the current logical assistant
+ * step is done and a new one is starting. Triggers only when the
+ * translator already has accumulated assistant text — otherwise there's
+ * nothing to finalize and the message just enters the current step.
+ */
+function isStepBoundary(msg, state) {
+    if (state.assistantText.length === 0)
+        return false;
+    switch (msg.type) {
+        case "reasoning":
+        case "tool_call":
+            return true;
+        case "assistant":
+            return (state.assistantMessageUuid !== null &&
+                msg.uuid !== state.assistantMessageUuid);
+        default:
+            return false;
+    }
+}
+/**
+ * Resets the per-step accumulators for a new logical step. Carries
+ * `status`/`phase` through — the next event will set them via its
+ * variant translator.
+ */
+function resetForNewStep(state) {
+    return {
+        ...state,
+        assistantText: "",
+        reasoningText: "",
+        openToolCalls: new Set(),
+        toolCallArguments: new Map(),
+        dispatchedToolCalls: new Set(),
+        assistantMessageUuid: null,
+    };
+}
+/**
+ * Mid-stream sibling of `finalizeAssistantMessage`. Emits the same
+ * `assistant_message_complete` for the accumulated step but snapshots
+ * the state as `{ status: "running", phase: <current> }` — the turn
+ * isn't done yet, only this logical step is. Returns empty when no
+ * assistant text was accumulated.
+ */
+function finalizeAssistantMessageMidStream(state) {
+    if (state.assistantText.length === 0)
+        return [];
+    const message = {
+        id: state.assistantMessageUuid ?? "",
+        role: "assistant",
+        content: state.assistantText,
+        created_at: new Date().toISOString(),
+    };
+    return [
+        {
+            event: "assistant_message_complete",
+            data: { message },
+            state: snapshot(state),
+        },
+    ];
+}
+/** The original per-variant switch — extracted so the entry-point can
+ *  wrap it with the step-boundary check above. */
+function translateInner(msg, state) {
+    switch (msg.type) {
+        case "assistant":
+            return translateAssistant(msg, state);
+        case "reasoning":
+            return translateReasoning(msg, state);
+        case "tool_call":
+            return translateToolCall(msg, state);
+        case "tool_result":
+            return translateToolResult(msg, state);
+        case "error":
+            return translateError(msg, state);
+        case "result":
+        case "init":
+        case "retry":
+        case "stream_event":
+        default:
+            // `result` is terminal — the runner detects it and calls
+            // `finalizeAssistantMessage` + `finalizeTerminal` itself. The
+            // others are either no-ops (`init` never appears in stream();
+            // `retry` is internal; `stream_event` requires a flag we don't
+            // set) or unknown future variants we pass through.
+            return { events: [], state };
+    }
+}
+/* ── per-variant translators ──────────────────────────────────────────────── */
+/**
+ * `assistant` → `assistant_delta`. Each chunk carries the **delta** text
+ * in `content` (not cumulative); we forward the delta verbatim and
+ * accumulate the full text in `assistantText` for the eventual
+ * `assistant_message_complete`.
+ */
+function translateAssistant(msg, state) {
+    if (!msg.content || msg.content.length === 0) {
+        return { events: [], state };
+    }
+    const next = {
+        ...state,
+        status: "running",
+        phase: "model_text",
+        assistantText: state.assistantText + msg.content,
+        assistantMessageUuid: state.assistantMessageUuid ?? msg.uuid,
+    };
+    return {
+        events: [
+            {
+                event: "assistant_delta",
+                data: { delta: msg.content },
+                state: snapshot(next),
+            },
+        ],
+        state: next,
+    };
+}
+/**
+ * `reasoning` → `reasoning_delta`. Phase transitions to
+ * `model_reasoning` while the block is in flight; the next non-
+ * reasoning message drives it back to `model_text`.
+ */
+function translateReasoning(msg, state) {
+    if (!msg.content || msg.content.length === 0) {
+        return { events: [], state };
+    }
+    const next = {
+        ...state,
+        status: "running",
+        phase: "model_reasoning",
+        reasoningText: state.reasoningText + msg.content,
+    };
+    return {
+        events: [
+            {
+                event: "reasoning_delta",
+                data: { delta: msg.content },
+                state: snapshot(next),
+            },
+        ],
+        state: next,
+    };
+}
+/**
+ * `tool_call` → `tool_call_started` on first sighting of the id, then
+ * `tool_call_input_delta` for each chunk of `rawArguments`. The
+ * SDK delivers tool-call arguments in multiple chunks (e.g. 3 events
+ * for `{"path": "/etc/hostname"}`) sharing the same `toolCallId`.
+ *
+ * We accumulate `rawArguments` per id so `translateToolResult` can
+ * include the assembled parsed input in `tool_call_dispatched`.
+ */
+function translateToolCall(msg, state) {
+    const id = msg.toolCallId;
+    if (!id)
+        return { events: [], state };
+    const events = [];
+    let next = {
+        ...state,
+        status: "running",
+        phase: "model_tool_input",
+    };
+    if (!next.openToolCalls.has(id)) {
+        events.push({
+            event: "tool_call_started",
+            data: { tool_call_id: id, tool_name: msg.toolName },
+            state: snapshot(next),
+        });
+        const opened = new Set(next.openToolCalls);
+        opened.add(id);
+        next = { ...next, openToolCalls: opened };
+    }
+    // Per-chunk rawArguments accumulation. The 1st event sometimes
+    // arrives with toolInput={raw:""} and no rawArguments; subsequent
+    // events carry chunks of the JSON args string.
+    const chunk = msg.rawArguments ?? "";
+    if (chunk.length > 0) {
+        const accumulated = (next.toolCallArguments.get(id) ?? "") + chunk;
+        const nextArgs = new Map(next.toolCallArguments);
+        nextArgs.set(id, accumulated);
+        next = { ...next, toolCallArguments: nextArgs };
+        events.push({
+            event: "tool_call_input_delta",
+            data: { tool_call_id: id, partial_json: chunk },
+            state: snapshot(next),
+        });
+    }
+    return { events, state: next };
+}
+/**
+ * `tool_result` → `tool_call_dispatched` (if not already) +
+ * `tool_call_result`.
+ *
+ * Phase transitions: `model_tool_input` → `tool_executing` (on
+ * dispatched) → `model_text` (after the result lands). Per §10.3 a
+ * tool error does NOT fail the turn — phase reverts to `model_text`
+ * either way.
+ */
+function translateToolResult(msg, state) {
+    const id = msg.toolCallId;
+    if (!id)
+        return { events: [], state };
+    const events = [];
+    let next = { ...state };
+    if (!next.dispatchedToolCalls.has(id)) {
+        const assembled = next.toolCallArguments.get(id);
+        events.push({
+            event: "tool_call_dispatched",
+            data: {
+                tool_call_id: id,
+                input: tryParseJson(assembled),
+            },
+            state: snapshot({ ...next, phase: "tool_executing" }),
+        });
+        const dispatched = new Set(next.dispatchedToolCalls);
+        dispatched.add(id);
+        next = {
+            ...next,
+            phase: "tool_executing",
+            dispatchedToolCalls: dispatched,
+        };
+    }
+    if (msg.isError) {
+        events.push({
+            event: "tool_call_result",
+            data: {
+                tool_call_id: id,
+                error: { code: "tool_error", message: msg.content ?? "" },
+            },
+            state: snapshot({ ...next, phase: "model_text" }),
+        });
+    }
+    else {
+        events.push({
+            event: "tool_call_result",
+            data: { tool_call_id: id, output: msg.content ?? "" },
+            state: snapshot({ ...next, phase: "model_text" }),
+        });
+    }
+    next = { ...next, phase: "model_text" };
+    return { events, state: next };
+}
+/**
+ * `error` SDK message → `error` SSE event.
+ *
+ * Letta Code surfaces most errors through the terminal `result` event
+ * (see `finalizeTerminal`), but a few error conditions also produce a
+ * mid-stream `error` event with `stopReason` and an optional
+ * `apiError`. We pass them through as ai-hub `error` events; the
+ * runner decides whether the turn should fail (it typically does, but
+ * the terminal `result` event is the authoritative signal).
+ */
+function translateError(msg, state) {
+    const code = classifyErrorCode(msg.errorCode, msg.stopReason);
+    return {
+        events: [
+            {
+                event: "error",
+                data: {
+                    code,
+                    message: msg.message ?? "Letta Code reported an error.",
+                },
+                state: snapshot(state),
+            },
+        ],
+        state,
+    };
+}
+/* ────────────────────────────────────────────────────────────────────────── */
+/*  Finalizers                                                                */
+/* ────────────────────────────────────────────────────────────────────────── */
+/**
+ * Emits the closing `assistant_message_complete` event for a turn that
+ * accumulated assistant text. Called by the runner exactly once when
+ * the terminal `result` SDK message arrives — but only when the turn
+ * succeeded. For a cancelled / failed turn we still emit it (the user
+ * deserves to see whatever partial text was generated), but the
+ * snapshot reflects the terminal status.
+ *
+ * @param state - the translator state at end-of-stream.
+ * @param terminalStatus - the status to snapshot into the envelope.
+ * @returns the closing events (empty if no assistant text was produced).
+ */
+export function finalizeAssistantMessage(state, terminalStatus = "done") {
+    if (state.assistantText.length === 0)
+        return [];
+    const message = {
+        id: state.assistantMessageUuid ?? "",
+        role: "assistant",
+        content: state.assistantText,
+        created_at: new Date().toISOString(),
+    };
+    return [
+        {
+            event: "assistant_message_complete",
+            data: { message },
+            state: snapshot({ ...state, status: terminalStatus, phase: null }),
+        },
+    ];
+}
+/**
+ * Interprets the terminal SDK `result` message into the right closing
+ * sequence: `assistant_message_complete` (if any) + the final
+ * `stream_end` with the appropriate reason. Pure function — no I/O.
+ *
+ * Behavior matrix:
+ *
+ * | result.success | result.errorCode | Emitted closing events |
+ * |---|---|---|
+ * | true  | — | assistant_message_complete + stream_end{done} |
+ * | false | "interrupted" | assistant_message_complete (with partial text, if any) + stream_end{cancelled} |
+ * | false | anything else | (assistant_message_complete if partial text) + error + stream_end{error} |
+ *
+ * @param msg - the terminal SDK result message.
+ * @param state - the translator state right before the result arrived.
+ * @returns the events to emit + the (terminal) state.
+ */
+export function finalizeTerminal(msg, state) {
+    if (msg.success) {
+        const completion = finalizeAssistantMessage(state, "done");
+        const finalState = { ...state, status: "done", phase: null };
+        return {
+            events: [
+                ...completion,
+                {
+                    event: "stream_end",
+                    data: { reason: "done" },
+                    state: snapshot(finalState),
+                },
+            ],
+            state: finalState,
+        };
+    }
+    if (msg.errorCode === "interrupted") {
+        const completion = finalizeAssistantMessage(state, "cancelled");
+        const finalState = { ...state, status: "cancelled", phase: null };
+        return {
+            events: [
+                ...completion,
+                {
+                    event: "stream_end",
+                    data: { reason: "cancelled" },
+                    state: snapshot(finalState),
+                },
+            ],
+            state: finalState,
+        };
+    }
+    // Any other failure (llm_api_error, max_steps, protocol_error,
+    // stream_closed, …) is a hard fail. Still emit the partial assistant
+    // text if any was produced, then the error and stream_end.
+    const partial = finalizeAssistantMessage(state, "failed");
+    const finalState = { ...state, status: "failed", phase: null };
+    const code = classifyErrorCode(msg.errorCode, msg.stopReason);
+    return {
+        events: [
+            ...partial,
+            {
+                event: "error",
+                data: {
+                    code,
+                    message: msg.errorDetail ?? msg.error ?? "Letta Code reported a terminal error.",
+                },
+                state: snapshot(finalState),
+            },
+            {
+                event: "stream_end",
+                data: { reason: "error" },
+                state: snapshot(finalState),
+            },
+        ],
+        state: finalState,
+    };
+}
+/* ────────────────────────────────────────────────────────────────────────── */
+/*  Internal helpers                                                          */
+/* ────────────────────────────────────────────────────────────────────────── */
+/** Snapshots `(status, phase)` for the SSE event envelope. */
+function snapshot(state) {
+    return { status: state.status, phase: state.phase };
+}
+/**
+ * Best-effort JSON parse. Returns `undefined` on failure so the
+ * `tool_call_dispatched.data.input` is null-shaped rather than
+ * throwing. If `raw` is `undefined` we also return `undefined` —
+ * happens when the tool was called with no args at all.
+ */
+function tryParseJson(raw) {
+    if (raw === undefined || raw === "")
+        return undefined;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+/**
+ * Maps the SDK's `errorCode` + `stopReason` strings onto ai-hub's
+ * stable `error.code` enum.
+ *
+ * SDK error codes we know about:
+ * - `approval_conflict` — non-fatal approval flow snag; treat as `internal`
+ *   (ai-hub doesn't surface approvals to end-users in v1).
+ * - `protocol_error` — SDK ↔ CLI wire-shape mismatch; `internal`.
+ * - `llm_api_error` — the underlying LLM call failed; `provider_error`.
+ * - `max_steps` — agent hit its step ceiling; `internal` for now (a
+ *   `max_steps` ai-hub code is a future v1.x enhancement).
+ * - `interrupted` — handled separately in `finalizeTerminal`.
+ * - `stream_closed` — SDK pump closed early; `internal`.
+ * - `error` (generic) — fall back to `stopReason` sniffing.
+ *
+ * The set of legitimate ai-hub `error.code` values lives in
+ * `@data-club/ai-hub` (§9.4). We keep `tpm_exhausted` reserved for
+ * future use (it is no longer emitted post-migration — the recovery
+ * loop is gone — but we keep the enum value so a future restore can
+ * use it without protocol-version churn).
+ */
+function classifyErrorCode(errorCode, stopReason) {
+    if (errorCode === "llm_api_error")
+        return "provider_error";
+    if (errorCode === "approval_conflict" || errorCode === "approval_conflict_terminal")
+        return "internal";
+    if (errorCode === "protocol_error" || errorCode === "stream_closed")
+        return "internal";
+    if (errorCode === "max_steps")
+        return "internal";
+    if (errorCode && errorCode !== "error" && errorCode !== "interrupted")
+        return "internal";
+    // Fall back on stopReason heuristics. Future Letta Code versions may
+    // expose richer error codes; we'll extend the map here.
+    const l = (stopReason ?? "").toLowerCase();
+    if (l.includes("rate") || l.includes("limit") || l.includes("429"))
+        return "tpm_exhausted";
+    if (l.includes("provider") || l.includes("upstream") || l.includes("llm"))
+        return "provider_error";
+    return "internal";
+}
+//# sourceMappingURL=eventTranslator.js.map

package/dist/letta/eventTranslator.js.map

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

package/dist/letta/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Public exports for the `letta/` module — the single entry point the rest
+ * of the server uses to reach Letta. Per §6.4, **every Letta interaction
+ * goes through `LettaClient`**; no raw HTTP, no other entry points.
+ *
+ * @see SPECIFICATIONS.md §6.4
+ */
+export { createDefaultLettaClient, type CreateLettaClientDeps, type LettaClient, type StreamUserMessageOpts, } from "./client.js";
+export { finalizeAssistantMessage, finalizeTerminal, initialTranslatorState, translateSdkMessage, type TranslateStep, type TranslatorState, type UnsequencedEvent, } from "./eventTranslator.js";
+export { ServerOverloadedError, SubprocessThrottle, readThrottleConfigFromEnv, type ThrottleConfig, type ThrottleLease, } from "./subprocessThrottle.js";
+export { seedAgentToolsetNone, type SeedOutcome, type ToolsetPreference, } from "./settingsFileSeed.js";
+export type { LettaAssistantMessage, LettaHiddenReasoningMessage, LettaMessage, LettaReasoningMessage, LettaSdk, LettaStreamEvent, LettaToolCallMessage, LettaToolReturnMessage, LettaUserMessage, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/letta/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,wBAAwB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,WAAW,EAChB,KAAK,qBAAqB,GAC3B,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,wBAAwB,EACxB,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,yBAAyB,EACzB,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,oBAAoB,EACpB,KAAK,WAAW,EAChB,KAAK,iBAAiB,GACvB,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,qBAAqB,EACrB,2BAA2B,EAC3B,YAAY,EACZ,qBAAqB,EACrB,QAAQ,EACR,gBAAgB,EAChB,oBAAoB,EACpB,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,YAAY,CAAC"}

package/dist/letta/index.js

@@ -0,0 +1,12 @@
+/**
+ * Public exports for the `letta/` module — the single entry point the rest
+ * of the server uses to reach Letta. Per §6.4, **every Letta interaction
+ * goes through `LettaClient`**; no raw HTTP, no other entry points.
+ *
+ * @see SPECIFICATIONS.md §6.4
+ */
+export { createDefaultLettaClient, } from "./client.js";
+export { finalizeAssistantMessage, finalizeTerminal, initialTranslatorState, translateSdkMessage, } from "./eventTranslator.js";
+export { ServerOverloadedError, SubprocessThrottle, readThrottleConfigFromEnv, } from "./subprocessThrottle.js";
+export { seedAgentToolsetNone, } from "./settingsFileSeed.js";
+//# sourceMappingURL=index.js.map

package/dist/letta/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/letta/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,wBAAwB,GAIzB,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,wBAAwB,EACxB,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,GAIpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,qBAAqB,EACrB,kBAAkB,EAClB,yBAAyB,GAG1B,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,oBAAoB,GAGrB,MAAM,uBAAuB,CAAC"}