@kweaver-ai/kweaver-sdk 0.4.1 → 0.4.2

package/dist/api/agent-list.d.ts

@@ -17,3 +17,47 @@ export interface GetAgentOptions {
     businessDomain?: string;
 }
 export declare function getAgent(options: GetAgentOptions): Promise<string>;
+export interface GetAgentByKeyOptions {
+    baseUrl: string;
+    accessToken: string;
+    key: string;
+    businessDomain?: string;
+}
+export declare function getAgentByKey(options: GetAgentByKeyOptions): Promise<string>;
+export interface CreateAgentOptions {
+    baseUrl: string;
+    accessToken: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function createAgent(options: CreateAgentOptions): Promise<string>;
+export interface UpdateAgentOptions {
+    baseUrl: string;
+    accessToken: string;
+    agentId: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function updateAgent(options: UpdateAgentOptions): Promise<string>;
+export interface DeleteAgentOptions {
+    baseUrl: string;
+    accessToken: string;
+    agentId: string;
+    businessDomain?: string;
+}
+export declare function deleteAgent(options: DeleteAgentOptions): Promise<void>;
+export interface PublishAgentOptions {
+    baseUrl: string;
+    accessToken: string;
+    agentId: string;
+    body?: string;
+    businessDomain?: string;
+}
+export declare function publishAgent(options: PublishAgentOptions): Promise<string>;
+export interface UnpublishAgentOptions {
+    baseUrl: string;
+    accessToken: string;
+    agentId: string;
+    businessDomain?: string;
+}
+export declare function unpublishAgent(options: UnpublishAgentOptions): Promise<void>;

package/dist/api/agent-list.js

@@ -1,4 +1,14 @@
 import { HttpError } from "../utils/http.js";
+function buildHeaders(accessToken, businessDomain) {
+    return {
+        accept: "application/json, text/plain, */*",
+        "accept-language": "zh-CN",
+        authorization: `Bearer ${accessToken}`,
+        token: accessToken,
+        "x-business-domain": businessDomain,
+        "x-language": "zh-CN",
+    };
+}
 export async function listAgents(options) {
     const { baseUrl, accessToken, businessDomain = "bd_public", name = "", offset = 0, limit = 50, category_id = "", custom_space_id = "", is_to_square = 1, } = options;
     const base = baseUrl.replace(/\/+$/, "");
@@ -13,14 +23,7 @@ export async function listAgents(options) {
     });
     const response = await fetch(url, {
         method: "POST",
-        headers: {
-            accept: "application/json, text/plain, */*",
-            "accept-language": "zh-CN",
-            authorization: `Bearer ${accessToken}`,
-            token: accessToken,
-            "x-business-domain": businessDomain,
-            "x-language": "zh-CN",
-        },
+        headers: buildHeaders(accessToken, businessDomain),
         body,
     });
     const responseBody = await response.text();
@@ -35,14 +38,39 @@ export async function getAgent(options) {
     const url = `${base}/api/agent-factory/v3/agent/${encodeURIComponent(agentId)}`;
     const response = await fetch(url, {
         method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function getAgentByKey(options) {
+    const { baseUrl, accessToken, key, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/agent-factory/v3/agent/by-key/${encodeURIComponent(key)}`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function createAgent(options) {
+    const { baseUrl, accessToken, body, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/agent-factory/v3/agent`;
+    const response = await fetch(url, {
+        method: "POST",
         headers: {
-            accept: "application/json, text/plain, */*",
-            "accept-language": "zh-CN",
-            authorization: `Bearer ${accessToken}`,
-            token: accessToken,
-            "x-business-domain": businessDomain,
-            "x-language": "zh-CN",
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
         },
+        body,
     });
     const responseBody = await response.text();
     if (!response.ok) {
@@ -50,3 +78,65 @@ export async function getAgent(options) {
     }
     return responseBody;
 }
+export async function updateAgent(options) {
+    const { baseUrl, accessToken, agentId, body, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/agent-factory/v3/agent/${encodeURIComponent(agentId)}`;
+    const response = await fetch(url, {
+        method: "PUT",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function deleteAgent(options) {
+    const { baseUrl, accessToken, agentId, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/agent-factory/v3/agent/${encodeURIComponent(agentId)}`;
+    const response = await fetch(url, {
+        method: "DELETE",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    if (!response.ok) {
+        const responseBody = await response.text();
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+}
+export async function publishAgent(options) {
+    const { baseUrl, accessToken, agentId, body = "{}", businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/agent-factory/v3/agent/${encodeURIComponent(agentId)}/publish`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function unpublishAgent(options) {
+    const { baseUrl, accessToken, agentId, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/agent-factory/v3/agent/${encodeURIComponent(agentId)}/unpublish`;
+    const response = await fetch(url, {
+        method: "PUT",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    if (!response.ok) {
+        const responseBody = await response.text();
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+}

package/dist/api/bkn-backend.d.ts

@@ -0,0 +1,16 @@
+export interface UploadBknOptions {
+    baseUrl: string;
+    accessToken: string;
+    tarBuffer: Buffer;
+    businessDomain?: string;
+    branch?: string;
+}
+export declare function uploadBkn(options: UploadBknOptions): Promise<string>;
+export interface DownloadBknOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    businessDomain?: string;
+    branch?: string;
+}
+export declare function downloadBkn(options: DownloadBknOptions): Promise<Buffer>;

package/dist/api/bkn-backend.js

@@ -0,0 +1,46 @@
+import { HttpError } from "../utils/http.js";
+function buildHeaders(accessToken, businessDomain) {
+    return {
+        accept: "application/json, text/plain, */*",
+        "accept-language": "zh-cn",
+        authorization: `Bearer ${accessToken}`,
+        token: accessToken,
+        "x-business-domain": businessDomain,
+        "x-language": "zh-cn",
+    };
+}
+export async function uploadBkn(options) {
+    const { baseUrl, accessToken, tarBuffer, businessDomain = "bd_public", branch = "main", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/bkn-backend/v1/bkns`);
+    url.searchParams.set("branch", branch);
+    const form = new FormData();
+    form.append("file", new Blob([new Uint8Array(tarBuffer)], { type: "application/octet-stream" }), "bkn.tar");
+    const headers = buildHeaders(accessToken, businessDomain);
+    const response = await fetch(url.toString(), {
+        method: "POST",
+        headers,
+        body: form,
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}
+export async function downloadBkn(options) {
+    const { baseUrl, accessToken, knId, businessDomain = "bd_public", branch = "main", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/bkn-backend/v1/bkns/${encodeURIComponent(knId)}`);
+    url.searchParams.set("branch", branch);
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+}

package/dist/api/ontology-query.d.ts

@@ -20,7 +20,7 @@ export interface ObjectTypePropertiesOptions extends OntologyQueryBaseOptions {
     excludeSystemProperties?: string[];
 }
 export declare function objectTypeProperties(options: ObjectTypePropertiesOptions): Promise<string>;
-/** Subgraph: POST */
+/** Subgraph: POST with X-HTTP-Method-Override: GET */
 export interface SubgraphOptions extends OntologyQueryBaseOptions {
     body: string;
     includeLogicParams?: boolean;

package/dist/api/ontology-query.js

@@ -83,6 +83,7 @@ export async function subgraph(options) {
     const headers = {
         ...buildHeaders(accessToken, businessDomain),
         "content-type": "application/json",
+        "X-HTTP-Method-Override": "GET",
     };
     const response = await fetch(url.toString(), {
         method: "POST",

package/dist/api/vega.d.ts

@@ -0,0 +1,110 @@
+export interface VegaHealthOptions {
+    baseUrl: string;
+    accessToken: string;
+    businessDomain?: string;
+}
+export declare function vegaHealth(options: VegaHealthOptions): Promise<string>;
+export interface ListVegaCatalogsOptions {
+    baseUrl: string;
+    accessToken: string;
+    status?: string;
+    limit?: number;
+    offset?: number;
+    businessDomain?: string;
+}
+export declare function listVegaCatalogs(options: ListVegaCatalogsOptions): Promise<string>;
+export interface GetVegaCatalogOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    businessDomain?: string;
+}
+export declare function getVegaCatalog(options: GetVegaCatalogOptions): Promise<string>;
+export interface VegaCatalogHealthStatusOptions {
+    baseUrl: string;
+    accessToken: string;
+    ids: string;
+    businessDomain?: string;
+}
+export declare function vegaCatalogHealthStatus(options: VegaCatalogHealthStatusOptions): Promise<string>;
+export interface TestVegaCatalogConnectionOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    businessDomain?: string;
+}
+export declare function testVegaCatalogConnection(options: TestVegaCatalogConnectionOptions): Promise<string>;
+export interface DiscoverVegaCatalogOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    wait?: boolean;
+    businessDomain?: string;
+}
+export declare function discoverVegaCatalog(options: DiscoverVegaCatalogOptions): Promise<string>;
+export interface ListVegaCatalogResourcesOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    category?: string;
+    limit?: number;
+    offset?: number;
+    businessDomain?: string;
+}
+export declare function listVegaCatalogResources(options: ListVegaCatalogResourcesOptions): Promise<string>;
+export interface ListVegaResourcesOptions {
+    baseUrl: string;
+    accessToken: string;
+    catalogId?: string;
+    category?: string;
+    status?: string;
+    limit?: number;
+    offset?: number;
+    businessDomain?: string;
+}
+export declare function listVegaResources(options: ListVegaResourcesOptions): Promise<string>;
+export interface GetVegaResourceOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    businessDomain?: string;
+}
+export declare function getVegaResource(options: GetVegaResourceOptions): Promise<string>;
+export interface QueryVegaResourceDataOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function queryVegaResourceData(options: QueryVegaResourceDataOptions): Promise<string>;
+export interface PreviewVegaResourceOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    limit?: number;
+    businessDomain?: string;
+}
+export declare function previewVegaResource(options: PreviewVegaResourceOptions): Promise<string>;
+export interface ListVegaConnectorTypesOptions {
+    baseUrl: string;
+    accessToken: string;
+    businessDomain?: string;
+}
+export declare function listVegaConnectorTypes(options: ListVegaConnectorTypesOptions): Promise<string>;
+export interface GetVegaConnectorTypeOptions {
+    baseUrl: string;
+    accessToken: string;
+    type: string;
+    businessDomain?: string;
+}
+export declare function getVegaConnectorType(options: GetVegaConnectorTypeOptions): Promise<string>;
+export interface ListVegaDiscoverTasksOptions {
+    baseUrl: string;
+    accessToken: string;
+    status?: string;
+    limit?: number;
+    offset?: number;
+    businessDomain?: string;
+}
+export declare function listVegaDiscoverTasks(options: ListVegaDiscoverTasksOptions): Promise<string>;

package/dist/api/vega.js

@@ -0,0 +1,251 @@
+import { HttpError } from "../utils/http.js";
+const VEGA_BASE = "/api/vega-backend/v1";
+function buildHeaders(accessToken, businessDomain) {
+    return {
+        accept: "application/json, text/plain, */*",
+        "accept-language": "zh-cn",
+        authorization: `Bearer ${accessToken}`,
+        token: accessToken,
+        "x-business-domain": businessDomain,
+        "x-language": "zh-cn",
+    };
+}
+export async function vegaHealth(options) {
+    const { baseUrl, accessToken, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/health`;
+    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;
+}
+export async function listVegaCatalogs(options) {
+    const { baseUrl, accessToken, status, limit, offset, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}${VEGA_BASE}/catalogs`);
+    if (status)
+        url.searchParams.set("status", status);
+    if (limit !== undefined)
+        url.searchParams.set("limit", String(limit));
+    if (offset !== undefined)
+        url.searchParams.set("offset", String(offset));
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        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 getVegaCatalog(options) {
+    const { baseUrl, accessToken, id, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/catalogs/${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;
+}
+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);
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        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 testVegaCatalogConnection(options) {
+    const { baseUrl, accessToken, id, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/catalogs/${encodeURIComponent(id)}/test-connection`;
+    const response = await fetch(url, {
+        method: "POST",
+        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 discoverVegaCatalog(options) {
+    const { baseUrl, accessToken, id, wait, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const endpoint = `${base}${VEGA_BASE}/catalogs/${encodeURIComponent(id)}/discover`;
+    let url;
+    if (wait !== undefined) {
+        const u = new URL(endpoint);
+        u.searchParams.set("wait", String(wait));
+        url = u.toString();
+    }
+    else {
+        url = endpoint;
+    }
+    const response = await fetch(url, {
+        method: "POST",
+        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 listVegaCatalogResources(options) {
+    const { baseUrl, accessToken, id, category, limit, offset, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}${VEGA_BASE}/catalogs/${encodeURIComponent(id)}/resources`);
+    if (category)
+        url.searchParams.set("category", category);
+    if (limit !== undefined)
+        url.searchParams.set("limit", String(limit));
+    if (offset !== undefined)
+        url.searchParams.set("offset", String(offset));
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        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 listVegaResources(options) {
+    const { baseUrl, accessToken, catalogId, category, status, limit, offset, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}${VEGA_BASE}/resources`);
+    if (catalogId)
+        url.searchParams.set("catalog_id", catalogId);
+    if (category)
+        url.searchParams.set("category", category);
+    if (status)
+        url.searchParams.set("status", status);
+    if (limit !== undefined)
+        url.searchParams.set("limit", String(limit));
+    if (offset !== undefined)
+        url.searchParams.set("offset", String(offset));
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        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 getVegaResource(options) {
+    const { baseUrl, accessToken, id, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/resources/${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;
+}
+export async function queryVegaResourceData(options) {
+    const { baseUrl, accessToken, id, body: requestBody, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/resources/${encodeURIComponent(id)}/data`;
+    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 previewVegaResource(options) {
+    const { baseUrl, accessToken, id, limit = 10, 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",
+        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 listVegaConnectorTypes(options) {
+    const { baseUrl, accessToken, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}${VEGA_BASE}/connector-types?sort=name&order=asc`;
+    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;
+}
+export async function getVegaConnectorType(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: "GET",
+        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 listVegaDiscoverTasks(options) {
+    const { baseUrl, accessToken, status, limit, offset, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}${VEGA_BASE}/discover-tasks`);
+    if (status)
+        url.searchParams.set("status", status);
+    if (limit !== undefined)
+        url.searchParams.set("limit", String(limit));
+    if (offset !== undefined)
+        url.searchParams.set("offset", String(offset));
+    const response = await fetch(url.toString(), {
+        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/auth/oauth.d.ts

@@ -46,7 +46,9 @@ export declare function buildAuthorizationUrl(client: ClientConfig, state?: stri
  */
 export declare function callLogoutEndpoint(client: ClientConfig, token: TokenConfig | null): Promise<void>;
 export declare function refreshAccessToken(client: ClientConfig, refreshToken: string): Promise<TokenConfig>;
-export declare function ensureValidToken(): Promise<TokenConfig>;
+export declare function ensureValidToken(opts?: {
+    forceRefresh?: boolean;
+}): Promise<TokenConfig>;
 export interface AuthLoginOptions {
     baseUrl: string;
     port: number;

package/dist/auth/oauth.js

@@ -271,13 +271,14 @@ export async function refreshAccessToken(client, refreshToken) {
     saveTokenConfig(tokenConfig);
     return tokenConfig;
 }
-export async function ensureValidToken() {
+export async function ensureValidToken(opts) {
     const envToken = process.env.KWEAVER_TOKEN;
     const envBaseUrl = process.env.KWEAVER_BASE_URL;
-    if (envToken && envBaseUrl) {
+    if (!opts?.forceRefresh && envToken && envBaseUrl) {
+        const rawToken = envToken.replace(/^Bearer\s+/i, "");
         return {
             baseUrl: normalizeBaseUrl(envBaseUrl),
-            accessToken: envToken,
+            accessToken: rawToken,
             tokenType: "bearer",
             scope: "openid",
             obtainedAt: new Date().toISOString(),
@@ -292,12 +293,14 @@ export async function ensureValidToken() {
     if (!client || !token) {
         throw new Error(`Missing saved credentials for ${currentPlatform}. Run \`kweaver auth ${currentPlatform}\` first.`);
     }
-    if (!token.expiresAt) {
-        return token;
-    }
-    const expiresAtMs = Date.parse(token.expiresAt);
-    if (Number.isNaN(expiresAtMs) || expiresAtMs - 60_000 > Date.now()) {
-        return token;
+    if (!opts?.forceRefresh) {
+        if (!token.expiresAt) {
+            return token;
+        }
+        const expiresAtMs = Date.parse(token.expiresAt);
+        if (Number.isNaN(expiresAtMs) || expiresAtMs - 60_000 > Date.now()) {
+            return token;
+        }
     }
     if (!token.refreshToken) {
         throw new Error("Access token expired and no refresh token is available. Run auth login again.");