@data-club/ai-hub-server 0.0.1

package/dist/letta/modelSettings.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Provider-specific `model_settings` construction for `agents.update()`.
+ *
+ * This module is a near-verbatim port of Letta Code CLI's `buildModelSettings2`
+ * function (in `@letta-ai/letta-code` v0.19.5, bundled in `letta.js`). The goal
+ * is to mirror Letta's own translation from a logical
+ * `(modelHandle, updateArgs)` choice to the wire shape the server accepts —
+ * so when Letta changes that mapping (new providers, new fields, renamed
+ * enums), we copy the diff instead of re-deriving the logic.
+ *
+ * Provider routing (from CLI source):
+ *
+ *   openai/ | openrouter/                  → OpenAIModelSettings
+ *   anthropic/ | claude-pro-max/ | minimax/ → AnthropicModelSettings
+ *   zai/                                   → ZaiModelSettings (no reasoning knobs)
+ *   google_ai/                             → GoogleAIModelSettings
+ *   google_vertex/                         → GoogleVertexModelSettings
+ *   bedrock/                               → BedrockModelSettings
+ *   <anything else>                        → OpenAI-shaped fallback
+ *
+ * Reasoning input: a unified `reasoning_effort` enum
+ *   `"none" | "minimal" | "low" | "medium" | "high" | "xhigh"`
+ * is translated per provider:
+ *
+ *   Anthropic / Bedrock — emits `model_settings.effort` (with `xhigh` mapped
+ *     to `"max"`). `thinking` is omitted entirely UNLESS the caller also sets
+ *     `enable_reasoner` or `max_reasoning_tokens` — letting the model handle
+ *     thinking decisions implicitly (Opus 4.7+ behavior).
+ *   OpenAI / OpenRouter — emits `model_settings.reasoning.reasoning_effort`,
+ *     plus optional `verbosity` and `strict`.
+ *   Google AI / Vertex — emits `thinking_config.thinking_budget` (numeric),
+ *     not the effort enum.
+ *   Z.AI — no reasoning surface (CLI exposes none either).
+ *
+ * Source-of-truth callout: when Letta releases a new CLI version, diff
+ * `@letta-ai/letta-code/letta.js → buildModelSettings2` against this file.
+ *
+ * @see tmp/letta-research/letta-code-sdk — cloned SDK source for inspection
+ * @see node_modules/@letta-ai/letta-code/letta.js — CLI bundle (search
+ *      `function buildModelSettings2`)
+ */
+import type { AnthropicModelSettings, BedrockModelSettings, GoogleAIModelSettings, GoogleVertexModelSettings, OpenAIModelSettings, XaiModelSettings } from "@letta-ai/letta-client/resources/agents/agents.js";
+/** Unified reasoning-effort input. Provider mapping happens in `buildModelSettings`.
+ *
+ *  - `"off"` — the unified-UX "no reasoning" tier; for Google maps to budget=0,
+ *    for Anthropic-shape providers no `effort` field is sent (the agent's
+ *    `enable_reasoner` flag controls whether reasoning runs at all).
+ *  - `"none"` / `"minimal"` — OpenAI-only tiers, passed through verbatim.
+ *  - `"low"` / `"medium"` / `"high"` / `"xhigh"` — universal tiers.
+ *    Anthropic's `xhigh` is translated to `"max"` at the wire level.
+ */
+export type ReasoningEffort = "off" | "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+/** Verbosity input (used by OpenAI-shape providers — GPT-5.x family). */
+export type Verbosity = "low" | "medium" | "high";
+/**
+ * Logical input shape — matches Letta Code's `updateArgs` exactly.
+ *
+ * The intent: callers describe the AGENT's intended configuration in
+ * provider-agnostic terms, and `buildModelSettings()` produces the right
+ * `*ModelSettings` discriminated-union member for the wire.
+ */
+export interface ModelUpdateArgs {
+    reasoning_effort?: ReasoningEffort | null;
+    enable_reasoner?: boolean;
+    max_reasoning_tokens?: number;
+    thinking_budget?: number;
+    verbosity?: Verbosity;
+    max_output_tokens?: number | null;
+    parallel_tool_calls?: boolean;
+    strict?: boolean;
+    temperature?: number;
+    context_window?: number;
+}
+/**
+ * Discriminated union — wire-shape returned by `buildModelSettings()`. This is
+ * the same union the Letta SDK accepts on `agents.update({ model_settings })`.
+ */
+export type ModelSettings = OpenAIModelSettings | AnthropicModelSettings | GoogleAIModelSettings | GoogleVertexModelSettings | BedrockModelSettings | XaiModelSettings | {
+    provider_type: "zai";
+    parallel_tool_calls?: boolean;
+};
+/**
+ * Resolves a model handle's provider family. Matches Letta Code's
+ * `startsWith` checks exactly.
+ *
+ * @param modelHandle — the agent's `model` field (e.g. `"anthropic/claude-opus-4-6"`).
+ */
+export declare function getProviderFamily(modelHandle: string): ProviderFamily;
+export type ProviderFamily = "openai" | "anthropic" | "zai" | "google_ai" | "google_vertex" | "bedrock" | "openai_compatible";
+/**
+ * The unified UI effort tiers, ordered low → high. `"off"` always maps to a
+ * zero / disabled state; the other tiers are proportionally distributed
+ * between 0 and the model's max budget for budget-based providers.
+ *
+ * For enum-based providers (Anthropic, OpenAI), the tier name is passed
+ * through directly to the wire field (`effort` / `reasoning_effort`), with
+ * Anthropic's `xhigh` → `max` translation handled at the call site.
+ */
+export declare const EFFORT_TIERS: readonly ["off", "low", "medium", "high", "xhigh", "max"];
+export type EffortTier = (typeof EFFORT_TIERS)[number];
+/**
+ * Maps a unified effort tier + a model handle to a concrete thinking-token
+ * budget. Returns `undefined` when the provider doesn't take a numeric budget
+ * (the caller should fall back to the enum field instead).
+ */
+export declare function effortTierToThinkingBudget(modelHandle: string, tier: EffortTier): number | undefined;
+/**
+ * Translates a logical `(modelHandle, args)` selection into the wire-shape
+ * `model_settings` object Letta expects on `agents.update()`.
+ *
+ * **Keep in sync** with Letta Code's `buildModelSettings2` — see file header.
+ *
+ * @param modelHandle — provider-prefixed handle (e.g. `"anthropic/claude-opus-4-6"`).
+ * @param args — logical update arguments (effort, verbosity, budgets, etc.).
+ * @returns the right discriminated-union member for the wire.
+ */
+export declare function buildModelSettings(modelHandle: string, args: ModelUpdateArgs): ModelSettings;
+/**
+ * Describes which reasoning knobs are settable for a given model handle.
+ * Drives ai-hub's per-model UI: if `effort` is omitted, no "Reasoning"
+ * dropdown is rendered for the agent; if `verbosity` is present, a separate
+ * "Verbosity" dropdown is rendered alongside; etc.
+ *
+ * The enums returned here MIRROR Letta's SDK `*ModelSettings` types — when
+ * Letta adds new values (e.g. `"ultra"` to `effort`), we copy the diff and
+ * the UI picks it up automatically.
+ */
+export interface ReasoningCapabilities {
+    /**
+     * Unified "Reasoning" dropdown — used for `anthropic/*`, `bedrock/*`, and
+     * `google_ai/*` / `google_vertex/*`. The enum is one of:
+     *
+     *  - `["low","medium","high","xhigh","max"]` — Anthropic / Bedrock; passed
+     *    through to `model_settings.effort` (with `xhigh` → `max` translation).
+     *  - `["off","low","medium","high","xhigh","max"]` — Google AI / Vertex;
+     *    the server maps the tier to `thinking_config.thinking_budget` as a
+     *    fraction of the provider's max budget (see `effortTierToThinkingBudget`).
+     *    `"off"` means budget=0 (no thinking).
+     */
+    effort?: {
+        enum: ReadonlyArray<EffortTier>;
+    };
+    /**
+     * OpenAI-shape reasoning_effort dropdown. Present for `openai/*`,
+     * `openrouter/*`, OpenAI-compatible models. UI label: "Reasoning"
+     * (separate from "Verbosity").
+     */
+    reasoning_effort?: {
+        enum: ReadonlyArray<"none" | "minimal" | "low" | "medium" | "high" | "xhigh">;
+    };
+    /**
+     * Verbosity dropdown — GPT-5.x / OpenAI shape. Independent from
+     * reasoning_effort, rendered as its own UI control.
+     */
+    verbosity?: {
+        enum: ReadonlyArray<Verbosity>;
+    };
+    /**
+     * Google-style thinking budget (numeric). Rendered as a slider/input.
+     * Range hints come from Google docs (1024–24576 typical).
+     */
+    thinking_budget?: {
+        min: number;
+        max: number;
+    };
+}
+/**
+ * Computes per-model reasoning capabilities from the model handle. Provider
+ * routing matches `buildModelSettings`; the per-field enums mirror Letta's
+ * SDK type definitions.
+ *
+ * @param modelHandle — provider-prefixed handle.
+ * @returns capability descriptor — empty object when no reasoning knobs apply.
+ */
+export declare function getReasoningCapabilities(modelHandle: string): ReasoningCapabilities;
+//# sourceMappingURL=modelSettings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"modelSettings.d.ts","sourceRoot":"","sources":["../../src/letta/modelSettings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EACV,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,EACzB,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,mDAAmD,CAAC;AAM3D;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,GACvB,KAAK,GACL,MAAM,GACN,SAAS,GACT,KAAK,GACL,QAAQ,GACR,MAAM,GACN,OAAO,GACP,KAAK,CAAC;AAEV,yEAAyE;AACzE,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;AAElD;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,gBAAgB,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAC1C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,MAAM,aAAa,GACrB,mBAAmB,GACnB,sBAAsB,GACtB,qBAAqB,GACrB,yBAAyB,GACzB,oBAAoB,GACpB,gBAAgB,GAChB;IAAE,aAAa,EAAE,KAAK,CAAC;IAAC,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAM5D;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,cAAc,CAoBrE;AAED,MAAM,MAAM,cAAc,GACtB,QAAQ,GACR,WAAW,GACX,KAAK,GACL,WAAW,GACX,eAAe,GACf,SAAS,GACT,mBAAmB,CAAC;AAuBxB;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,2DAOf,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAgBvD;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,UAAU,GACf,MAAM,GAAG,SAAS,CAMpB;AAMD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,eAAe,GACpB,aAAa,CAqIf;AAMD;;;;;;;;;GASG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE;QACP,IAAI,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;KACjC,CAAC;IACF;;;;OAIG;IACH,gBAAgB,CAAC,EAAE;QACjB,IAAI,EAAE,aAAa,CACjB,MAAM,GAAG,SAAS,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CACzD,CAAC;KACH,CAAC;IACF;;;OAGG;IACH,SAAS,CAAC,EAAE;QACV,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;KAChC,CAAC;IACF;;;OAGG;IACH,eAAe,CAAC,EAAE;QAChB,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;CACH;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,GAClB,qBAAqB,CA+BvB"}

package/dist/letta/modelSettings.js

@@ -0,0 +1,314 @@
+/**
+ * Provider-specific `model_settings` construction for `agents.update()`.
+ *
+ * This module is a near-verbatim port of Letta Code CLI's `buildModelSettings2`
+ * function (in `@letta-ai/letta-code` v0.19.5, bundled in `letta.js`). The goal
+ * is to mirror Letta's own translation from a logical
+ * `(modelHandle, updateArgs)` choice to the wire shape the server accepts —
+ * so when Letta changes that mapping (new providers, new fields, renamed
+ * enums), we copy the diff instead of re-deriving the logic.
+ *
+ * Provider routing (from CLI source):
+ *
+ *   openai/ | openrouter/                  → OpenAIModelSettings
+ *   anthropic/ | claude-pro-max/ | minimax/ → AnthropicModelSettings
+ *   zai/                                   → ZaiModelSettings (no reasoning knobs)
+ *   google_ai/                             → GoogleAIModelSettings
+ *   google_vertex/                         → GoogleVertexModelSettings
+ *   bedrock/                               → BedrockModelSettings
+ *   <anything else>                        → OpenAI-shaped fallback
+ *
+ * Reasoning input: a unified `reasoning_effort` enum
+ *   `"none" | "minimal" | "low" | "medium" | "high" | "xhigh"`
+ * is translated per provider:
+ *
+ *   Anthropic / Bedrock — emits `model_settings.effort` (with `xhigh` mapped
+ *     to `"max"`). `thinking` is omitted entirely UNLESS the caller also sets
+ *     `enable_reasoner` or `max_reasoning_tokens` — letting the model handle
+ *     thinking decisions implicitly (Opus 4.7+ behavior).
+ *   OpenAI / OpenRouter — emits `model_settings.reasoning.reasoning_effort`,
+ *     plus optional `verbosity` and `strict`.
+ *   Google AI / Vertex — emits `thinking_config.thinking_budget` (numeric),
+ *     not the effort enum.
+ *   Z.AI — no reasoning surface (CLI exposes none either).
+ *
+ * Source-of-truth callout: when Letta releases a new CLI version, diff
+ * `@letta-ai/letta-code/letta.js → buildModelSettings2` against this file.
+ *
+ * @see tmp/letta-research/letta-code-sdk — cloned SDK source for inspection
+ * @see node_modules/@letta-ai/letta-code/letta.js — CLI bundle (search
+ *      `function buildModelSettings2`)
+ */
+/* ────────────────────────────────────────────────────────────────────────── */
+/*  Provider routing                                                          */
+/* ────────────────────────────────────────────────────────────────────────── */
+/**
+ * Resolves a model handle's provider family. Matches Letta Code's
+ * `startsWith` checks exactly.
+ *
+ * @param modelHandle — the agent's `model` field (e.g. `"anthropic/claude-opus-4-6"`).
+ */
+export function getProviderFamily(modelHandle) {
+    if (modelHandle.startsWith("openai/") ||
+        modelHandle.startsWith("openai_codex/") ||
+        modelHandle.startsWith("openrouter/")) {
+        return "openai";
+    }
+    if (modelHandle.startsWith("anthropic/") ||
+        modelHandle.startsWith("claude-pro-max/") ||
+        modelHandle.startsWith("minimax/")) {
+        return "anthropic";
+    }
+    if (modelHandle.startsWith("zai/"))
+        return "zai";
+    if (modelHandle.startsWith("google_ai/"))
+        return "google_ai";
+    if (modelHandle.startsWith("google_vertex/"))
+        return "google_vertex";
+    if (modelHandle.startsWith("bedrock/"))
+        return "bedrock";
+    return "openai_compatible";
+}
+/* ────────────────────────────────────────────────────────────────────────── */
+/*  Thinking-budget normalization — unified effort dropdown across providers  */
+/* ────────────────────────────────────────────────────────────────────────── */
+/**
+ * Per-provider default for the model's maximum thinking-token budget. Used to
+ * translate the unified `effort` tier into a concrete `thinking_budget`
+ * number for providers that take a budget (Google AI / Vertex).
+ *
+ * **Not a hardcoded per-model table** — this is a per-provider ceiling; the
+ * model's effective max may be lower (e.g. Gemini 2.5 Flash) but Letta will
+ * clamp on its side. A future enhancement could read `Model.max_reasoning_tokens`
+ * from `client.models.list()` and override when non-zero, plus expose a
+ * per-agent override in admin DB. The current value matches Google's
+ * published per-model maxes for Gemini 2.5 Pro / Flash (24576).
+ */
+const PROVIDER_THINKING_BUDGET_MAX = {
+    google_ai: 24576,
+    google_vertex: 24576,
+};
+/**
+ * The unified UI effort tiers, ordered low → high. `"off"` always maps to a
+ * zero / disabled state; the other tiers are proportionally distributed
+ * between 0 and the model's max budget for budget-based providers.
+ *
+ * For enum-based providers (Anthropic, OpenAI), the tier name is passed
+ * through directly to the wire field (`effort` / `reasoning_effort`), with
+ * Anthropic's `xhigh` → `max` translation handled at the call site.
+ */
+export const EFFORT_TIERS = [
+    "off",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+/**
+ * Fraction of the model's max thinking budget for each tier, used when
+ * translating to a budget-based provider. `"off"` → 0; the other five tiers
+ * are linearly distributed up to 1.0 (max = full budget).
+ */
+const EFFORT_TIER_FRACTION = {
+    off: 0,
+    low: 0.2,
+    medium: 0.4,
+    high: 0.6,
+    xhigh: 0.8,
+    max: 1.0,
+};
+/**
+ * Maps a unified effort tier + a model handle to a concrete thinking-token
+ * budget. Returns `undefined` when the provider doesn't take a numeric budget
+ * (the caller should fall back to the enum field instead).
+ */
+export function effortTierToThinkingBudget(modelHandle, tier) {
+    const family = getProviderFamily(modelHandle);
+    const max = PROVIDER_THINKING_BUDGET_MAX[family];
+    if (max === undefined)
+        return undefined;
+    const fraction = EFFORT_TIER_FRACTION[tier];
+    return Math.round(max * fraction);
+}
+/* ────────────────────────────────────────────────────────────────────────── */
+/*  buildModelSettings — port of Letta Code's buildModelSettings2             */
+/* ────────────────────────────────────────────────────────────────────────── */
+/**
+ * Translates a logical `(modelHandle, args)` selection into the wire-shape
+ * `model_settings` object Letta expects on `agents.update()`.
+ *
+ * **Keep in sync** with Letta Code's `buildModelSettings2` — see file header.
+ *
+ * @param modelHandle — provider-prefixed handle (e.g. `"anthropic/claude-opus-4-6"`).
+ * @param args — logical update arguments (effort, verbosity, budgets, etc.).
+ * @returns the right discriminated-union member for the wire.
+ */
+export function buildModelSettings(modelHandle, args) {
+    const family = getProviderFamily(modelHandle);
+    let settings;
+    if (family === "openai") {
+        const openaiSettings = {
+            provider_type: "openai",
+            parallel_tool_calls: true,
+        };
+        if (args.reasoning_effort) {
+            // Translate the unified tier to OpenAI's enum. `"off"` maps to
+            // `"none"` (OpenAI's spelling); `"max"` is not in OpenAI's enum, so
+            // we clamp to `"xhigh"` (the highest OpenAI tier).
+            const e = args.reasoning_effort;
+            const openaiEffort = e === "off" ? "none" : e === "max" ? "xhigh" : e;
+            openaiSettings.reasoning = { reasoning_effort: openaiEffort };
+        }
+        if (args.verbosity === "low" ||
+            args.verbosity === "medium" ||
+            args.verbosity === "high") {
+            // SDK type lags wire shape — `verbosity` is real on the server but not
+            // declared in `OpenAIModelSettings`. Letta Code sends it identically.
+            openaiSettings.verbosity = args.verbosity;
+        }
+        if (typeof args.strict === "boolean")
+            openaiSettings.strict = args.strict;
+        settings = openaiSettings;
+    }
+    else if (family === "anthropic") {
+        const anthropicSettings = {
+            provider_type: "anthropic",
+            parallel_tool_calls: true,
+        };
+        const e = args.reasoning_effort;
+        if (e === "low" || e === "medium" || e === "high" || e === "max") {
+            anthropicSettings.effort = e;
+        }
+        else if (e === "xhigh") {
+            anthropicSettings.effort = "max";
+        }
+        if (args.enable_reasoner !== undefined ||
+            typeof args.max_reasoning_tokens === "number") {
+            anthropicSettings.thinking = {
+                type: args.enable_reasoner === false ? "disabled" : "enabled",
+                ...(typeof args.max_reasoning_tokens === "number" && {
+                    budget_tokens: args.max_reasoning_tokens,
+                }),
+            };
+        }
+        if (typeof args.strict === "boolean")
+            anthropicSettings.strict = args.strict;
+        settings = anthropicSettings;
+    }
+    else if (family === "zai") {
+        settings = { provider_type: "zai", parallel_tool_calls: true };
+    }
+    else if (family === "google_ai" || family === "google_vertex") {
+        const baseSettings = {
+            provider_type: family,
+            parallel_tool_calls: true,
+        };
+        // Budget resolution priority:
+        //   1. Explicit `thinking_budget` (advanced callers / raw control).
+        //   2. Unified `reasoning_effort` tier — translated to a fraction of the
+        //      provider's max budget. This is the path the UI dropdown takes.
+        let resolvedBudget;
+        if (args.thinking_budget !== undefined) {
+            resolvedBudget = args.thinking_budget;
+        }
+        else if (args.reasoning_effort) {
+            // The unified effort enum includes "off" → budget 0; the conversion
+            // is done provider-aware so Anthropic/OpenAI tiers don't accidentally
+            // hit this path.
+            resolvedBudget = effortTierToThinkingBudget(modelHandle, args.reasoning_effort);
+        }
+        if (resolvedBudget !== undefined) {
+            baseSettings.thinking_config = { thinking_budget: resolvedBudget };
+        }
+        if (typeof args.temperature === "number") {
+            baseSettings.temperature = args.temperature;
+        }
+        settings = baseSettings;
+    }
+    else if (family === "bedrock") {
+        const bedrockSettings = {
+            provider_type: "bedrock",
+            parallel_tool_calls: true,
+        };
+        // SDK type lags wire shape for Bedrock — `effort` and `thinking` are
+        // real on the server (CLI sends them) but missing from `BedrockModelSettings`.
+        const e = args.reasoning_effort;
+        const bs = bedrockSettings;
+        if (e === "low" || e === "medium" || e === "high" || e === "max") {
+            bs.effort = e;
+        }
+        else if (e === "xhigh") {
+            bs.effort = "max";
+        }
+        if (args.enable_reasoner !== undefined ||
+            typeof args.max_reasoning_tokens === "number") {
+            bs.thinking = {
+                type: args.enable_reasoner === false ? "disabled" : "enabled",
+                ...(typeof args.max_reasoning_tokens === "number" && {
+                    budget_tokens: args.max_reasoning_tokens,
+                }),
+            };
+        }
+        settings = bedrockSettings;
+    }
+    else {
+        // OpenAI-compatible fallback (matches CLI's default branch).
+        const fallback = {
+            provider_type: "openai",
+            parallel_tool_calls: typeof args.parallel_tool_calls === "boolean"
+                ? args.parallel_tool_calls
+                : true,
+        };
+        if (typeof args.strict === "boolean")
+            fallback.strict = args.strict;
+        settings = fallback;
+    }
+    if (typeof args.max_output_tokens === "number" &&
+        "provider_type" in settings) {
+        settings.max_output_tokens =
+            args.max_output_tokens;
+    }
+    return settings;
+}
+/**
+ * Computes per-model reasoning capabilities from the model handle. Provider
+ * routing matches `buildModelSettings`; the per-field enums mirror Letta's
+ * SDK type definitions.
+ *
+ * @param modelHandle — provider-prefixed handle.
+ * @returns capability descriptor — empty object when no reasoning knobs apply.
+ */
+export function getReasoningCapabilities(modelHandle) {
+    const family = getProviderFamily(modelHandle);
+    switch (family) {
+        case "anthropic":
+        case "bedrock":
+            return {
+                effort: { enum: ["low", "medium", "high", "xhigh", "max"] },
+            };
+        case "openai":
+        case "openai_compatible":
+            return {
+                reasoning_effort: {
+                    enum: ["none", "minimal", "low", "medium", "high", "xhigh"],
+                },
+                verbosity: { enum: ["low", "medium", "high"] },
+            };
+        case "google_ai":
+        case "google_vertex":
+            // Unified UX: Google models expose the same "Reasoning" dropdown as
+            // Anthropic, with `off` mapped to budget=0 and the other tiers
+            // proportionally distributed up to the provider's max budget at
+            // request time (see `effortTierToThinkingBudget`). The numeric
+            // `thinking_budget` knob is still on the type for advanced wrappers
+            // that want raw control, but the default selector renders this
+            // dropdown instead.
+            return {
+                effort: { enum: ["off", "low", "medium", "high", "xhigh", "max"] },
+            };
+        case "zai":
+            return {};
+    }
+}
+//# sourceMappingURL=modelSettings.js.map

package/dist/letta/modelSettings.js.map

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

package/dist/letta/promptWrapping.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Recency-bias prompt-injection helpers for `streamUserMessage`.
+ *
+ * **What this is for.** Letta agents are configured in Letta ADE — a non-AI
+ * admin writes a plain system prompt there ("You are a Marketing Campaign
+ * Analyst…"). We can't ask that admin to think about prompt-injection
+ * safety, boundary tokens, or recency bias. So ai-hub takes the admin's
+ * prompt verbatim and, under the hood:
+ *
+ * 1. Appends a generic block of `CRITICAL SECURITY RULES` that tells the
+ *    LLM how to treat the boundary-tagged user content (don't follow
+ *    instructions inside it, don't trust XML tags inside it, etc.).
+ * 2. Wraps the combined string in `<system_instructions>…</system_instructions>`.
+ * 3. XML-escapes the user's typed input so they can't inject closing tags
+ *    or fake boundary markers.
+ * 4. Wraps the escaped user input in `<user_message boundary="MSG_xxx">…
+ *    </user_message boundary="MSG_xxx">` with a per-request unique boundary
+ *    token. The closing tag's `boundary="…"` is unusual but lets the LLM
+ *    pattern-match the closing tag against the opening one, making fake
+ *    closing tags inside the user content visibly mismatched.
+ * 5. Sends the whole concatenated blob as the *user-role* message to
+ *    Letta, paired with `override_system: "."` so Letta's compiled system
+ *    message (which would otherwise carry a `<memory_metadata>` block and
+ *    other scaffolding) doesn't reach the LLM at all.
+ *
+ * **Why this works better than a separate system role message.** Empirical
+ * finding from a related project: LLMs pay the most attention to the most
+ * recent turn and drift away from front-of-conversation instructions as
+ * the dialogue grows. Re-injecting the full prompt into every user turn
+ * pins the instructions back to the front of attention every time.
+ * Precision went from ~50% → ~100% on a goal-adherence task by switching
+ * to this pattern.
+ *
+ * **What ADE admins see.** Nothing different. They write their prompt in
+ * Letta ADE the normal way; the wrapping is transparent.
+ *
+ * **What ai-hub UI viewers see.** Nothing different either — the messages
+ * route auto-strips the wrapping at render time (see
+ * `routes/sessions.ts` and `db/schema.ts#message_override`), so the chat
+ * transcript shows the original user text and admin's prompt cleanly.
+ */
+/**
+ * Escapes the three XML characters that could let a user break out of the
+ * `<user_message>` wrapper or inject lookalike tags:
+ *
+ * - `&` → `&amp;` (must be first so we don't double-escape the others)
+ * - `<` → `&lt;`
+ * - `>` → `&gt;`
+ *
+ * We deliberately do NOT escape quotes — the boundary attribute uses
+ * double quotes and we don't include any user-controlled values inside
+ * attributes, so single/double quotes inside the content are safe to
+ * leave as-is. Keeping quotes unescaped makes the chat UI's reverse
+ * (un-escape on display) a no-op for the common case.
+ *
+ * Idempotent on already-escaped strings? No — `&amp;` would become
+ * `&amp;amp;`. Callers must escape exactly once, at the wrap step. The
+ * matching `unescapeUserInput` function in `routes/sessions.ts` reverses
+ * it for display.
+ *
+ * @param input - raw user text from the chat request.
+ * @returns the same text with `&`, `<`, `>` HTML-entity-escaped.
+ */
+export declare function escapeUserInput(input: string): string;
+/**
+ * Reverses `escapeUserInput` for chat-UI display. Substitutes the three
+ * entities back to their literal characters, in the reverse order so
+ * `&amp;lt;` (which a user could conceivably have typed before we
+ * escaped) round-trips correctly.
+ *
+ * @param escaped - text previously produced by `escapeUserInput`.
+ * @returns the original text with entities decoded.
+ */
+export declare function unescapeUserInput(escaped: string): string;
+/**
+ * Generates a fresh per-request boundary token. The format is
+ * `MSG_<32-char hex>` — a UUID with the dashes stripped, prefixed for
+ * human readability in logs / Letta history.
+ *
+ * The token is high-entropy by construction (UUIDv4 ≈ 122 bits), so a
+ * user who wanted to forge a closing tag with the right boundary value
+ * would need to guess it. Combined with the rule that the LLM must
+ * treat mismatched closing tags as untrusted, this makes
+ * boundary-bypass attacks effectively impossible from inside the chat
+ * input.
+ *
+ * @returns a fresh boundary token like `MSG_3fa395bfc67d4b3d859a71a2ee2774f2`.
+ */
+export declare function makeBoundary(): string;
+/** Result of `buildWrappedUserMessage`. */
+export interface WrappedUserMessage {
+    /** The fully-assembled string to send as the user-role message to Letta. */
+    wrapped: string;
+    /** The boundary token used in this wrap — logged for audit / debugging. */
+    boundary: string;
+}
+/**
+ * Assembles the full wrapped user message:
+ *
+ * ```
+ * <system_instructions>
+ * {admin's system prompt verbatim}
+ *
+ * {generic security rules with {boundary} substituted}
+ * </system_instructions>
+ *
+ * <user_message boundary="MSG_xxx">{escaped user input}</user_message boundary="MSG_xxx">
+ * ```
+ *
+ * Pair the output with `override_system: "."` on the Letta request — that
+ * tells Letta to bypass its compiled system message so the LLM only sees
+ * this wrapped user content as its turn.
+ *
+ * @param agentSystemPrompt - the admin-authored prompt from Letta ADE
+ *   (resolved via `LettaClient.getAgentSystemPrompt`). Inserted verbatim
+ *   — the admin controls this string. No escaping (it isn't user input).
+ * @param userMessage - the raw user message text from the chat request.
+ *   Escaped before insertion.
+ * @returns the wrapped string and the boundary token used.
+ */
+export declare function buildWrappedUserMessage(agentSystemPrompt: string, userMessage: string): WrappedUserMessage;
+/**
+ * Reverses `buildWrappedUserMessage` for chat-UI display. Returns the
+ * un-escaped inner user content, or `null` if the input doesn't match
+ * the wrapped shape (so callers can fall through to "display as-is").
+ *
+ * @param wrapped - the string Letta returned as the user-role message
+ *   content for a turn we wrapped on send.
+ * @returns the original user text, or `null` for non-wrapped content.
+ */
+export declare function unwrapUserMessage(wrapped: string): string | null;
+/**
+ * Removes Letta's `<memory_metadata>` block from a system-message content
+ * string for display purposes. Idempotent on already-clean strings.
+ *
+ * @param content - the raw `system_message` content from Letta.
+ * @returns the same content with the trailing memory_metadata block
+ *   (and any whitespace separating it from the prompt body) stripped.
+ */
+export declare function stripMemoryMetadata(content: string): string;
+//# sourceMappingURL=promptWrapping.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"promptWrapping.d.ts","sourceRoot":"","sources":["../../src/letta/promptWrapping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AA6BH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKrD;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAKzD;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAMD,2CAA2C;AAC3C,MAAM,WAAW,kBAAkB;IACjC,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,uBAAuB,CACrC,iBAAiB,EAAE,MAAM,EACzB,WAAW,EAAE,MAAM,GAClB,kBAAkB,CAWpB;AAmBD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAIhE;AAaD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE3D"}