@blazingagents/sdk 0.1.0

package/dist/http.js

@@ -0,0 +1,307 @@
+import { receivedApiErrorResponseSchema } from "./contracts/api.js";
+import { BlazingAgentsError } from "./errors.js";
+const DIAGNOSTIC_BODY_LIMIT_BYTES = 64 * 1024;
+const INVALID_RESPONSE_MESSAGE = "The server returned an invalid response.";
+const NETWORK_ERROR_MESSAGE = "Network request failed (fetch threw before any HTTP exchange).";
+const REQUEST_ABORTED_MESSAGE = "The request was aborted before any HTTP response.";
+/**
+ * The fetch client — a thin wrapper in the stripe/openai-node shape.
+ * `apiKey` rides the `Authorization: Bearer ${apiKey}` header; `baseUrl`
+ * defaults to the local api dev port. No OpenAI wire compatibility.
+ */
+function buildUrl(baseUrl, path, query) {
+    const url = `${baseUrl}${path}`;
+    if (!query) {
+        return url;
+    }
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null) {
+            continue;
+        }
+        params.append(key, String(value));
+    }
+    const qs = params.toString();
+    return qs.length > 0 ? `${url}?${qs}` : url;
+}
+/**
+ * Performs a request and returns the parsed JSON body for success (status
+ * 2xx). API errors preserve the tolerant wire envelope; malformed responses
+ * become `invalid_response`.
+ */
+export async function requestJson(config, path, options = {}, schema) {
+    const response = await rawRequest(config, path, options);
+    if (response.status < 200 || response.status >= 300) {
+        throw await errorFromResponse(response, options.signal);
+    }
+    const headers = new Headers(response.headers);
+    if (response.status === 204) {
+        try {
+            return schema === undefined ? undefined : schema.parse(undefined);
+        }
+        catch (cause) {
+            throw invalidResponseError(headers, response.status, "", false, cause);
+        }
+    }
+    const read = await readResponseBody(response, false);
+    if (read.readFailed) {
+        if (isRequestAborted(read.cause, options.signal)) {
+            throw requestAbortedError(read.cause);
+        }
+        throw invalidResponseError(headers, response.status, read.diagnosticBody, true, read.cause);
+    }
+    try {
+        const json = JSON.parse(read.bodyText);
+        return schema === undefined ? json : schema.parse(json);
+    }
+    catch (cause) {
+        throw invalidResponseError(headers, response.status, read.diagnosticBody, read.diagnosticBodyTruncated, cause);
+    }
+}
+/**
+ * Performs a request and returns the raw `Response` for streaming paths.
+ * Non-2xx bodies are decoded before a caller can observe a streaming body.
+ */
+export async function requestStream(config, path, options = {}) {
+    const response = await rawRequest(config, path, options);
+    if (response.status >= 200 && response.status < 300) {
+        return response;
+    }
+    throw await errorFromResponse(response, options.signal);
+}
+async function rawRequest(config, path, options) {
+    const fetchImpl = config.fetch ?? globalThis.fetch;
+    const url = buildUrl(config.baseUrl, path, options.query);
+    const method = options.method ?? "GET";
+    const startedAt = performance.now();
+    const clientRequestId = options.clientRequestId ?? config.clientRequestId;
+    const headers = {
+        authorization: `Bearer ${config.apiKey}`,
+        ...(options.headers ?? {}),
+        ...(clientRequestId === undefined
+            ? {}
+            : { "x-client-request-id": clientRequestId }),
+    };
+    let body = options.body ?? null;
+    if (options.json !== undefined) {
+        headers["content-type"] = "application/json";
+        body = JSON.stringify(options.json);
+    }
+    try {
+        const response = await fetchImpl(url, {
+            method,
+            headers,
+            body,
+            ...(options.signal ? { signal: options.signal } : {}),
+        });
+        try {
+            config.onResponse?.({
+                method,
+                path,
+                status: response.status,
+                durationMs: performance.now() - startedAt,
+                requestId: response.headers.get("x-request-id") ?? undefined,
+                ...(clientRequestId === undefined ? {} : { clientRequestId }),
+            });
+        }
+        catch {
+            /** Observation must not affect transport or response ownership. */
+        }
+        return response;
+    }
+    catch (cause) {
+        const requestAborted = isRequestAborted(cause, options.signal);
+        if (requestAborted) {
+            throw requestAbortedError(cause);
+        }
+        let message = NETWORK_ERROR_MESSAGE;
+        if (cause instanceof Error) {
+            message = cause.message;
+        }
+        throw new BlazingAgentsError({
+            code: "network_error",
+            message,
+        }, { cause });
+    }
+}
+async function errorFromResponse(response, signal) {
+    const read = await readResponseBody(response, true);
+    if (read.readFailed && isRequestAborted(read.cause, signal)) {
+        return requestAbortedError(read.cause);
+    }
+    const headers = new Headers(response.headers);
+    if (read.readFailed || read.diagnosticBodyTruncated) {
+        return invalidResponseError(headers, response.status, read.diagnosticBody, read.diagnosticBodyTruncated, read.cause);
+    }
+    return parseErrorEnvelope(read.diagnosticBody, response.status, headers);
+}
+function isRequestAborted(cause, signal) {
+    return (signal?.aborted === true ||
+        (cause !== null &&
+            typeof cause === "object" &&
+            "name" in cause &&
+            cause.name === "AbortError"));
+}
+function requestAbortedError(cause) {
+    return new BlazingAgentsError({
+        code: "request_aborted",
+        message: cause instanceof Error ? cause.message : REQUEST_ABORTED_MESSAGE,
+    }, { cause });
+}
+/**
+ * Reads a response while retaining at most 64 KiB of UTF-8 diagnostics.
+ * Error responses stop as soon as the body is known to exceed the limit.
+ * Successful JSON responses continue so legitimate large payloads can parse.
+ */
+async function readResponseBody(response, stopAtDiagnosticLimit) {
+    if (response.body === null) {
+        return {
+            bodyText: "",
+            diagnosticBody: "",
+            diagnosticBodyTruncated: false,
+            readFailed: false,
+        };
+    }
+    let reader;
+    try {
+        reader = response.body.getReader();
+    }
+    catch (cause) {
+        return {
+            bodyText: "",
+            cause,
+            diagnosticBody: "",
+            diagnosticBodyTruncated: true,
+            readFailed: true,
+        };
+    }
+    const chunks = [];
+    let byteLength = 0;
+    while (true) {
+        let read;
+        try {
+            read = await reader.read();
+        }
+        catch (cause) {
+            const diagnostic = decodeDiagnosticChunks(chunks, Math.min(byteLength, DIAGNOSTIC_BODY_LIMIT_BYTES), true);
+            return {
+                bodyText: "",
+                cause,
+                diagnosticBody: diagnostic.body,
+                diagnosticBodyTruncated: true,
+                readFailed: true,
+            };
+        }
+        if (read.done) {
+            const diagnostic = decodeDiagnosticChunks(chunks, Math.min(byteLength, DIAGNOSTIC_BODY_LIMIT_BYTES), byteLength > DIAGNOSTIC_BODY_LIMIT_BYTES);
+            return {
+                bodyText: stopAtDiagnosticLimit
+                    ? diagnostic.body
+                    : decodeChunks(chunks, byteLength, false),
+                diagnosticBody: diagnostic.body,
+                diagnosticBodyTruncated: diagnostic.truncated,
+                readFailed: false,
+            };
+        }
+        const chunk = read.value;
+        if (stopAtDiagnosticLimit &&
+            byteLength + chunk.byteLength > DIAGNOSTIC_BODY_LIMIT_BYTES) {
+            const remaining = DIAGNOSTIC_BODY_LIMIT_BYTES - byteLength;
+            if (remaining > 0) {
+                chunks.push(chunk.slice(0, remaining));
+                byteLength += remaining;
+            }
+            return cancelTruncatedBody(reader, chunks, byteLength);
+        }
+        chunks.push(chunk);
+        byteLength += chunk.byteLength;
+    }
+}
+async function cancelTruncatedBody(reader, chunks, byteLength) {
+    const diagnosticBody = decodeDiagnosticChunks(chunks, byteLength, true).body;
+    try {
+        await reader.cancel();
+        return {
+            bodyText: diagnosticBody,
+            diagnosticBody,
+            diagnosticBodyTruncated: true,
+            readFailed: false,
+        };
+    }
+    catch (cause) {
+        return {
+            bodyText: diagnosticBody,
+            cause,
+            diagnosticBody,
+            diagnosticBodyTruncated: true,
+            readFailed: true,
+        };
+    }
+}
+function decodeDiagnosticChunks(chunks, byteLength, sourceTruncated) {
+    const body = decodeChunks(chunks, byteLength, sourceTruncated);
+    const encoded = new TextEncoder().encode(body);
+    if (encoded.byteLength <= DIAGNOSTIC_BODY_LIMIT_BYTES) {
+        return { body, truncated: sourceTruncated };
+    }
+    return {
+        body: decodeChunks([encoded.slice(0, DIAGNOSTIC_BODY_LIMIT_BYTES)], DIAGNOSTIC_BODY_LIMIT_BYTES, true),
+        truncated: true,
+    };
+}
+function decodeChunks(chunks, byteLength, truncated) {
+    const bytes = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        if (offset === byteLength) {
+            break;
+        }
+        const retained = chunk.subarray(0, byteLength - offset);
+        bytes.set(retained, offset);
+        offset += retained.byteLength;
+    }
+    return new TextDecoder().decode(bytes, truncated ? { stream: true } : {});
+}
+/**
+ * Decodes a response body with the tolerant consumer schema. Unknown future
+ * codes and fields remain valid; malformed responses never infer a domain
+ * code from HTTP status.
+ */
+export function parseErrorEnvelope(bodyText, status, headers = new Headers()) {
+    let parsed;
+    if (bodyText.length === 0) {
+        parsed = null;
+    }
+    else {
+        try {
+            parsed = JSON.parse(bodyText);
+        }
+        catch (cause) {
+            return invalidResponseError(headers, status, bodyText, false, cause);
+        }
+    }
+    const result = receivedApiErrorResponseSchema.safeParse(parsed);
+    if (result.success) {
+        return new BlazingAgentsError({
+            code: result.data.error.code,
+            details: result.data.error.details,
+            headers,
+            message: result.data.error.message,
+            param: result.data.error.param,
+            requestId: headers.get("x-request-id") ?? undefined,
+            status,
+        });
+    }
+    return invalidResponseError(headers, status, bodyText, false);
+}
+function invalidResponseError(headers, status, responseBody, responseBodyTruncated, cause) {
+    return new BlazingAgentsError({
+        code: "invalid_response",
+        headers,
+        message: INVALID_RESPONSE_MESSAGE,
+        requestId: headers.get("x-request-id") ?? undefined,
+        responseBody,
+        responseBodyTruncated: responseBodyTruncated ? true : undefined,
+        status,
+    }, cause === undefined ? undefined : { cause });
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `@blazingagents/sdk` — the resource-style client SDK for the
+ * Blazing Agents `/v1` API. `ai` is a peer dependency (`^7`);
+ * `UIMessage` is re-exported from `ai`, never redeclared.
+ *
+ * This is the package's entry point — a barrel file that re-exports the
+ * public surface from the internal modules.
+ */
+export type { UIMessage } from "ai";
+export { BlazingAgentsChatTransport, type BlazingAgentsChatTransportOptions, } from "./chat-transport.ts";
+export { BlazingAgents } from "./client.ts";
+export type { Agent, AgentResponse, AgentsResponse, AgentVersion, AgentVersionsListQuery, AgentVersionsResponse, CreateAgentBody, UpdateAgentBody, } from "./contracts/entities/agents.ts";
+export type { ArtifactDownloadUrlResponse, ArtifactListItem, ArtifactsListResponse, } from "./contracts/entities/artifacts.ts";
+export type { CreateMcpConnectionBody, McpAttachmentResponse, McpAttachmentsResponse, McpConnectionAuthType, McpConnectionOauthConnectResponse, McpConnectionReconnectResult, McpConnectionResponse, McpConnectionStatus, McpConnectionTestResponse, ReconnectMcpConnectionBody, UpdateMcpAttachmentBody, UpdateMcpConnectionBody, } from "./contracts/entities/mcp-connections.ts";
+export type { CreateProviderBody, ProviderModel, ProviderModelsResponse, ProviderResponse, ProvidersResponse, ProviderType, UpdateProviderBody, } from "./contracts/entities/providers.ts";
+export type { CreateSkillBody, Skill, SkillArchiveType, SkillCopyResult, SkillCopyResults, SkillDetail, SkillFile, SkillsListResponse, } from "./contracts/entities/skills.ts";
+export type { CreateWorkspaceBody, UpdateWorkspaceBody, Workspace, WorkspaceNetworkPolicy, WorkspacesListResponse, } from "./contracts/entities/workspaces.ts";
+export { BlazingAgentsError } from "./errors.ts";
+export { createChatRelay, createCompletionRelay, type RelayContext, type SessionOwnershipStore, } from "./relay.ts";
+export type { AgentClient, AgentSkillsResource, AgentsListOptions, AgentsResource, AgentVersionsListOptions, ArtifactsResource, AttributionInput, BlazingAgentsErrorCode, BlazingAgentsOptions, BlazingAgentsRequestOptions, BlazingAgentsUIMessage, BlazingAgentsUIMessageChunk, ChatInput, ChatMessageInput, ChatPromptInput, ChatResult, ChatTrigger, CompletionInput, CompletionPromptIdInput, CompletionPromptInput, CompletionResult, KnownBlazingAgentsErrorCode, McpConnectionsResource, MemoriesListOptions, MemoriesResource, ObjectInput, ObjectPromptIdInput, ObjectPromptInput, ObjectResult, PromptsResource, ProvidersResource, ResponseObservation, SessionsResource, SkillsListOptions, TasksResource, TenantResource, TerminalStreamResult, UsageResource, WorkspacesListOptions, WorkspacesResource, } from "./types.ts";

package/dist/index.js

@@ -0,0 +1,13 @@
+/**
+ * `@blazingagents/sdk` — the resource-style client SDK for the
+ * Blazing Agents `/v1` API. `ai` is a peer dependency (`^7`);
+ * `UIMessage` is re-exported from `ai`, never redeclared.
+ *
+ * This is the package's entry point — a barrel file that re-exports the
+ * public surface from the internal modules.
+ */
+// biome-ignore lint/performance/noBarrelFile: package entry point
+export { BlazingAgentsChatTransport, } from "./chat-transport.js";
+export { BlazingAgents } from "./client.js";
+export { BlazingAgentsError } from "./errors.js";
+export { createChatRelay, createCompletionRelay, } from "./relay.js";

package/dist/relay.d.ts

@@ -0,0 +1,20 @@
+import type { BlazingAgents } from "./client.ts";
+export interface RelayContext {
+    agentId: string;
+    metadata?: Record<string, unknown>;
+    userId: string;
+    version?: number;
+}
+export interface SessionOwnershipStore {
+    ownerOf(sessionId: string): Promise<string | undefined>;
+    recordOwner(sessionId: string, userId: string): Promise<void>;
+}
+interface RelayOptions {
+    client: Pick<BlazingAgents, "chat" | "completion">;
+    resolveContext(request: Request): Promise<RelayContext | null>;
+}
+export declare function createChatRelay(options: RelayOptions & {
+    sessions: SessionOwnershipStore;
+}): (request: Request) => Promise<Response>;
+export declare function createCompletionRelay(options: RelayOptions): (request: Request) => Promise<Response>;
+export {};

package/dist/relay.js

@@ -0,0 +1,113 @@
+import { safeValidateUIMessages } from "ai";
+import { z } from "zod";
+import { sessionIdSchema } from "./contracts/ids.js";
+import { BlazingAgentsError } from "./errors.js";
+const chatBodySchema = z.object({
+    message: z.unknown(),
+    messageId: z.string().min(1).optional(),
+    sessionId: sessionIdSchema.optional(),
+    trigger: z
+        .enum(["submit-message", "regenerate-message"])
+        .default("submit-message"),
+});
+const completionBodySchema = z.object({ prompt: z.string().trim().min(1) });
+export function createChatRelay(options) {
+    return async (request) => {
+        try {
+            const context = await options.resolveContext(request);
+            if (!context) {
+                return errorResponse(401, "unauthorized", "Authentication required.");
+            }
+            const body = chatBodySchema.parse(await request.json());
+            const validated = await safeValidateUIMessages({
+                messages: [body.message],
+            });
+            if (!validated.success) {
+                return errorResponse(400, "invalid_request", "Invalid chat message.");
+            }
+            if (body.sessionId !== undefined &&
+                (await options.sessions.ownerOf(body.sessionId)) !== context.userId) {
+                return errorResponse(403, "forbidden", "Session is not available.");
+            }
+            const chatInput = {
+                agentId: context.agentId,
+                message: validated.data[0],
+                messageId: body.messageId,
+                metadata: context.metadata,
+                signal: request.signal,
+                userId: context.userId,
+            };
+            const result = await options.client.chat(body.sessionId === undefined
+                ? {
+                    ...chatInput,
+                    trigger: "submit-message",
+                    version: context.version,
+                }
+                : {
+                    ...chatInput,
+                    sessionId: body.sessionId,
+                    trigger: body.trigger,
+                });
+            const sessionId = await result.sessionId;
+            if (body.sessionId === undefined) {
+                try {
+                    await options.sessions.recordOwner(sessionId, context.userId);
+                }
+                catch (error) {
+                    await result
+                        .toResponse()
+                        .body?.cancel(error)
+                        .catch(() => undefined);
+                    throw error;
+                }
+            }
+            return result.toResponse();
+        }
+        catch (error) {
+            return safeErrorResponse(error);
+        }
+    };
+}
+export function createCompletionRelay(options) {
+    return async (request) => {
+        try {
+            const context = await options.resolveContext(request);
+            if (!context) {
+                return errorResponse(401, "unauthorized", "Authentication required.");
+            }
+            const body = completionBodySchema.parse(await request.json());
+            const result = await options.client.completion({
+                agentId: context.agentId,
+                metadata: context.metadata,
+                prompt: body.prompt,
+                signal: request.signal,
+                userId: context.userId,
+                version: context.version,
+            });
+            return result.toResponse();
+        }
+        catch (error) {
+            return safeErrorResponse(error);
+        }
+    };
+}
+function safeErrorResponse(error) {
+    if (error instanceof z.ZodError || error instanceof SyntaxError) {
+        return errorResponse(400, "invalid_request", "Invalid request body.");
+    }
+    if (BlazingAgentsError.isInstance(error)) {
+        const status = error.status ?? (error.code === "request_aborted" ? 499 : 502);
+        const headers = new Headers();
+        const requestId = error.requestId ?? error.headers?.get("x-request-id");
+        if (requestId) {
+            headers.set("x-request-id", requestId);
+        }
+        return errorResponse(status, error.code, error.message, headers);
+    }
+    return errorResponse(500, "internal_error", "Request failed.");
+}
+function errorResponse(status, code, message, headers) {
+    const responseHeaders = new Headers(headers);
+    responseHeaders.set("content-type", "application/json");
+    return Response.json({ error: { code, message } }, { status, headers: responseHeaders });
+}

package/dist/resources/agents.d.ts

@@ -0,0 +1,8 @@
+import type { AgentsResource, HttpConfig } from "../types.ts";
+/**
+ * `client.agents` — full CRUD over `/v1/agents`. The list endpoint is
+ * unpaginated (bounded by the 100/tenant cap); create/update bodies are
+ * the core zod contracts' input shapes. Responses are parsed against the
+ * core wire schemas (parse-on-read).
+ */
+export declare function createAgentsResource(config: HttpConfig): AgentsResource;

package/dist/resources/agents.js

@@ -0,0 +1,82 @@
+import { agentResponseSchema, agentsResponseSchema, agentVersionSchema, agentVersionsResponseSchema, } from "../contracts/entities/agents.js";
+import { mcpAttachmentResponseSchema, mcpAttachmentsResponseSchema, } from "../contracts/entities/mcp-connections.js";
+import { requestJson } from "../http.js";
+/**
+ * `client.agents` — full CRUD over `/v1/agents`. The list endpoint is
+ * unpaginated (bounded by the 100/tenant cap); create/update bodies are
+ * the core zod contracts' input shapes. Responses are parsed against the
+ * core wire schemas (parse-on-read).
+ */
+export function createAgentsResource(config) {
+    const getVersion = async (agentId, version) => requestJson(config, `/v1/agents/${agentId}/versions/${version}`, {}, agentVersionSchema);
+    const update = async (agentId, body) => requestJson(config, `/v1/agents/${agentId}`, {
+        json: body,
+        method: "PUT",
+    }, agentResponseSchema);
+    return {
+        async create(body) {
+            return await requestJson(config, "/v1/agents", {
+                json: body,
+                method: "POST",
+            }, agentResponseSchema);
+        },
+        async list(options = {}) {
+            return await requestJson(config, "/v1/agents", {
+                query: {
+                    userId: options.userId,
+                    workspaceId: options.workspaceId,
+                },
+            }, agentsResponseSchema);
+        },
+        async get(agentId) {
+            return await requestJson(config, `/v1/agents/${agentId}`, {}, agentResponseSchema);
+        },
+        async disable(agentId) {
+            return await requestJson(config, `/v1/agents/${agentId}/disable`, { method: "POST" }, agentResponseSchema);
+        },
+        async enable(agentId) {
+            return await requestJson(config, `/v1/agents/${agentId}/enable`, { method: "POST" }, agentResponseSchema);
+        },
+        getVersion,
+        async listVersions(agentId, options = {}) {
+            return await requestJson(config, `/v1/agents/${agentId}/versions`, { query: { cursor: options.cursor, limit: options.limit } }, agentVersionsResponseSchema);
+        },
+        async listMcpAttachments(agentId) {
+            return await requestJson(config, `/v1/agents/${agentId}/mcp-attachments`, {}, mcpAttachmentsResponseSchema);
+        },
+        async restoreVersion(agentId, versionNumber) {
+            const version = await getVersion(agentId, versionNumber);
+            return update(agentId, {
+                name: version.name,
+                model: version.model,
+                providerId: version.providerId,
+                memoryInjectionEnabled: version.memoryInjectionEnabled,
+                tools: version.tools,
+                instructions: version.instructions,
+                metadata: version.metadata,
+                mcpConnectionIds: version.mcpConnectionIds,
+            });
+        },
+        update,
+        async updateMcpAttachment(agentId, mcpConnectionId, body) {
+            return await requestJson(config, `/v1/agents/${agentId}/mcp-attachments/${mcpConnectionId}`, { json: body, method: "PATCH" }, mcpAttachmentResponseSchema);
+        },
+        async delete(agentId, includeArtifacts) {
+            await requestJson(config, `/v1/agents/${agentId}`, {
+                method: "DELETE",
+                query: { includeArtifacts },
+            });
+        },
+        async uploadAvatar(agentId, file) {
+            const form = new FormData();
+            form.append("file", file);
+            return await requestJson(config, `/v1/agents/${agentId}/avatar`, {
+                body: form,
+                method: "POST",
+            }, agentResponseSchema);
+        },
+        async removeAvatar(agentId) {
+            return await requestJson(config, `/v1/agents/${agentId}/avatar`, { method: "DELETE" }, agentResponseSchema);
+        },
+    };
+}

package/dist/resources/artifacts.d.ts

@@ -0,0 +1,5 @@
+import type { ArtifactsResource, HttpConfig } from "../types.ts";
+/**
+ * `client.artifacts` — Tenant-level metadata and direct download URLs.
+ */
+export declare function createArtifactsResource(config: HttpConfig): ArtifactsResource;

package/dist/resources/artifacts.js

@@ -0,0 +1,29 @@
+import { artifactDownloadUrlResponseSchema, artifactListItemSchema, artifactsListResponseSchema, } from "../contracts/entities/artifacts.js";
+import { requestJson } from "../http.js";
+/**
+ * `client.artifacts` — Tenant-level metadata and direct download URLs.
+ */
+export function createArtifactsResource(config) {
+    return {
+        async createDownloadUrl(artifactId) {
+            return await requestJson(config, `/v1/artifacts/${artifactId}/download-url`, { method: "POST" }, artifactDownloadUrlResponseSchema);
+        },
+        async get(artifactId) {
+            return await requestJson(config, `/v1/artifacts/${artifactId}`, {}, artifactListItemSchema);
+        },
+        async list(options = {}) {
+            return await requestJson(config, "/v1/artifacts", {
+                query: {
+                    agentId: options.agentId,
+                    sessionId: options.sessionId,
+                    cursor: options.cursor,
+                },
+            }, artifactsListResponseSchema);
+        },
+        async delete(artifactId) {
+            await requestJson(config, `/v1/artifacts/${artifactId}`, {
+                method: "DELETE",
+            });
+        },
+    };
+}

package/dist/resources/mcp-connections.d.ts

@@ -0,0 +1,2 @@
+import type { HttpConfig, McpConnectionsResource } from "../types.ts";
+export declare function createMcpConnectionsResource(config: HttpConfig): McpConnectionsResource;

package/dist/resources/mcp-connections.js

@@ -0,0 +1,40 @@
+import { mcpConnectionOauthConnectResponseSchema, mcpConnectionReconnectResultSchema, mcpConnectionResponseSchema, mcpConnectionsResponseSchema, mcpConnectionTestResponseSchema, reconnectMcpConnectionBodySchema, updateMcpConnectionBodySchema, } from "../contracts/entities/mcp-connections.js";
+import { requestJson } from "../http.js";
+export function createMcpConnectionsResource(config) {
+    const create = (async (body) => requestJson(config, "/v1/mcp-connections", {
+        json: body,
+        method: "POST",
+    }, mcpConnectionResponseSchema));
+    return {
+        async connect(id) {
+            return await requestJson(config, `/v1/mcp-connections/${id}/connect`, { method: "POST" }, mcpConnectionOauthConnectResponseSchema);
+        },
+        create,
+        async list() {
+            return await requestJson(config, "/v1/mcp-connections", {}, mcpConnectionsResponseSchema);
+        },
+        async get(id) {
+            return await requestJson(config, `/v1/mcp-connections/${id}`, {}, mcpConnectionResponseSchema);
+        },
+        async update(id, body) {
+            return await requestJson(config, `/v1/mcp-connections/${id}`, {
+                json: updateMcpConnectionBodySchema.parse(body),
+                method: "PATCH",
+            }, mcpConnectionResponseSchema);
+        },
+        async delete(id) {
+            await requestJson(config, `/v1/mcp-connections/${id}`, {
+                method: "DELETE",
+            });
+        },
+        async test(id) {
+            return await requestJson(config, `/v1/mcp-connections/${id}/test`, { method: "POST" }, mcpConnectionTestResponseSchema);
+        },
+        async reconnect(id, body) {
+            return await requestJson(config, `/v1/mcp-connections/${id}/reconnect`, {
+                json: reconnectMcpConnectionBodySchema.parse(body),
+                method: "POST",
+            }, mcpConnectionReconnectResultSchema);
+        },
+    };
+}

package/dist/resources/memories.d.ts

@@ -0,0 +1,7 @@
+import type { HttpConfig, MemoriesResource } from "../types.ts";
+/**
+ * `client.memories` — CRUD and query over `/v1/agents/:agentId/memories`.
+ * Memories are Agent-nested; `userId` is stamped at creation and immutable,
+ * while list can filter it (including explicit `''`) or full-text search.
+ */
+export declare function createMemoriesResource(config: HttpConfig): MemoriesResource;