@babav/knowledge-core-client 0.42.0 → 0.43.0

package/dist/index.d.ts

@@ -215,7 +215,7 @@ export interface Corpus {
 /** Build-time knob bundle that DEFINES an index. Defaults are today's blessed config, so a
  *  profile created with no params is the blessed profile. Change any knob => different vectors
  *  => a different physical collection. Embedding/indexing/chunking is SYSTEM-level, never a
- *  query knob — this is the build-side counterpart to an Agent, not an agent. */
+ *  query knob — this is the build-side counterpart to a query profile. */
 export interface IngestionProfileParams {
     chunker: string;
     chunk_child_max_tokens: number;
@@ -477,7 +477,7 @@ export interface Conversation {
 export interface Message {
     id: UUID;
     conversation_id: UUID;
-    agent_id: UUID | null;
+    query_profile_id: UUID | null;
     corpus_ids: UUID[] | null;
     query: string;
     answer: string | null;
@@ -506,7 +506,7 @@ export interface Feedback {
     rating: number | null;
     comment: string | null;
 }
-export interface Agent {
+export interface QueryProfile {
     id: UUID;
     tenant_id: UUID;
     name: string;
@@ -543,8 +543,8 @@ export interface Agent {
  *  (null/omit => server default); model fields must be one of
  *  `agents.modelOptions().fields[field].supported`. The owning tenant is the caller's key —
  *  it is never part of the body. */
-export type AgentWrite = Partial<Omit<Agent, "id" | "tenant_id">>;
-/** Model catalog for the agent-config UI (GET /v1/agents/model-options). `models` maps id → its
+export type QueryProfileWrite = Partial<Omit<QueryProfile, "id" | "tenant_id">>;
+/** Model catalog for the query-profile-config UI (GET /v1/query-profiles/model-options). `models` maps id → its
  *  capabilities; `fields` gives each agent model-field its supported ids + default (+ usage metadata);
  *  `modes` says which model field governs each mode (reasoning is valid only if that model's
  *  supports_reasoning is true). KC provides the data; the UI decides presentation. */
@@ -686,11 +686,11 @@ export interface DocumentEventHandlers {
 export declare class KnowledgeCoreClient extends HttpBase {
     /** @param opts.apiKey a TENANT key, supplied by the caller. */
     constructor(opts: ClientOptions);
-    query(agentId: UUID, body: QueryRequest): Promise<QueryResponse>;
+    query(profileId: UUID, body: QueryRequest): Promise<QueryResponse>;
     /** Streaming query (SSE). Resolves when the stream ends (the Promise resolving is normal, not an
      *  error). Pass `signal` and abort() on unmount / when the user cancels or navigates away so the
      *  connection doesn't linger. Transient (ends on `done`) — no reopen logic needed. */
-    queryStream(agentId: UUID, body: QueryRequest, handlers: StreamHandlers, signal?: AbortSignal): Promise<void>;
+    queryStream(profileId: UUID, body: QueryRequest, handlers: StreamHandlers, signal?: AbortSignal): Promise<void>;
     /** Fetch a visual's PNG bytes BY ID. This is the ONLY way to get a visual image — the API never
      *  returns a URL. Authenticated + tenant-scoped like every call. Use `visual.id` from a query
      *  response / streamed `visual` event / persisted message. Returns a Blob (browser: `URL.
@@ -708,11 +708,11 @@ export declare class KnowledgeCoreClient extends HttpBase {
     /** DUMMY-PROOF CHAT. Every message goes through a conversation — it is structurally impossible
      *  to send a chat turn as a non-persisted one-shot. Use this for ANY chat UI. Use the low-level
      *  `query`/`queryStream` ONLY for programmatic one-shots (tools).
-     *    New chat:  const chat = kc.chat(agentId, corpusIds);
-     *    Resume:    const chat = kc.chat(agentId, corpusIds, { conversationId });
+     *    New chat:  const chat = kc.chat(profileId, corpusIds);
+     *    Resume:    const chat = kc.chat(profileId, corpusIds, { conversationId });
      *  The conversation is created LAZILY on the first `send()` (opening a "new chat" and never
      *  sending leaves nothing behind). See ChatSession.send. */
-    chat(agentId: UUID, corpusIds: UUID[], opts?: {
+    chat(profileId: UUID, corpusIds: UUID[], opts?: {
         conversationId?: UUID;
     }): ChatSession;
     /** Shared SSE reader for the document-status streams (documents.events / folders.events).
@@ -984,25 +984,25 @@ export declare class KnowledgeCoreClient extends HttpBase {
         get: (id: UUID) => Promise<Feedback>;
         delete: (id: UUID) => Promise<void>;
     };
-    agents: {
-        /** List this tenant's agents. */
+    queryProfiles: {
+        /** List this tenant's query profiles. */
         list: (q?: {
             limit?: number;
             cursor?: string;
-        }) => Promise<Page<Agent>>;
-        listAll: () => Promise<Agent[]>;
-        get: (id: UUID) => Promise<Agent>;
-        /** Create an agent owned by this tenant (the owning tenant is the key's — no tenant_id in the body). */
-        create: (b: AgentWrite & {
+        }) => Promise<Page<QueryProfile>>;
+        listAll: () => Promise<QueryProfile[]>;
+        get: (id: UUID) => Promise<QueryProfile>;
+        /** Create a query profile owned by this tenant (the owning tenant is the key's — no tenant_id in the body). */
+        create: (b: QueryProfileWrite & {
             name: string;
-        }) => Promise<Agent>;
-        update: (id: UUID, b: AgentWrite) => Promise<Agent>;
+        }) => Promise<QueryProfile>;
+        update: (id: UUID, b: QueryProfileWrite) => Promise<QueryProfile>;
         delete: (id: UUID) => Promise<void>;
-        /** The model catalog for an agent-config UI: supported models + default per field, per-model
+        /** The model catalog for an query-profile-config UI: supported models + default per field, per-model
          *  capabilities (`supports_reasoning`), and mode↔model dependencies. */
         modelOptions: () => Promise<ModelOptions>;
     };
-    /** Ingestion profiles — the build-side config object (counterpart to `agents`): a tenant-owned,
+    /** Ingestion profiles — the build-side config object (counterpart to query profiles): a tenant-owned,
      *  named bundle of pipeline config (chunking + embedding + sparse + quant). Unlike an agent
      *  (chosen per query), a profile binds at the TENANT/COLLECTION level — the tenant's one
      *  `is_default` profile governs how ALL its documents are ingested; swapping it re-indexes.
@@ -1024,7 +1024,7 @@ export declare class KnowledgeCoreClient extends HttpBase {
         delete: (id: UUID) => Promise<void>;
         /** The config catalog for a profile UI: supported embedding models (+ provider/dims),
          *  chunkers, distances, quantizations, per-field defaults/bounds, and the standard params.
-         *  Build-side mirror of `agents.modelOptions()`. */
+         *  Build-side mirror of `queryProfiles.modelOptions()`. */
         modelOptions: () => Promise<IngestionProfileOptions>;
     };
     analytics: {
@@ -1123,7 +1123,7 @@ export declare class ChatSession {
     #private;
     /** The conversation id — null until the first `send()` (unless resumed). */
     conversationId: UUID | null;
-    constructor(kc: KnowledgeCoreClient, agentId: UUID, corpusIds: UUID[], conversationId: UUID | null);
+    constructor(kc: KnowledgeCoreClient, profileId: UUID, corpusIds: UUID[], conversationId: UUID | null);
     /** Send a chat message (streaming). Lazily creates the conversation on the first message and
      *  ALWAYS passes conversation_id, so the turn is persisted. `onConversationId` fires before the
      *  stream so you can show the conversation immediately. Pass `signal` to cancel on unmount. */

package/dist/index.js

@@ -156,18 +156,18 @@ export class KnowledgeCoreClient extends HttpBase {
     constructor(opts) {
         super(opts);
     }
-    // --- query (agent-anchored) ---
-    query(agentId, body) {
-        return this.request("POST", `/v1/agents/${agentId}/query`, { json: body });
+    // --- query (query-profile-anchored) ---
+    query(profileId, body) {
+        return this.request("POST", `/v1/query-profiles/${profileId}/query`, { json: body });
     }
     /** Streaming query (SSE). Resolves when the stream ends (the Promise resolving is normal, not an
      *  error). Pass `signal` and abort() on unmount / when the user cancels or navigates away so the
      *  connection doesn't linger. Transient (ends on `done`) — no reopen logic needed. */
-    async queryStream(agentId, body, handlers, signal) {
-        const res = await this.raw("POST", `/v1/agents/${agentId}/query/stream`, { json: body, signal });
+    async queryStream(profileId, body, handlers, signal) {
+        const res = await this.raw("POST", `/v1/query-profiles/${profileId}/query/stream`, { json: body, signal });
         if (!res.ok || !res.body) {
             const t = await res.text();
-            throw new KnowledgeCoreError(res.status, safeJson(t), `/v1/agents/${agentId}/query/stream`);
+            throw new KnowledgeCoreError(res.status, safeJson(t), `/v1/query-profiles/${profileId}/query/stream`);
         }
         const reader = res.body.getReader();
         const decoder = new TextDecoder();
@@ -217,12 +217,12 @@ export class KnowledgeCoreClient extends HttpBase {
     /** DUMMY-PROOF CHAT. Every message goes through a conversation — it is structurally impossible
      *  to send a chat turn as a non-persisted one-shot. Use this for ANY chat UI. Use the low-level
      *  `query`/`queryStream` ONLY for programmatic one-shots (tools).
-     *    New chat:  const chat = kc.chat(agentId, corpusIds);
-     *    Resume:    const chat = kc.chat(agentId, corpusIds, { conversationId });
+     *    New chat:  const chat = kc.chat(profileId, corpusIds);
+     *    Resume:    const chat = kc.chat(profileId, corpusIds, { conversationId });
      *  The conversation is created LAZILY on the first `send()` (opening a "new chat" and never
      *  sending leaves nothing behind). See ChatSession.send. */
-    chat(agentId, corpusIds, opts) {
-        return new ChatSession(this, agentId, corpusIds, opts?.conversationId ?? null);
+    chat(profileId, corpusIds, opts) {
+        return new ChatSession(this, profileId, corpusIds, opts?.conversationId ?? null);
     }
     /** Shared SSE reader for the document-status streams (documents.events / folders.events).
      *  Resolves when the stream ends (server sends `complete` once nothing is in-flight, or the
@@ -453,21 +453,21 @@ export class KnowledgeCoreClient extends HttpBase {
         get: (id) => this.request("GET", `/v1/feedback/${id}`),
         delete: (id) => this.request("DELETE", `/v1/feedback/${id}`),
     };
-    // --- agents (tenant-owned config the chat queries; full CRUD with the tenant key) ---
-    agents = {
-        /** List this tenant's agents. */
-        list: (q) => this.request("GET", "/v1/agents", { query: q }),
-        listAll: () => this.pageAll("/v1/agents"),
-        get: (id) => this.request("GET", `/v1/agents/${id}`),
-        /** Create an agent owned by this tenant (the owning tenant is the key's — no tenant_id in the body). */
-        create: (b) => this.request("POST", "/v1/agents", { json: b }),
-        update: (id, b) => this.request("PATCH", `/v1/agents/${id}`, { json: b }),
-        delete: (id) => this.request("DELETE", `/v1/agents/${id}`),
-        /** The model catalog for an agent-config UI: supported models + default per field, per-model
+    // --- query profiles (tenant-owned query config; full CRUD with the tenant key) ---
+    queryProfiles = {
+        /** List this tenant's query profiles. */
+        list: (q) => this.request("GET", "/v1/query-profiles", { query: q }),
+        listAll: () => this.pageAll("/v1/query-profiles"),
+        get: (id) => this.request("GET", `/v1/query-profiles/${id}`),
+        /** Create a query profile owned by this tenant (the owning tenant is the key's — no tenant_id in the body). */
+        create: (b) => this.request("POST", "/v1/query-profiles", { json: b }),
+        update: (id, b) => this.request("PATCH", `/v1/query-profiles/${id}`, { json: b }),
+        delete: (id) => this.request("DELETE", `/v1/query-profiles/${id}`),
+        /** The model catalog for an query-profile-config UI: supported models + default per field, per-model
          *  capabilities (`supports_reasoning`), and mode↔model dependencies. */
-        modelOptions: () => this.request("GET", "/v1/agents/model-options"),
+        modelOptions: () => this.request("GET", "/v1/query-profiles/model-options"),
     };
-    /** Ingestion profiles — the build-side config object (counterpart to `agents`): a tenant-owned,
+    /** Ingestion profiles — the build-side config object (counterpart to query profiles): a tenant-owned,
      *  named bundle of pipeline config (chunking + embedding + sparse + quant). Unlike an agent
      *  (chosen per query), a profile binds at the TENANT/COLLECTION level — the tenant's one
      *  `is_default` profile governs how ALL its documents are ingested; swapping it re-indexes.
@@ -484,7 +484,7 @@ export class KnowledgeCoreClient extends HttpBase {
         delete: (id) => this.request("DELETE", `/v1/profiles/${id}`),
         /** The config catalog for a profile UI: supported embedding models (+ provider/dims),
          *  chunkers, distances, quantizations, per-field defaults/bounds, and the standard params.
-         *  Build-side mirror of `agents.modelOptions()`. */
+         *  Build-side mirror of `queryProfiles.modelOptions()`. */
         modelOptions: () => this.request("GET", "/v1/profiles/model-options"),
     };
     // --- retrieval analytics (read-only, tenant-scoped, aggregate-on-read) ---
@@ -519,7 +519,7 @@ export class KnowledgeCoreClient extends HttpBase {
 }
 // ---------------------------------------------------------------------------
 // Admin client (tenant + API-key provisioning) — use the ADMIN key.
-// Agents are tenant data; manage them with the tenant client (KnowledgeCoreClient.agents).
+// Query profiles are tenant data; manage them with the tenant client (KnowledgeCoreClient.queryProfiles).
 // ---------------------------------------------------------------------------
 export class AdminClient extends HttpBase {
     /** @param opts.apiKey the ADMIN key, supplied by the caller. */
@@ -544,14 +544,14 @@ export class AdminClient extends HttpBase {
  *  a chat turn is never lost and a chat conversation is never left blank. */
 export class ChatSession {
     #kc;
-    #agentId;
+    #profileId;
     #corpusIds;
     #creating = null;
     /** The conversation id — null until the first `send()` (unless resumed). */
     conversationId;
-    constructor(kc, agentId, corpusIds, conversationId) {
+    constructor(kc, profileId, corpusIds, conversationId) {
         this.#kc = kc;
-        this.#agentId = agentId;
+        this.#profileId = profileId;
         this.#corpusIds = corpusIds;
         this.conversationId = conversationId;
     }
@@ -572,7 +572,7 @@ export class ChatSession {
     async send(text, o = {}) {
         const convId = await this.#ensure(o, text);
         o.onConversationId?.(convId);
-        await this.#kc.queryStream(this.#agentId, { corpus_ids: this.#corpusIds, query: text, conversation_id: convId,
+        await this.#kc.queryStream(this.#profileId, { corpus_ids: this.#corpusIds, query: text, conversation_id: convId,
             overrides: o.overrides, filter: o.filter, visual: o.visual }, o, o.signal);
     }
     /** The conversation history (messages), once it exists. Empty page before the first send. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babav/knowledge-core-client",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "description": "TypeScript client for the Babav Knowledge Core API (Deno + Node 18+, zero deps). Includes the babav.visual grammar TYPES at the ./visual subpath (types only; all visual rendering is server-side).",
   "type": "module",
   "main": "./dist/index.js",

package/src/index.ts

@@ -250,7 +250,7 @@ export interface Corpus {
 /** Build-time knob bundle that DEFINES an index. Defaults are today's blessed config, so a
  *  profile created with no params is the blessed profile. Change any knob => different vectors
  *  => a different physical collection. Embedding/indexing/chunking is SYSTEM-level, never a
- *  query knob — this is the build-side counterpart to an Agent, not an agent. */
+ *  query knob — this is the build-side counterpart to a query profile. */
 export interface IngestionProfileParams {
   chunker: string;                     // "hybrid"
   chunk_child_max_tokens: number;
@@ -446,7 +446,7 @@ export interface Conversation {
 export interface Message {
   id: UUID;
   conversation_id: UUID;
-  agent_id: UUID | null;
+  query_profile_id: UUID | null;
   corpus_ids: UUID[] | null;
   query: string;
   answer: string | null;
@@ -472,7 +472,7 @@ export interface Feedback {
   rating: number | null;
   comment: string | null;
 }
-export interface Agent {
+export interface QueryProfile {
   id: UUID;
   tenant_id: UUID;                   // the owning tenant (every agent belongs to exactly one; no globals)
   name: string;
@@ -511,9 +511,9 @@ export interface Agent {
  *  (null/omit => server default); model fields must be one of
  *  `agents.modelOptions().fields[field].supported`. The owning tenant is the caller's key —
  *  it is never part of the body. */
-export type AgentWrite = Partial<Omit<Agent, "id" | "tenant_id">>;
+export type QueryProfileWrite = Partial<Omit<QueryProfile, "id" | "tenant_id">>;
 
-/** Model catalog for the agent-config UI (GET /v1/agents/model-options). `models` maps id → its
+/** Model catalog for the query-profile-config UI (GET /v1/query-profiles/model-options). `models` maps id → its
  *  capabilities; `fields` gives each agent model-field its supported ids + default (+ usage metadata);
  *  `modes` says which model field governs each mode (reasoning is valid only if that model's
  *  supports_reasoning is true). KC provides the data; the UI decides presentation. */
@@ -758,19 +758,19 @@ export class KnowledgeCoreClient extends HttpBase {
     super(opts);
   }
 
-  // --- query (agent-anchored) ---
-  query(agentId: UUID, body: QueryRequest): Promise<QueryResponse> {
-    return this.request("POST", `/v1/agents/${agentId}/query`, { json: body });
+  // --- query (query-profile-anchored) ---
+  query(profileId: UUID, body: QueryRequest): Promise<QueryResponse> {
+    return this.request("POST", `/v1/query-profiles/${profileId}/query`, { json: body });
   }
 
   /** Streaming query (SSE). Resolves when the stream ends (the Promise resolving is normal, not an
    *  error). Pass `signal` and abort() on unmount / when the user cancels or navigates away so the
    *  connection doesn't linger. Transient (ends on `done`) — no reopen logic needed. */
-  async queryStream(agentId: UUID, body: QueryRequest, handlers: StreamHandlers, signal?: AbortSignal): Promise<void> {
-    const res = await this.raw("POST", `/v1/agents/${agentId}/query/stream`, { json: body, signal });
+  async queryStream(profileId: UUID, body: QueryRequest, handlers: StreamHandlers, signal?: AbortSignal): Promise<void> {
+    const res = await this.raw("POST", `/v1/query-profiles/${profileId}/query/stream`, { json: body, signal });
     if (!res.ok || !res.body) {
       const t = await res.text();
-      throw new KnowledgeCoreError(res.status, safeJson(t), `/v1/agents/${agentId}/query/stream`);
+      throw new KnowledgeCoreError(res.status, safeJson(t), `/v1/query-profiles/${profileId}/query/stream`);
     }
     const reader = res.body.getReader();
     const decoder = new TextDecoder();
@@ -825,12 +825,12 @@ export class KnowledgeCoreClient extends HttpBase {
   /** DUMMY-PROOF CHAT. Every message goes through a conversation — it is structurally impossible
    *  to send a chat turn as a non-persisted one-shot. Use this for ANY chat UI. Use the low-level
    *  `query`/`queryStream` ONLY for programmatic one-shots (tools).
-   *    New chat:  const chat = kc.chat(agentId, corpusIds);
-   *    Resume:    const chat = kc.chat(agentId, corpusIds, { conversationId });
+   *    New chat:  const chat = kc.chat(profileId, corpusIds);
+   *    Resume:    const chat = kc.chat(profileId, corpusIds, { conversationId });
    *  The conversation is created LAZILY on the first `send()` (opening a "new chat" and never
    *  sending leaves nothing behind). See ChatSession.send. */
-  chat(agentId: UUID, corpusIds: UUID[], opts?: { conversationId?: UUID }): ChatSession {
-    return new ChatSession(this, agentId, corpusIds, opts?.conversationId ?? null);
+  chat(profileId: UUID, corpusIds: UUID[], opts?: { conversationId?: UUID }): ChatSession {
+    return new ChatSession(this, profileId, corpusIds, opts?.conversationId ?? null);
   }
 
   /** Shared SSE reader for the document-status streams (documents.events / folders.events).
@@ -1126,22 +1126,22 @@ export class KnowledgeCoreClient extends HttpBase {
     delete: (id: UUID) => this.request<void>("DELETE", `/v1/feedback/${id}`),
   };
 
-  // --- agents (tenant-owned config the chat queries; full CRUD with the tenant key) ---
-  agents = {
-    /** List this tenant's agents. */
-    list: (q?: { limit?: number; cursor?: string }) => this.request<Page<Agent>>("GET", "/v1/agents", { query: q }),
-    listAll: () => this.pageAll<Agent>("/v1/agents"),
-    get: (id: UUID) => this.request<Agent>("GET", `/v1/agents/${id}`),
-    /** Create an agent owned by this tenant (the owning tenant is the key's — no tenant_id in the body). */
-    create: (b: AgentWrite & { name: string }) => this.request<Agent>("POST", "/v1/agents", { json: b }),
-    update: (id: UUID, b: AgentWrite) => this.request<Agent>("PATCH", `/v1/agents/${id}`, { json: b }),
-    delete: (id: UUID) => this.request<void>("DELETE", `/v1/agents/${id}`),
-    /** The model catalog for an agent-config UI: supported models + default per field, per-model
+  // --- query profiles (tenant-owned query config; full CRUD with the tenant key) ---
+  queryProfiles = {
+    /** List this tenant's query profiles. */
+    list: (q?: { limit?: number; cursor?: string }) => this.request<Page<QueryProfile>>("GET", "/v1/query-profiles", { query: q }),
+    listAll: () => this.pageAll<QueryProfile>("/v1/query-profiles"),
+    get: (id: UUID) => this.request<QueryProfile>("GET", `/v1/query-profiles/${id}`),
+    /** Create a query profile owned by this tenant (the owning tenant is the key's — no tenant_id in the body). */
+    create: (b: QueryProfileWrite & { name: string }) => this.request<QueryProfile>("POST", "/v1/query-profiles", { json: b }),
+    update: (id: UUID, b: QueryProfileWrite) => this.request<QueryProfile>("PATCH", `/v1/query-profiles/${id}`, { json: b }),
+    delete: (id: UUID) => this.request<void>("DELETE", `/v1/query-profiles/${id}`),
+    /** The model catalog for an query-profile-config UI: supported models + default per field, per-model
      *  capabilities (`supports_reasoning`), and mode↔model dependencies. */
-    modelOptions: () => this.request<ModelOptions>("GET", "/v1/agents/model-options"),
+    modelOptions: () => this.request<ModelOptions>("GET", "/v1/query-profiles/model-options"),
   };
 
-  /** Ingestion profiles — the build-side config object (counterpart to `agents`): a tenant-owned,
+  /** Ingestion profiles — the build-side config object (counterpart to query profiles): a tenant-owned,
    *  named bundle of pipeline config (chunking + embedding + sparse + quant). Unlike an agent
    *  (chosen per query), a profile binds at the TENANT/COLLECTION level — the tenant's one
    *  `is_default` profile governs how ALL its documents are ingested; swapping it re-indexes.
@@ -1161,7 +1161,7 @@ export class KnowledgeCoreClient extends HttpBase {
     delete: (id: UUID) => this.request<void>("DELETE", `/v1/profiles/${id}`),
     /** The config catalog for a profile UI: supported embedding models (+ provider/dims),
      *  chunkers, distances, quantizations, per-field defaults/bounds, and the standard params.
-     *  Build-side mirror of `agents.modelOptions()`. */
+     *  Build-side mirror of `queryProfiles.modelOptions()`. */
     modelOptions: () => this.request<IngestionProfileOptions>("GET", "/v1/profiles/model-options"),
   };
 
@@ -1202,7 +1202,7 @@ export class KnowledgeCoreClient extends HttpBase {
 
 // ---------------------------------------------------------------------------
 // Admin client (tenant + API-key provisioning) — use the ADMIN key.
-// Agents are tenant data; manage them with the tenant client (KnowledgeCoreClient.agents).
+// Query profiles are tenant data; manage them with the tenant client (KnowledgeCoreClient.queryProfiles).
 // ---------------------------------------------------------------------------
 export class AdminClient extends HttpBase {
   /** @param opts.apiKey the ADMIN key, supplied by the caller. */
@@ -1221,8 +1221,8 @@ export class AdminClient extends HttpBase {
     listApiKeys: (tenantId: UUID, q?: { limit?: number; cursor?: string }) => this.request<Page<ApiKey>>("GET", `/v1/tenants/${tenantId}/api-keys`, { query: q }),
     revokeApiKey: (tenantId: UUID, keyId: UUID) => this.request<void>("DELETE", `/v1/tenants/${tenantId}/api-keys/${keyId}`),
   };
-  // Agents are TENANT data, not an admin surface — manage them with the tenant key via
-  // KnowledgeCoreClient.agents (create/update/delete/list/get/modelOptions).
+  // Query profiles are TENANT data, not an admin surface — manage them with the tenant key via
+  // KnowledgeCoreClient.queryProfiles (create/update/delete/list/get/modelOptions).
 }
 
 export interface ChatSendOptions extends StreamHandlers {
@@ -1247,15 +1247,15 @@ export interface ChatSendOptions extends StreamHandlers {
  *  a chat turn is never lost and a chat conversation is never left blank. */
 export class ChatSession {
   #kc: KnowledgeCoreClient;
-  #agentId: UUID;
+  #profileId: UUID;
   #corpusIds: UUID[];
   #creating: Promise<UUID> | null = null;
   /** The conversation id — null until the first `send()` (unless resumed). */
   conversationId: UUID | null;
 
-  constructor(kc: KnowledgeCoreClient, agentId: UUID, corpusIds: UUID[], conversationId: UUID | null) {
+  constructor(kc: KnowledgeCoreClient, profileId: UUID, corpusIds: UUID[], conversationId: UUID | null) {
     this.#kc = kc;
-    this.#agentId = agentId;
+    this.#profileId = profileId;
     this.#corpusIds = corpusIds;
     this.conversationId = conversationId;
   }
@@ -1278,7 +1278,7 @@ export class ChatSession {
     const convId = await this.#ensure(o, text);
     o.onConversationId?.(convId);
     await this.#kc.queryStream(
-      this.#agentId,
+      this.#profileId,
       { corpus_ids: this.#corpusIds, query: text, conversation_id: convId,
         overrides: o.overrides, filter: o.filter, visual: o.visual },
       o,