@ai-matrx/agents 0.59.228 → 0.59.230

package/dist/quick/index.cjs

@@ -20,49 +20,205 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // quick/index.ts
 var quick_exports = {};
 __export(quick_exports, {
-  QUICK_AGENT_BOUNDS: () => QUICK_AGENT_BOUNDS,
-  QUICK_AGENT_DEFAULT_SETTINGS: () => QUICK_AGENT_DEFAULT_SETTINGS,
   QUICK_AGENT_KIND: () => QUICK_AGENT_KIND,
+  QUICK_AGENT_KNOBS: () => QUICK_AGENT_KNOBS,
   QUICK_AGENT_TAG: () => QUICK_AGENT_TAG,
-  buildQuickAgentRow: () => buildQuickAgentRow,
-  buildQuickAgentUpdate: () => buildQuickAgentUpdate,
   clampQuickAgentSettings: () => clampQuickAgentSettings,
-  createQuickAgent: () => createQuickAgent,
-  deleteQuickAgent: () => deleteQuickAgent,
+  defaultQuickAgentSettings: () => defaultQuickAgentSettings,
   isQuickAgentSummary: () => isQuickAgentSummary,
   listMyQuickAgents: () => listMyQuickAgents,
+  listQuickAgents: () => listQuickAgents,
+  quickAgentFields: () => quickAgentFields,
   quickAgentFromRow: () => quickAgentFromRow,
   quickAgentMessages: () => quickAgentMessages,
   quickAgentProblems: () => quickAgentProblems,
   quickAgentSettingsJson: () => quickAgentSettingsJson,
   readQuickAgent: () => readQuickAgent,
-  updateQuickAgent: () => updateQuickAgent,
+  resolveQuickAgentLimits: () => resolveQuickAgentLimits,
+  sliderStep: () => sliderStep,
   withoutQuickAgents: () => withoutQuickAgents
 });
 module.exports = __toCommonJS(quick_exports);
 
+// catalog/selectors.ts
+function memoize1(fn) {
+  let lastA;
+  let last;
+  let has = false;
+  return (a) => {
+    if (!has || lastA !== a) {
+      last = fn(a);
+      lastA = a;
+      has = true;
+    }
+    return last;
+  };
+}
+function memoize2(fn) {
+  let lastA;
+  let lastB;
+  let last;
+  let has = false;
+  return (a, b) => {
+    if (!has || lastA !== a || lastB !== b) {
+      last = fn(a, b);
+      lastA = a;
+      lastB = b;
+      has = true;
+    }
+    return last;
+  };
+}
+var selectAllAgentCategories = memoize1(
+  (agents) => {
+    const cats = /* @__PURE__ */ new Set();
+    for (const a of agents) {
+      if (a.agentType === "user" && a.category) cats.add(a.category);
+    }
+    return Array.from(cats).sort();
+  }
+);
+var selectAllSystemAgentCategories = memoize1(
+  (agents) => {
+    const cats = /* @__PURE__ */ new Set();
+    for (const a of agents) {
+      if (a.agentType === "builtin" && a.category) cats.add(a.category);
+    }
+    return Array.from(cats).sort();
+  }
+);
+var selectAllAgentTags = memoize1(
+  (agents) => {
+    const tags = /* @__PURE__ */ new Set();
+    for (const a of agents) {
+      if (a.agentType === "user") a.tags?.forEach((t) => tags.add(t));
+    }
+    return Array.from(tags).sort();
+  }
+);
+var selectAllSystemAgentTags = memoize1(
+  (agents) => {
+    const tags = /* @__PURE__ */ new Set();
+    for (const a of agents) {
+      if (a.agentType === "builtin") a.tags?.forEach((t) => tags.add(t));
+    }
+    return Array.from(tags).sort();
+  }
+);
+var selectUserTypeAgents = memoize1(
+  (agents) => agents.filter((a) => a.agentType === "user")
+);
+var selectBuiltinTypeAgents = memoize1(
+  (agents) => agents.filter((a) => a.agentType === "builtin")
+);
+function agentMatchesArchiveFilter(agent, archFilter) {
+  if (archFilter === "active") return !agent.isArchived;
+  if (archFilter === "archived") return Boolean(agent.isArchived);
+  return true;
+}
+function countBuiltinRows(agents, archFilter) {
+  let n = 0;
+  for (const a of agents) {
+    if (a.agentType !== "builtin") continue;
+    if (!agentMatchesArchiveFilter(a, archFilter)) continue;
+    n += 1;
+  }
+  return n;
+}
+function countUserRows(agents, archFilter, predicate) {
+  let n = 0;
+  for (const a of agents) {
+    if (a.agentType !== "user") continue;
+    if (!agentMatchesArchiveFilter(a, archFilter)) continue;
+    if (predicate(a)) n += 1;
+  }
+  return n;
+}
+var isOwned = (a) => a.isOwner === true;
+var isShared = (a) => a.isOwner === false && a.accessLevel != null;
+var isAny = () => true;
+var isFavorite = (a) => Boolean(a.isFavorite);
+var selectAgentTabCounts = memoize2(
+  (agents, archFilter) => ({
+    mine: countUserRows(agents, archFilter, isOwned),
+    shared: countUserRows(agents, archFilter, isShared),
+    all: countUserRows(agents, archFilter, isAny),
+    system: countBuiltinRows(agents, archFilter)
+  })
+);
+var selectTotalUserAgentsCount = memoize1(
+  (agents) => countUserRows(agents, "active", isAny)
+);
+var selectTotalOwnedAgentsCount = memoize1(
+  (agents) => countUserRows(agents, "active", isOwned)
+);
+var selectTotalSharedAgentsCount = memoize1(
+  (agents) => countUserRows(agents, "active", isShared)
+);
+var selectTotalBuiltinAgentsCount = memoize1(
+  (agents) => countBuiltinRows(agents, "active")
+);
+var selectTotalFavoriteAgentsCount = memoize1(
+  (agents) => countUserRows(agents, "active", isFavorite)
+);
+
 // quick/shape.ts
 var QUICK_AGENT_KIND = "quick";
 var QUICK_AGENT_TAG = "kind:quick";
-var QUICK_AGENT_BOUNDS = {
-  temperature: { min: 0, max: 2, step: 0.1 },
-  topP: { min: 0, max: 1, step: 0.05 },
-  maxOutputTokens: { min: 256, max: 32768, step: 256 }
+var QUICK_AGENT_KNOBS = {
+  temperatureMax: { feature: "agents.quick", key: "temperature_max" },
+  temperatureDefault: { feature: "agents.quick", key: "temperature_default" },
+  topPDefault: { feature: "agents.quick", key: "top_p_default" },
+  maxOutputMin: { feature: "agents.quick", key: "max_output_min" },
+  maxOutputMax: { feature: "agents.quick", key: "max_output_max" },
+  maxOutputDefault: { feature: "agents.quick", key: "max_output_default" }
 };
-var QUICK_AGENT_DEFAULT_SETTINGS = Object.freeze({
-  temperature: 0.7,
-  topP: 1,
-  maxOutputTokens: 4096
-});
+var isNum = (v) => typeof v === "number" && Number.isFinite(v);
+function sliderStep(min, max) {
+  const raw = (max - min) / 100;
+  if (!(raw > 0)) return 1;
+  const pow = 10 ** Math.floor(Math.log10(raw));
+  const unit = raw / pow;
+  const nice = unit <= 1 ? 1 : unit <= 2 ? 2 : unit <= 5 ? 5 : 10;
+  return Number((nice * pow).toPrecision(6));
+}
+function limit(min, max, rest, whole) {
+  const step = whole ? Math.max(1, Math.round(sliderStep(min, max))) : sliderStep(min, max);
+  return { min, max, step, default: Math.min(max, Math.max(min, rest)) };
+}
+function resolveQuickAgentLimits(model, knobs) {
+  const t = model?.temperature;
+  const p = model?.top_p;
+  const m = model?.max_output_tokens;
+  const tMin = isNum(t?.min) ? t.min : 0;
+  const tMax = isNum(t?.max) ? t.max : knobs.temperatureMax;
+  const tRest = isNum(t?.default) ? t.default : knobs.temperatureDefault;
+  const pMin = isNum(p?.min) ? p.min : 0;
+  const pMax = isNum(p?.max) ? p.max : 1;
+  const pRest = isNum(p?.default) ? p.default : knobs.topPDefault;
+  const mMin = isNum(m?.min) ? m.min : knobs.maxOutputMin;
+  const mMax = isNum(m?.max) ? m.max : knobs.maxOutputMax;
+  const mRest = isNum(m?.default) ? m.default : knobs.maxOutputDefault;
+  if (!isNum(tMax) || !isNum(tRest) || !isNum(pRest) || !isNum(mMin) || !isNum(mMax) || !isNum(mRest)) return null;
+  if (tMax <= tMin || pMax <= pMin || mMax <= mMin) return null;
+  return {
+    temperature: limit(tMin, tMax, tRest, false),
+    topP: limit(pMin, pMax, pRest, false),
+    maxOutputTokens: limit(mMin, mMax, mRest, true)
+  };
+}
+function defaultQuickAgentSettings(limits) {
+  return { temperature: limits.temperature.default, topP: limits.topP.default, maxOutputTokens: limits.maxOutputTokens.default };
+}
 function clamp(value, bound) {
   if (!Number.isFinite(value)) return bound.min;
   return Math.min(bound.max, Math.max(bound.min, value));
 }
-function clampQuickAgentSettings(settings) {
+function clampQuickAgentSettings(settings, limits) {
   return {
-    temperature: clamp(settings.temperature, QUICK_AGENT_BOUNDS.temperature),
-    topP: clamp(settings.topP, QUICK_AGENT_BOUNDS.topP),
-    maxOutputTokens: Math.round(clamp(settings.maxOutputTokens, QUICK_AGENT_BOUNDS.maxOutputTokens))
+    temperature: clamp(settings.temperature, limits.temperature),
+    topP: clamp(settings.topP, limits.topP),
+    maxOutputTokens: Math.round(clamp(settings.maxOutputTokens, limits.maxOutputTokens))
   };
 }
 function quickAgentProblems(def) {
@@ -73,44 +229,31 @@ function quickAgentProblems(def) {
   return problems;
 }
 function quickAgentSettingsJson(settings) {
-  const s = clampQuickAgentSettings(settings);
-  return { stream: true, temperature: s.temperature, top_p: s.topP, max_output_tokens: s.maxOutputTokens };
+  return { stream: true, temperature: settings.temperature, top_p: settings.topP, max_output_tokens: settings.maxOutputTokens };
 }
 function quickAgentMessages(systemPrompt) {
   return [{ role: "system", content: [{ type: "text", text: systemPrompt }] }];
 }
-function buildQuickAgentRow(def, owner) {
+function quickAgentFields(def) {
   return {
-    agent_type: "user",
     name: def.name.trim(),
-    description: null,
     tags: [QUICK_AGENT_TAG],
-    is_active: true,
-    is_archived: false,
-    model_id: def.modelId,
+    isActive: true,
+    isArchived: false,
+    modelId: def.modelId,
     messages: quickAgentMessages(def.systemPrompt),
     settings: quickAgentSettingsJson(def.settings),
-    tools: [],
-    metadata: { kind: QUICK_AGENT_KIND },
-    created_by: owner.userId,
-    organization_id: owner.organizationId
-  };
-}
-function buildQuickAgentUpdate(def) {
-  return {
-    name: def.name.trim(),
-    model_id: def.modelId,
-    messages: quickAgentMessages(def.systemPrompt),
-    settings: quickAgentSettingsJson(def.settings)
+    tools: []
   };
 }
 function num(value, fallback) {
   return typeof value === "number" && Number.isFinite(value) ? value : fallback;
 }
-function quickAgentFromRow(row) {
+function quickAgentFromRow(row, defaults) {
   if (!row) return null;
   const metadata = row["metadata"];
-  if (metadata?.["kind"] !== QUICK_AGENT_KIND) return null;
+  const tags = Array.isArray(row["tags"]) ? row["tags"] : [];
+  if (metadata?.["kind"] !== QUICK_AGENT_KIND && !tags.includes(QUICK_AGENT_TAG)) return null;
   const messages = Array.isArray(row["messages"]) ? row["messages"] : [];
   const system = messages.find((m) => m["role"] === "system");
   const parts = Array.isArray(system?.["content"]) ? system?.["content"] : [];
@@ -121,55 +264,35 @@ function quickAgentFromRow(row) {
     name: typeof row["name"] === "string" ? row["name"] : "",
     systemPrompt,
     modelId: typeof row["model_id"] === "string" ? row["model_id"] : "",
-    settings: clampQuickAgentSettings({
-      temperature: num(raw["temperature"], QUICK_AGENT_DEFAULT_SETTINGS.temperature),
-      topP: num(raw["top_p"], QUICK_AGENT_DEFAULT_SETTINGS.topP),
-      maxOutputTokens: num(raw["max_output_tokens"], QUICK_AGENT_DEFAULT_SETTINGS.maxOutputTokens)
-    })
+    settings: {
+      temperature: num(raw["temperature"], defaults.temperature),
+      topP: num(raw["top_p"], defaults.topP),
+      maxOutputTokens: num(raw["max_output_tokens"], defaults.maxOutputTokens)
+    }
   };
 }
 function isQuickAgentSummary(row) {
   return row.tags.includes(QUICK_AGENT_TAG);
 }
+function listQuickAgents(rows, userId) {
+  const live = (row) => isQuickAgentSummary(row) && !row.isArchived && row.isActive !== false;
+  const user = selectUserTypeAgents(rows).filter(live);
+  const mine = userId ? user.filter((row) => row.createdBy === userId) : [];
+  const organization = user.filter((row) => !mine.includes(row));
+  const system = selectBuiltinTypeAgents(rows).filter(live);
+  return { mine, organization, system };
+}
 function listMyQuickAgents(rows, userId) {
-  if (!userId) return [];
-  return rows.filter((row) => isQuickAgentSummary(row) && row.createdBy === userId && !row.isArchived && row.isActive !== false);
+  const lanes = listQuickAgents(rows, userId);
+  return [...lanes.mine, ...lanes.organization, ...lanes.system];
 }
 function withoutQuickAgents(rows) {
   return rows.filter((row) => !isQuickAgentSummary(row));
 }
 
-// quick/writes.ts
-function refuse(def) {
-  const problems = quickAgentProblems(def);
-  if (problems.length > 0) throw new Error(problems[0]);
-}
-function fail(error) {
-  throw new Error(error?.message ?? "The agent could not be saved.");
-}
-var table = (client) => client.schema("agent").from("definition");
-async function createQuickAgent(client, def, owner) {
-  refuse(def);
-  const { data, error } = await table(client).insert(buildQuickAgentRow(def, owner)).select().single();
-  if (error) fail(error);
-  const saved = quickAgentFromRow(data);
-  if (!saved) fail(null);
-  return saved;
-}
-async function updateQuickAgent(client, id, def) {
-  refuse(def);
-  const { data, error } = await table(client).update(buildQuickAgentUpdate(def)).eq("id", id).select().single();
-  if (error) fail(error);
-  const saved = quickAgentFromRow(data);
-  if (!saved) fail(null);
-  return saved;
-}
-async function deleteQuickAgent(client, id) {
-  const { error } = await table(client).update({ deleted_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", id);
-  if (error) fail(error);
-}
-async function readQuickAgent(client, id) {
-  const { data, error } = await table(client).select("id,name,model_id,messages,settings,metadata").eq("id", id).is("deleted_at", null).maybeSingle();
-  if (error) fail(error);
-  return quickAgentFromRow(data);
+// quick/reads.ts
+async function readQuickAgent(client, id, defaults) {
+  const { data, error } = await client.schema("agent").from("definition").select("id,name,model_id,messages,settings,tags,metadata").eq("id", id).is("deleted_at", null).maybeSingle();
+  if (error) throw new Error(error.message ?? "The agent could not be read.");
+  return quickAgentFromRow(data, defaults);
 }

package/dist/quick/index.d.cts

@@ -6,12 +6,13 @@ import { A as AgentSummary } from '../types-DZhDqrVE.cjs';
  * A quick agent is a named bundle of exactly: name, system prompt, model and three settings
  * (temperature, top-p, max output tokens). It is an ordinary `agent.definition` row — one agent
  * table, one permission model, no second prompt store — marked `kind: quick` so the big catalog
- * can hide or group it. This entry owns the shape and the pure builders/selectors; `./writes`
- * owns the four database calls (the one named write allowlist entry of this package).
+ * can hide or group it. This entry owns the shape and the pure builders/selectors; the WRITES go
+ * through chat's one agent-definition write path (`agents/redux/agent-definition/definition-writes`),
+ * never a second one here.
  *
- * The marker lives in two places on purpose: `metadata.kind = "quick"` is the record's own
- * statement; the `kind:quick` tag rides every catalog row (the catalog read carries tags, not
- * metadata), so a list can filter without a second read — exactly how `chat-agent` marks presets.
+ * The marker is the `kind:quick` tag: it rides every catalog row, so a list can filter without a
+ * second read — exactly how `chat-agent` marks presets. (Rows saved before the shared write path also
+ * carry `metadata.kind = "quick"`; both read as quick.)
  */
 
 declare const QUICK_AGENT_KIND: "quick";
@@ -34,26 +35,81 @@ interface QuickAgentDefinition {
 interface QuickAgent extends QuickAgentDefinition {
     id: string;
 }
-declare const QUICK_AGENT_BOUNDS: {
-    readonly temperature: {
-        readonly min: 0;
-        readonly max: 2;
-        readonly step: 0.1;
+/** One setting's slider: where it starts, where it stops, where a new agent rests. */
+interface QuickAgentSettingLimit {
+    min: number;
+    max: number;
+    step: number;
+    default: number;
+}
+interface QuickAgentLimits {
+    temperature: QuickAgentSettingLimit;
+    topP: QuickAgentSettingLimit;
+    maxOutputTokens: QuickAgentSettingLimit;
+}
+/** A model's own settings row for one control (`ai.model` controls: min / max / default), when it states one. */
+interface ModelSettingRow {
+    min?: number | null | undefined;
+    max?: number | null | undefined;
+    default?: unknown;
+}
+/** The chosen model's settings rows for the three controls; a control it does not state is absent. */
+interface ModelSettingRows {
+    temperature?: ModelSettingRow | null | undefined;
+    top_p?: ModelSettingRow | null | undefined;
+    max_output_tokens?: ModelSettingRow | null | undefined;
+}
+/**
+ * The `agents.quick` knob values (organization and person can set them). `undefined` = the register
+ * has not answered yet. A probability lives in 0..1 and a temperature starts at 0 by definition;
+ * every other bound and every default is a knob.
+ */
+interface QuickAgentKnobValues {
+    temperatureMax?: unknown;
+    temperatureDefault?: unknown;
+    topPDefault?: unknown;
+    maxOutputMin?: unknown;
+    maxOutputMax?: unknown;
+    maxOutputDefault?: unknown;
+}
+declare const QUICK_AGENT_KNOBS: {
+    readonly temperatureMax: {
+        readonly feature: "agents.quick";
+        readonly key: "temperature_max";
+    };
+    readonly temperatureDefault: {
+        readonly feature: "agents.quick";
+        readonly key: "temperature_default";
+    };
+    readonly topPDefault: {
+        readonly feature: "agents.quick";
+        readonly key: "top_p_default";
+    };
+    readonly maxOutputMin: {
+        readonly feature: "agents.quick";
+        readonly key: "max_output_min";
     };
-    readonly topP: {
-        readonly min: 0;
-        readonly max: 1;
-        readonly step: 0.05;
+    readonly maxOutputMax: {
+        readonly feature: "agents.quick";
+        readonly key: "max_output_max";
     };
-    readonly maxOutputTokens: {
-        readonly min: 256;
-        readonly max: 32768;
-        readonly step: 256;
+    readonly maxOutputDefault: {
+        readonly feature: "agents.quick";
+        readonly key: "max_output_default";
     };
 };
-declare const QUICK_AGENT_DEFAULT_SETTINGS: QuickAgentSettings;
-/** Settings pulled inside their bounds (a slider can never save a value the model refuses). */
-declare function clampQuickAgentSettings(settings: QuickAgentSettings): QuickAgentSettings;
+/** A slider step that gives ~100 positions over the range, on a 1 / 2 / 5 grid (0.02 -> 0.05 style). */
+declare function sliderStep(min: number, max: number): number;
+/**
+ * THE ONE SOURCE of the three sliders' bounds and resting values: the chosen model's own settings
+ * rows where it states them, else the `agents.quick` knobs. `null` until every number is known (the
+ * panel shows no slider for a number nobody has answered — there is no code default).
+ */
+declare function resolveQuickAgentLimits(model: ModelSettingRows | null | undefined, knobs: QuickAgentKnobValues): QuickAgentLimits | null;
+/** A new agent's settings: every slider at its resting value. */
+declare function defaultQuickAgentSettings(limits: QuickAgentLimits): QuickAgentSettings;
+/** Settings pulled inside their limits (a slider can never save a value the model refuses). */
+declare function clampQuickAgentSettings(settings: QuickAgentSettings, limits: QuickAgentLimits): QuickAgentSettings;
 /** What stops a save, in words — empty when the definition is saveable. */
 declare function quickAgentProblems(def: Pick<QuickAgentDefinition, "name" | "systemPrompt" | "modelId">): string[];
 interface QuickAgentSystemMessage {
@@ -66,28 +122,44 @@ interface QuickAgentSystemMessage {
 /** The persisted `settings` JSON: the three params plus the stream flag every agent row carries. */
 declare function quickAgentSettingsJson(settings: QuickAgentSettings): Record<string, unknown>;
 declare function quickAgentMessages(systemPrompt: string): QuickAgentSystemMessage[];
-/** The `agent.definition` insert for a new quick agent. Born active; no tools, variables or context. */
-declare function buildQuickAgentRow(def: QuickAgentDefinition, owner: {
-    organizationId: string;
-    userId: string;
-}): Record<string, unknown>;
-/** The `agent.definition` update for an edit: only the four things a quick agent has. */
-declare function buildQuickAgentUpdate(def: QuickAgentDefinition): Record<string, unknown>;
-/** A stored row read back as a quick agent; `null` when the row is not one. */
-declare function quickAgentFromRow(row: Record<string, unknown> | null | undefined): QuickAgent | null;
+/**
+ * The agent fields a quick agent sets, in the shape of the ONE agent-definition write path
+ * (chat `definition-writes`): name + system message + model + the three settings, marked quick, no
+ * tools. Nothing else is ever part of a quick agent.
+ */
+declare function quickAgentFields(def: QuickAgentDefinition): {
+    name: string;
+    tags: string[];
+    isActive: true;
+    isArchived: false;
+    modelId: string;
+    messages: QuickAgentSystemMessage[];
+    settings: Record<string, unknown>;
+    tools: never[];
+};
+/**
+ * A stored row read back as a quick agent; `null` when the row is not one. A setting the row does
+ * not carry rests at `defaults` (the resolved limits' resting values).
+ */
+declare function quickAgentFromRow(row: Record<string, unknown> | null | undefined, defaults: QuickAgentSettings): QuickAgent | null;
 declare function isQuickAgentSummary(row: Pick<AgentSummary, "tags">): boolean;
 /**
- * THE PERSONAL LIST: the person's own, live quick agents out of the ONE catalog read.
- * (Org and system lanes are the catalogue's own tabs; this is "mine".)
+ * THE QUICK-AGENT LIST in the platform's visibility lanes: mine, then my organization's, then the
+ * system's (the catalog's own user-type / builtin split; "mine" is what the person created).
  */
+declare function listQuickAgents(rows: readonly AgentSummary[], userId: string | null): {
+    mine: AgentSummary[];
+    organization: AgentSummary[];
+    system: AgentSummary[];
+};
+/** The pill's list: mine, then organization, then system. */
 declare function listMyQuickAgents(rows: readonly AgentSummary[], userId: string | null): AgentSummary[];
 /** The big catalogue's view: quick agents leave the general list (a filter, never a delete). */
 declare function withoutQuickAgents<T extends Pick<AgentSummary, "tags">>(rows: readonly T[]): T[];
 
 /**
- * The four database calls of a quick agent, over the EXISTING `agent.definition` table.
- * The only write entry of this package besides favorites (check-agents-below-chat WRITE_ALLOWLIST).
- * The client is the host's own RLS-bound Supabase client; nothing here knows how it was built.
+ * The one READ of a quick agent: its full definition (the catalog row carries no prompt). Reads
+ * only; every write goes through chat's one agent-definition write path.
  */
 
 interface QuickAgentClient {
@@ -95,14 +167,7 @@ interface QuickAgentClient {
         from(table: "definition"): any;
     };
 }
-declare function createQuickAgent(client: QuickAgentClient, def: QuickAgentDefinition, owner: {
-    organizationId: string;
-    userId: string;
-}): Promise<QuickAgent>;
-declare function updateQuickAgent(client: QuickAgentClient, id: string, def: QuickAgentDefinition): Promise<QuickAgent>;
-/** Soft delete — the same `deleted_at` every agent delete sets, so every list already hides it. */
-declare function deleteQuickAgent(client: QuickAgentClient, id: string): Promise<void>;
-/** One quick agent's full definition (the catalog row carries no prompt). */
-declare function readQuickAgent(client: QuickAgentClient, id: string): Promise<QuickAgent | null>;
+/** One quick agent's full definition; settings the row lacks rest at `defaults`. */
+declare function readQuickAgent(client: QuickAgentClient, id: string, defaults: QuickAgentSettings): Promise<QuickAgent | null>;
 
-export { QUICK_AGENT_BOUNDS, QUICK_AGENT_DEFAULT_SETTINGS, QUICK_AGENT_KIND, QUICK_AGENT_TAG, type QuickAgent, type QuickAgentClient, type QuickAgentDefinition, type QuickAgentSettings, type QuickAgentSystemMessage, buildQuickAgentRow, buildQuickAgentUpdate, clampQuickAgentSettings, createQuickAgent, deleteQuickAgent, isQuickAgentSummary, listMyQuickAgents, quickAgentFromRow, quickAgentMessages, quickAgentProblems, quickAgentSettingsJson, readQuickAgent, updateQuickAgent, withoutQuickAgents };
+export { type ModelSettingRow, type ModelSettingRows, QUICK_AGENT_KIND, QUICK_AGENT_KNOBS, QUICK_AGENT_TAG, type QuickAgent, type QuickAgentClient, type QuickAgentDefinition, type QuickAgentKnobValues, type QuickAgentLimits, type QuickAgentSettingLimit, type QuickAgentSettings, type QuickAgentSystemMessage, clampQuickAgentSettings, defaultQuickAgentSettings, isQuickAgentSummary, listMyQuickAgents, listQuickAgents, quickAgentFields, quickAgentFromRow, quickAgentMessages, quickAgentProblems, quickAgentSettingsJson, readQuickAgent, resolveQuickAgentLimits, sliderStep, withoutQuickAgents };