@kweaver-ai/kweaver-sdk 0.4.14 → 0.5.0

package/dist/api/conversations.d.ts

@@ -12,11 +12,17 @@ export interface ListMessagesOptions {
     businessDomain?: string;
     limit?: number;
 }
+export interface GetTracesOptions {
+    baseUrl: string;
+    accessToken: string;
+    conversationId: string;
+}
 /**
  * List conversations for an agent.
  * Returns empty array on 404 (endpoint may not be available in all deployments).
  */
 export declare function listConversations(opts: ListConversationsOptions): Promise<string>;
+export declare function getTracesByConversation(opts: GetTracesOptions): Promise<string>;
 /**
  * List messages for a conversation.
  * Returns empty array on 404 (endpoint may not be available in all deployments).

package/dist/api/conversations.js

@@ -34,6 +34,27 @@ export async function listConversations(opts) {
     }
     return body || "[]";
 }
+function buildTracesUrl(baseUrl, conversationId) {
+    const base = baseUrl.replace(/\/+$/, "");
+    return `${base}/api/agent-observability/v1/traces/by-conversation?conversation_id=${conversationId}`;
+}
+export async function getTracesByConversation(opts) {
+    const { baseUrl, accessToken, conversationId } = opts;
+    const url = buildTracesUrl(baseUrl, conversationId);
+    const response = await fetch(url, {
+        method: "GET",
+        headers: {
+            accept: "application/json",
+            authorization: `Bearer ${accessToken}`,
+            token: accessToken,
+        },
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new Error(`getTracesByConversation failed: HTTP ${response.status} ${response.statusText} — ${body.slice(0, 200)}`);
+    }
+    return body || "{}";
+}
 /**
  * List messages for a conversation.
  * Returns empty array on 404 (endpoint may not be available in all deployments).

package/dist/api/vega.d.ts

@@ -20,6 +20,28 @@ export interface GetVegaCatalogOptions {
     businessDomain?: string;
 }
 export declare function getVegaCatalog(options: GetVegaCatalogOptions): Promise<string>;
+export interface CreateVegaCatalogOptions {
+    baseUrl: string;
+    accessToken: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function createVegaCatalog(options: CreateVegaCatalogOptions): Promise<string>;
+export interface UpdateVegaCatalogOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function updateVegaCatalog(options: UpdateVegaCatalogOptions): Promise<string>;
+export interface DeleteVegaCatalogsOptions {
+    baseUrl: string;
+    accessToken: string;
+    ids: string;
+    businessDomain?: string;
+}
+export declare function deleteVegaCatalogs(options: DeleteVegaCatalogsOptions): Promise<string>;
 export interface VegaCatalogHealthStatusOptions {
     baseUrl: string;
     accessToken: string;
@@ -78,14 +100,28 @@ export interface QueryVegaResourceDataOptions {
     businessDomain?: string;
 }
 export declare function queryVegaResourceData(options: QueryVegaResourceDataOptions): Promise<string>;
-export interface PreviewVegaResourceOptions {
+export interface CreateVegaResourceOptions {
+    baseUrl: string;
+    accessToken: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function createVegaResource(options: CreateVegaResourceOptions): Promise<string>;
+export interface UpdateVegaResourceOptions {
     baseUrl: string;
     accessToken: string;
     id: string;
-    limit?: number;
+    body: string;
+    businessDomain?: string;
+}
+export declare function updateVegaResource(options: UpdateVegaResourceOptions): Promise<string>;
+export interface DeleteVegaResourcesOptions {
+    baseUrl: string;
+    accessToken: string;
+    ids: string;
     businessDomain?: string;
 }
-export declare function previewVegaResource(options: PreviewVegaResourceOptions): Promise<string>;
+export declare function deleteVegaResources(options: DeleteVegaResourcesOptions): Promise<string>;
 export interface ListVegaConnectorTypesOptions {
     baseUrl: string;
     accessToken: string;
@@ -99,6 +135,36 @@ export interface GetVegaConnectorTypeOptions {
     businessDomain?: string;
 }
 export declare function getVegaConnectorType(options: GetVegaConnectorTypeOptions): Promise<string>;
+export interface RegisterVegaConnectorTypeOptions {
+    baseUrl: string;
+    accessToken: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function registerVegaConnectorType(options: RegisterVegaConnectorTypeOptions): Promise<string>;
+export interface UpdateVegaConnectorTypeOptions {
+    baseUrl: string;
+    accessToken: string;
+    type: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function updateVegaConnectorType(options: UpdateVegaConnectorTypeOptions): Promise<string>;
+export interface DeleteVegaConnectorTypeOptions {
+    baseUrl: string;
+    accessToken: string;
+    type: string;
+    businessDomain?: string;
+}
+export declare function deleteVegaConnectorType(options: DeleteVegaConnectorTypeOptions): Promise<string>;
+export interface SetVegaConnectorTypeEnabledOptions {
+    baseUrl: string;
+    accessToken: string;
+    type: string;
+    enabled: boolean;
+    businessDomain?: string;
+}
+export declare function setVegaConnectorTypeEnabled(options: SetVegaConnectorTypeEnabledOptions): Promise<string>;
 export interface ListVegaDiscoverTasksOptions {
     baseUrl: string;
     accessToken: string;
@@ -108,3 +174,10 @@ export interface ListVegaDiscoverTasksOptions {
     businessDomain?: string;
 }
 export declare function listVegaDiscoverTasks(options: ListVegaDiscoverTasksOptions): Promise<string>;
+export interface GetVegaDiscoverTaskOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    businessDomain?: string;
+}
+export declare function getVegaDiscoverTask(options: GetVegaDiscoverTaskOptions): Promise<string>;

package/dist/api/vega.js

@@ -61,11 +61,52 @@ export async function getVegaCatalog(options) {
     }
     return body;
 }
+export async function createVegaCatalog(options) {
+    const { baseUrl, accessToken, body: requestBody, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/catalogs`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { ...buildHeaders(accessToken, businessDomain), "content-type": "application/json" },
+        body: requestBody,
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
+export async function updateVegaCatalog(options) {
+    const { baseUrl, accessToken, id, body: requestBody, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/catalogs/${encodeURIComponent(id)}`;
+    const response = await fetch(url, {
+        method: "PUT",
+        headers: { ...buildHeaders(accessToken, businessDomain), "content-type": "application/json" },
+        body: requestBody,
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
+export async function deleteVegaCatalogs(options) {
+    const { baseUrl, accessToken, ids, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/catalogs/${ids}`;
+    const response = await fetch(url, {
+        method: "DELETE",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
 export async function vegaCatalogHealthStatus(options) {
     const { baseUrl, accessToken, ids, businessDomain = "bd_public", } = options;
     const base = baseUrl.replace(/\/+$/, "");
-    const url = new URL(`${base}${VEGA_BASE}/catalogs/health-status`);
-    url.searchParams.set("ids", ids);
+    // ids go in the path segment: GET /catalogs/{ids}/health-status
+    const url = new URL(`${base}${VEGA_BASE}/catalogs/${ids}/health-status`);
     const response = await fetch(url.toString(), {
         method: "GET",
         headers: buildHeaders(accessToken, businessDomain),
@@ -189,19 +230,45 @@ export async function queryVegaResourceData(options) {
     }
     return body;
 }
-export async function previewVegaResource(options) {
-    const { baseUrl, accessToken, id, limit = 50, businessDomain = "bd_public", } = options;
+export async function createVegaResource(options) {
+    const { baseUrl, accessToken, body: requestBody, businessDomain = "bd_public" } = options;
     const base = baseUrl.replace(/\/+$/, "");
-    const url = new URL(`${base}${VEGA_BASE}/resources/${encodeURIComponent(id)}/preview`);
-    url.searchParams.set("limit", String(limit));
-    const response = await fetch(url.toString(), {
-        method: "GET",
+    const url = `${base}${VEGA_BASE}/resources`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { ...buildHeaders(accessToken, businessDomain), "content-type": "application/json" },
+        body: requestBody,
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
+export async function updateVegaResource(options) {
+    const { baseUrl, accessToken, id, body: requestBody, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/resources/${encodeURIComponent(id)}`;
+    const response = await fetch(url, {
+        method: "PUT",
+        headers: { ...buildHeaders(accessToken, businessDomain), "content-type": "application/json" },
+        body: requestBody,
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
+export async function deleteVegaResources(options) {
+    const { baseUrl, accessToken, ids, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/resources/${ids}`;
+    const response = await fetch(url, {
+        method: "DELETE",
         headers: buildHeaders(accessToken, businessDomain),
     });
     const body = await response.text();
-    if (!response.ok) {
+    if (!response.ok)
         throw new HttpError(response.status, response.statusText, body);
-    }
     return body;
 }
 export async function listVegaConnectorTypes(options) {
@@ -232,6 +299,61 @@ export async function getVegaConnectorType(options) {
     }
     return body;
 }
+export async function registerVegaConnectorType(options) {
+    const { baseUrl, accessToken, body: requestBody, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/connector-types`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { ...buildHeaders(accessToken, businessDomain), "content-type": "application/json" },
+        body: requestBody,
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
+export async function updateVegaConnectorType(options) {
+    const { baseUrl, accessToken, type, body: requestBody, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/connector-types/${encodeURIComponent(type)}`;
+    const response = await fetch(url, {
+        method: "PUT",
+        headers: { ...buildHeaders(accessToken, businessDomain), "content-type": "application/json" },
+        body: requestBody,
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
+export async function deleteVegaConnectorType(options) {
+    const { baseUrl, accessToken, type, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/connector-types/${encodeURIComponent(type)}`;
+    const response = await fetch(url, {
+        method: "DELETE",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
+export async function setVegaConnectorTypeEnabled(options) {
+    const { baseUrl, accessToken, type, enabled, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/connector-types/${encodeURIComponent(type)}/enabled`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { ...buildHeaders(accessToken, businessDomain), "content-type": "application/json" },
+        body: JSON.stringify({ enabled }),
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}
 export async function listVegaDiscoverTasks(options) {
     const { baseUrl, accessToken, status, limit, offset, businessDomain = "bd_public", } = options;
     const base = baseUrl.replace(/\/+$/, "");
@@ -252,3 +374,16 @@ export async function listVegaDiscoverTasks(options) {
     }
     return body;
 }
+export async function getVegaDiscoverTask(options) {
+    const { baseUrl, accessToken, id, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/discover-tasks/${encodeURIComponent(id)}`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, response.statusText, body);
+    return body;
+}

package/dist/cli.js

@@ -82,7 +82,7 @@ Usage:
 
   kweaver vega health|stats|inspect
   kweaver vega catalog list|get|health|test-connection|discover|resources [options]
-  kweaver vega resource list|get|query|preview [options]
+  kweaver vega resource list|get|query [options]
   kweaver vega connector-type list|get [options]
 
   kweaver context-loader config set|use|list|remove|show [options]

package/dist/commands/agent.d.ts

@@ -25,6 +25,11 @@ export interface AgentHistoryOptions {
     pretty: boolean;
 }
 export declare function parseAgentHistoryArgs(args: string[]): AgentHistoryOptions;
+export interface AgentTraceOptions {
+    conversationId: string;
+    pretty: boolean;
+}
+export declare function parseAgentTraceArgs(args: string[]): AgentTraceOptions;
 export declare function runAgentCommand(args: string[]): Promise<number>;
 export interface AgentGetOptions {
     agentId: string;

package/dist/commands/agent.js

@@ -1,7 +1,7 @@
 import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
 import { runAgentChatCommand } from "./agent-chat.js";
 import { listAgents, getAgent, getAgentByKey, createAgent, updateAgent, deleteAgent, publishAgent, unpublishAgent, } from "../api/agent-list.js";
-import { listConversations, listMessages } from "../api/conversations.js";
+import { listConversations, listMessages, getTracesByConversation } from "../api/conversations.js";
 import { formatCallOutput } from "./call.js";
 import { resolveBusinessDomain } from "../config/store.js";
 function readStringField(value, ...keys) {
@@ -212,6 +212,29 @@ export function parseAgentHistoryArgs(args) {
         businessDomain = resolveBusinessDomain();
     return { conversationId, businessDomain, limit, pretty };
 }
+export function parseAgentTraceArgs(args) {
+    const conversationId = args[0];
+    if (!conversationId || conversationId.startsWith("-")) {
+        throw new Error("Missing conversation_id");
+    }
+    let pretty = true;
+    for (let i = 1; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            throw new Error("help");
+        }
+        if (arg === "--pretty") {
+            pretty = true;
+            continue;
+        }
+        if (arg === "--compact") {
+            pretty = false;
+            continue;
+        }
+        throw new Error(`Unsupported agent trace argument: ${arg}`);
+    }
+    return { conversationId, pretty };
+}
 export async function runAgentCommand(args) {
     const [subcommand, ...rest] = args;
     if (!subcommand || subcommand === "--help" || subcommand === "-h") {
@@ -231,7 +254,8 @@ Subcommands:
   chat <agent_id>                    Start interactive chat with an agent
   chat <agent_id> -m "message"       Send a single message (non-interactive)
   sessions <agent_id>                List all conversations for an agent
-  history <conversation_id>          Show message history for a conversation`);
+  history <conversation_id>          Show message history for a conversation
+  trace <conversation_id>            Get trace data for a conversation`);
         return Promise.resolve(0);
     }
     const dispatch = async () => {
@@ -245,6 +269,8 @@ Subcommands:
             return runAgentSessionsCommand(rest);
         if (subcommand === "history")
             return runAgentHistoryCommand(rest);
+        if (subcommand === "trace")
+            return runAgentTraceCommand(rest);
         if (subcommand === "get-by-key")
             return runAgentGetByKeyCommand(rest);
         if (subcommand === "create")
@@ -345,6 +371,18 @@ Options:
             return 0;
         }
     }
+    if (subcommand === "trace") {
+        if (rest.length === 1 && (rest[0] === "--help" || rest[0] === "-h")) {
+            console.log(`kweaver agent trace <conversation_id> [options]
+
+Get trace data for a conversation.
+
+Options:
+  --pretty                  Pretty-print JSON output (default)
+  --compact                 Compact JSON output`);
+            return 0;
+        }
+    }
     try {
         return await with401RefreshRetry(async () => {
             const code = await dispatch();
@@ -571,6 +609,40 @@ Options:
         return 1;
     }
 }
+async function runAgentTraceCommand(args) {
+    let options;
+    try {
+        options = parseAgentTraceArgs(args);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "help") {
+            console.log(`kweaver agent trace <conversation_id> [options]
+
+Get trace data for a conversation.
+
+Options:
+  --pretty                  Pretty-print JSON output (default)
+  --compact                 Compact JSON output`);
+            return 0;
+        }
+        console.error(formatHttpError(error));
+        return 1;
+    }
+    try {
+        const token = await ensureValidToken();
+        const body = await getTracesByConversation({
+            baseUrl: token.baseUrl,
+            accessToken: token.accessToken,
+            conversationId: options.conversationId,
+        });
+        console.log(formatCallOutput(body, options.pretty));
+        return 0;
+    }
+    catch (error) {
+        console.error(formatHttpError(error));
+        return 1;
+    }
+}
 // ── Get by key ───────────────────────────────────────────────────────────────
 async function runAgentGetByKeyCommand(args) {
     const key = args[0];