@blazingagents/sdk 0.7.0 → 0.9.0

package/dist/contracts/entities/chat-connections.d.ts

@@ -0,0 +1,202 @@
+import { z } from "zod";
+export declare const chatCredentialsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    platform: z.ZodLiteral<"slack">;
+    botToken: z.ZodString;
+    signingSecret: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    platform: z.ZodLiteral<"telegram">;
+    botToken: z.ZodString;
+    webhookSecret: z.ZodString;
+}, z.core.$strict>], "platform">;
+export declare const chatConfigurationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    teamId: z.ZodString;
+    appId: z.ZodString;
+    webhookUrl: z.ZodURL;
+    channelIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    platform: z.ZodLiteral<"slack">;
+}, z.core.$strict>, z.ZodObject<{
+    botId: z.ZodString;
+    webhookUrl: z.ZodURL;
+    chatIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    platform: z.ZodLiteral<"telegram">;
+}, z.core.$strict>], "platform">;
+export declare const createChatConnectionBodySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    agentId: z.ZodString;
+    name: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    platform: z.ZodLiteral<"slack">;
+    configuration: z.ZodObject<{
+        teamId: z.ZodString;
+        appId: z.ZodString;
+        webhookUrl: z.ZodURL;
+        channelIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    credentials: z.ZodObject<{
+        botToken: z.ZodString;
+        signingSecret: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    agentId: z.ZodString;
+    name: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    platform: z.ZodLiteral<"telegram">;
+    configuration: z.ZodObject<{
+        botId: z.ZodString;
+        webhookUrl: z.ZodURL;
+        chatIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    credentials: z.ZodObject<{
+        botToken: z.ZodString;
+        webhookSecret: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>], "platform">;
+export declare const rotateChatConnectionBodySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    platform: z.ZodLiteral<"slack">;
+    botToken: z.ZodString;
+    signingSecret: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    platform: z.ZodLiteral<"telegram">;
+    botToken: z.ZodString;
+    webhookSecret: z.ZodString;
+}, z.core.$strict>], "platform">;
+export declare const updateChatConnectionBodySchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    webhookUrl: z.ZodOptional<z.ZodURL>;
+}, z.core.$strict>;
+export declare const chatConnectionParamsSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const chatHealthCheckSchema: z.ZodObject<{
+    code: z.ZodString;
+    status: z.ZodEnum<{
+        fail: "fail";
+        pass: "pass";
+        unknown: "unknown";
+    }>;
+    subject: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const chatHealthSchema: z.ZodObject<{
+    checkedAt: z.ZodString;
+    tokenValid: z.ZodBoolean;
+    identityVerified: z.ZodBoolean;
+    checks: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        status: z.ZodEnum<{
+            fail: "fail";
+            pass: "pass";
+            unknown: "unknown";
+        }>;
+        subject: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const chatIdentitySchema: z.ZodObject<{
+    botId: z.ZodString;
+    botUserId: z.ZodString;
+    teamId: z.ZodNullable<z.ZodString>;
+    appId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const chatConnectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    agentId: z.ZodString;
+    name: z.ZodString;
+    platform: z.ZodEnum<{
+        slack: "slack";
+        telegram: "telegram";
+    }>;
+    enabled: z.ZodBoolean;
+    configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        teamId: z.ZodString;
+        appId: z.ZodString;
+        webhookUrl: z.ZodURL;
+        channelIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        platform: z.ZodLiteral<"slack">;
+    }, z.core.$strip>, z.ZodObject<{
+        botId: z.ZodString;
+        webhookUrl: z.ZodURL;
+        chatIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        platform: z.ZodLiteral<"telegram">;
+    }, z.core.$strip>], "platform">;
+    identity: z.ZodObject<{
+        botId: z.ZodString;
+        botUserId: z.ZodString;
+        teamId: z.ZodNullable<z.ZodString>;
+        appId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    health: z.ZodObject<{
+        checkedAt: z.ZodString;
+        tokenValid: z.ZodBoolean;
+        identityVerified: z.ZodBoolean;
+        checks: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            status: z.ZodEnum<{
+                fail: "fail";
+                pass: "pass";
+                unknown: "unknown";
+            }>;
+            subject: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    credentialFragment: z.ZodString;
+    credentialVersion: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type CreateChatConnectionBody = z.input<typeof createChatConnectionBodySchema>;
+export type ChatCredentials = z.output<typeof chatCredentialsSchema>;
+export type ChatConfiguration = z.output<typeof chatConfigurationSchema>;
+export type ChatHealth = z.output<typeof chatHealthSchema>;
+export type ChatIdentity = z.output<typeof chatIdentitySchema>;
+export type ChatConnection = z.output<typeof chatConnectionSchema>;
+export type UpdateChatConnectionBody = z.output<typeof updateChatConnectionBodySchema>;
+export declare const chatConnectionsResponseSchema: z.ZodObject<{
+    chatConnections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tenantId: z.ZodString;
+        agentId: z.ZodString;
+        name: z.ZodString;
+        platform: z.ZodEnum<{
+            slack: "slack";
+            telegram: "telegram";
+        }>;
+        enabled: z.ZodBoolean;
+        configuration: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            teamId: z.ZodString;
+            appId: z.ZodString;
+            webhookUrl: z.ZodURL;
+            channelIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            platform: z.ZodLiteral<"slack">;
+        }, z.core.$strip>, z.ZodObject<{
+            botId: z.ZodString;
+            webhookUrl: z.ZodURL;
+            chatIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            platform: z.ZodLiteral<"telegram">;
+        }, z.core.$strip>], "platform">;
+        identity: z.ZodObject<{
+            botId: z.ZodString;
+            botUserId: z.ZodString;
+            teamId: z.ZodNullable<z.ZodString>;
+            appId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        health: z.ZodObject<{
+            checkedAt: z.ZodString;
+            tokenValid: z.ZodBoolean;
+            identityVerified: z.ZodBoolean;
+            checks: z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                status: z.ZodEnum<{
+                    fail: "fail";
+                    pass: "pass";
+                    unknown: "unknown";
+                }>;
+                subject: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        credentialFragment: z.ZodString;
+        credentialVersion: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ChatConnectionsResponse = z.output<typeof chatConnectionsResponseSchema>;
+export type RotateChatConnectionBody = z.input<typeof rotateChatConnectionBodySchema>;

package/dist/contracts/entities/chat-connections.js

@@ -0,0 +1,142 @@
+import { z } from "zod";
+import { agentIdSchema, chatConnectionIdSchema, tenantIdSchema, } from "../ids.js";
+const webhookUrl = z
+    .url()
+    .max(2048)
+    .refine((value) => {
+    const url = new URL(value);
+    return (url.protocol === "https:" &&
+        !url.username &&
+        !url.password &&
+        !url.search &&
+        !url.hash);
+}, "Use an HTTPS callback URL without credentials, query or fragment");
+const secret = z
+    .string()
+    .min(8)
+    .max(8192)
+    .regex(/^[!-~]+$/);
+export const chatCredentialsSchema = z.discriminatedUnion("platform", [
+    z
+        .object({
+        platform: z.literal("slack"),
+        botToken: secret,
+        signingSecret: z.string().regex(/^[0-9a-f]{32}$/),
+    })
+        .strict(),
+    z
+        .object({
+        platform: z.literal("telegram"),
+        botToken: z.string().regex(/^\d+:[A-Za-z0-9_-]+$/),
+        webhookSecret: z
+            .string()
+            .min(1)
+            .max(256)
+            .regex(/^[A-Za-z0-9_-]+$/),
+    })
+        .strict(),
+]);
+const slackConfiguration = z
+    .object({
+    teamId: z.string().regex(/^T[A-Z0-9]+$/),
+    appId: z.string().regex(/^A[A-Z0-9]+$/),
+    webhookUrl,
+    channelIds: z
+        .array(z.string().regex(/^[CG][A-Z0-9]+$/))
+        .max(20)
+        .default([]),
+})
+    .strict();
+const telegramConfiguration = z
+    .object({
+    botId: z.string().regex(/^\d+$/),
+    webhookUrl,
+    chatIds: z
+        .array(z.string().regex(/^-?\d+$/))
+        .max(20)
+        .default([]),
+})
+    .strict();
+export const chatConfigurationSchema = z.discriminatedUnion("platform", [
+    slackConfiguration.extend({ platform: z.literal("slack") }),
+    telegramConfiguration.extend({ platform: z.literal("telegram") }),
+]);
+const common = {
+    agentId: agentIdSchema,
+    name: z.string().trim().min(1).max(80),
+    enabled: z.boolean().default(true),
+};
+export const createChatConnectionBodySchema = z.discriminatedUnion("platform", [
+    z
+        .object({
+        ...common,
+        platform: z.literal("slack"),
+        configuration: slackConfiguration,
+        credentials: chatCredentialsSchema.options[0].omit({ platform: true }),
+    })
+        .strict(),
+    z
+        .object({
+        ...common,
+        platform: z.literal("telegram"),
+        configuration: telegramConfiguration,
+        credentials: chatCredentialsSchema.options[1].omit({ platform: true }),
+    })
+        .strict(),
+]);
+export const rotateChatConnectionBodySchema = chatCredentialsSchema;
+export const updateChatConnectionBodySchema = z
+    .object({ name: common.name.optional(), webhookUrl: webhookUrl.optional() })
+    .strict()
+    .refine((body) => body.name !== undefined || body.webhookUrl !== undefined, {
+    message: "Provide a name or webhook URL",
+});
+export const chatConnectionParamsSchema = z.object({
+    id: chatConnectionIdSchema,
+});
+export const chatHealthCheckSchema = z
+    .object({
+    code: z.string(),
+    status: z.enum(["pass", "fail", "unknown"]),
+    subject: z.string().optional(),
+})
+    .strip();
+export const chatHealthSchema = z
+    .object({
+    checkedAt: z.string(),
+    tokenValid: z.boolean(),
+    identityVerified: z.boolean(),
+    checks: z.array(chatHealthCheckSchema),
+})
+    .strip();
+export const chatIdentitySchema = z
+    .object({
+    botId: z.string(),
+    botUserId: z.string(),
+    teamId: z.string().nullable(),
+    appId: z.string().nullable(),
+})
+    .strip();
+export const chatConnectionSchema = z
+    .object({
+    id: chatConnectionIdSchema,
+    tenantId: tenantIdSchema,
+    agentId: agentIdSchema,
+    name: common.name,
+    platform: z.enum(["slack", "telegram"]),
+    enabled: z.boolean(),
+    configuration: z.discriminatedUnion("platform", [
+        chatConfigurationSchema.options[0].strip(),
+        chatConfigurationSchema.options[1].strip(),
+    ]),
+    identity: chatIdentitySchema,
+    health: chatHealthSchema,
+    credentialFragment: z.string().max(4),
+    credentialVersion: z.number().int().nonnegative(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+})
+    .strip();
+export const chatConnectionsResponseSchema = z
+    .object({ chatConnections: z.array(chatConnectionSchema) })
+    .strip();

package/dist/contracts/entities/sessions.d.ts

@@ -132,6 +132,32 @@ export declare const toolApprovalContinuationStateSchema: z.ZodEnum<{
     waiting: "waiting";
 }>;
 export declare const toolApprovalStateSchema: z.ZodObject<{
+    tool: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"builtin">;
+        name: z.ZodEnum<{
+            activate_skill: "activate_skill";
+            bash: "bash";
+            delete_memory: "delete_memory";
+            edit: "edit";
+            get_memory: "get_memory";
+            glob: "glob";
+            grep: "grep";
+            publish_artifacts: "publish_artifacts";
+            read: "read";
+            save_memory: "save_memory";
+            search_memories: "search_memories";
+            update_memory: "update_memory";
+            write: "write";
+            write_todos: "write_todos";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"mcp">;
+        connectionId: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>], "type">>>;
+    assistantMessageId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodISODateTime>;
+    decidedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
     approvalId: z.ZodString;
     decision: z.ZodEnum<{
         approved: "approved";
@@ -155,6 +181,32 @@ export declare const toolApprovalContinuationSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const toolApprovalsResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
+        tool: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"builtin">;
+            name: z.ZodEnum<{
+                activate_skill: "activate_skill";
+                bash: "bash";
+                delete_memory: "delete_memory";
+                edit: "edit";
+                get_memory: "get_memory";
+                glob: "glob";
+                grep: "grep";
+                publish_artifacts: "publish_artifacts";
+                read: "read";
+                save_memory: "save_memory";
+                search_memories: "search_memories";
+                update_memory: "update_memory";
+                write: "write";
+                write_todos: "write_todos";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"mcp">;
+            connectionId: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>], "type">>>;
+        assistantMessageId: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodOptional<z.ZodISODateTime>;
+        decidedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
         approvalId: z.ZodString;
         decision: z.ZodEnum<{
             approved: "approved";

package/dist/contracts/entities/sessions.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { paginatedResponseSchema } from "../api.js";
 import { agentIdSchema, sessionIdSchema } from "../ids.js";
 import { DEFAULT_SESSION_MESSAGES_LIMIT, MAX_SESSION_MESSAGES_LIMIT, } from "../limitations.js";
+import { toolReferenceSchema } from "./agent-approval.js";
 import { agentSchema, agentVersionNumberSchema } from "./agents.js";
 import { metadataSchema, userIdSchema } from "./attribution.js";
 /**
@@ -107,6 +108,10 @@ export const toolApprovalContinuationStateSchema = z.enum([
 ]);
 export const toolApprovalStateSchema = z
     .object({
+    tool: toolReferenceSchema.nullable().optional(),
+    assistantMessageId: z.string().min(1).optional(),
+    createdAt: z.iso.datetime({ offset: true }).optional(),
+    decidedAt: z.iso.datetime({ offset: true }).nullable().optional(),
     approvalId: z.string().min(1),
     decision: z.enum(["pending", "approved", "denied"]),
     input: z.json(),

package/dist/contracts/ids.d.ts

@@ -55,3 +55,4 @@ export declare const apiKeyDigestSchema: z.ZodString;
 export declare const apiKeyFragmentSchema: z.ZodString;
 export declare const providerKeyFragmentSchema: z.ZodString;
 export type TurnId = z.infer<typeof turnIdSchema>;
+export declare const chatConnectionIdSchema: z.ZodString;

package/dist/contracts/ids.js

@@ -77,3 +77,4 @@ export const apiKeyDigestSchema = z.string().regex(/^[0-9a-f]{64}$/);
 export const apiKeyFragmentSchema = z.string().regex(/^ba_[0-9A-Za-z]{2}$/);
 // Provider key fragment — last 4 chars of the secret, display-only.
 export const providerKeyFragmentSchema = z.string().min(1).max(4);
+export const chatConnectionIdSchema = z.string().regex(/^cc_[0-9A-Za-z]{16}$/);

package/dist/contracts/index.d.ts

@@ -1,10 +1,13 @@
 /** Public runtime schemas for the Blazing Agents HTTP API. */
 export { receivedApiErrorResponseSchema } from "./api.ts";
+export type { ApprovalDecision, ApprovalPolicy, ToolReference, } from "./entities/agent-approval.ts";
+export { approvalDecisionSchema, approvalPolicySchema, toolReferenceSchema, } from "./entities/agent-approval.ts";
 export { agentResponseSchema, agentSchema, agentStatusSchema, agentsResponseSchema, agentVersionSchema, agentVersionsResponseSchema, createAgentBodySchema, updateAgentBodySchema, } from "./entities/agents.ts";
 export { artifactDownloadUrlResponseSchema, artifactListItemSchema, artifactsListResponseSchema, } from "./entities/artifacts.ts";
 export { attributionCreateInputSchema, metadataSchema, } from "./entities/attribution.ts";
 export type { PromptVariables, UsageSummary } from "./entities/chat.ts";
 export { blazingAgentsChatMessageMetadataSchema, chatModeSchema, chatRequestBodySchema, chatTriggerSchema, generationRequestBodySchema, jsonSchemaShapeSchema, promptVariablesSchema, usageSummarySchema, } from "./entities/chat.ts";
+export { chatConfigurationSchema, chatConnectionSchema, chatConnectionsResponseSchema, chatCredentialsSchema, chatHealthCheckSchema, chatHealthSchema, chatIdentitySchema, createChatConnectionBodySchema, rotateChatConnectionBodySchema, updateChatConnectionBodySchema, } from "./entities/chat-connections.ts";
 export { approveMcpOauthAuthorizationBodySchema, createMcpConnectionBodySchema, mcpAttachmentResponseSchema, mcpAttachmentsResponseSchema, mcpConnectionAuthTypeSchema, mcpConnectionOauthConnectResponseSchema, mcpConnectionReconnectResultSchema, mcpConnectionResponseSchema, mcpConnectionStatusSchema, mcpConnectionsResponseSchema, mcpConnectionTestErrorCodeSchema, mcpConnectionTestResponseSchema, mcpOauthAuthorizationLaunchResponseSchema, reconnectMcpConnectionBodySchema, updateMcpAttachmentBodySchema, updateMcpConnectionBodySchema, } from "./entities/mcp-connections.ts";
 export { createMemoryBodySchema, memoriesListResponseSchema, memoryResponseSchema, memorySchema, updateMemoryBodySchema, } from "./entities/memories.ts";
 export { createPromptBodySchema, promptResponseSchema, promptSchema, promptsResponseSchema, updatePromptBodySchema, } from "./entities/prompts.ts";

package/dist/contracts/index.js

@@ -1,10 +1,12 @@
 /** Public runtime schemas for the Blazing Agents HTTP API. */
 // biome-ignore lint/performance/noBarrelFile: public contract entry point
 export { receivedApiErrorResponseSchema } from "./api.js";
+export { approvalDecisionSchema, approvalPolicySchema, toolReferenceSchema, } from "./entities/agent-approval.js";
 export { agentResponseSchema, agentSchema, agentStatusSchema, agentsResponseSchema, agentVersionSchema, agentVersionsResponseSchema, createAgentBodySchema, updateAgentBodySchema, } from "./entities/agents.js";
 export { artifactDownloadUrlResponseSchema, artifactListItemSchema, artifactsListResponseSchema, } from "./entities/artifacts.js";
 export { attributionCreateInputSchema, metadataSchema, } from "./entities/attribution.js";
 export { blazingAgentsChatMessageMetadataSchema, chatModeSchema, chatRequestBodySchema, chatTriggerSchema, generationRequestBodySchema, jsonSchemaShapeSchema, promptVariablesSchema, usageSummarySchema, } from "./entities/chat.js";
+export { chatConfigurationSchema, chatConnectionSchema, chatConnectionsResponseSchema, chatCredentialsSchema, chatHealthCheckSchema, chatHealthSchema, chatIdentitySchema, createChatConnectionBodySchema, rotateChatConnectionBodySchema, updateChatConnectionBodySchema, } from "./entities/chat-connections.js";
 export { approveMcpOauthAuthorizationBodySchema, createMcpConnectionBodySchema, mcpAttachmentResponseSchema, mcpAttachmentsResponseSchema, mcpConnectionAuthTypeSchema, mcpConnectionOauthConnectResponseSchema, mcpConnectionReconnectResultSchema, mcpConnectionResponseSchema, mcpConnectionStatusSchema, mcpConnectionsResponseSchema, mcpConnectionTestErrorCodeSchema, mcpConnectionTestResponseSchema, mcpOauthAuthorizationLaunchResponseSchema, reconnectMcpConnectionBodySchema, updateMcpAttachmentBodySchema, updateMcpConnectionBodySchema, } from "./entities/mcp-connections.js";
 export { createMemoryBodySchema, memoriesListResponseSchema, memoryResponseSchema, memorySchema, updateMemoryBodySchema, } from "./entities/memories.js";
 export { createPromptBodySchema, promptResponseSchema, promptSchema, promptsResponseSchema, updatePromptBodySchema, } from "./entities/prompts.js";

package/dist/index.d.ts

@@ -9,13 +9,16 @@
 export type { UIMessage } from "ai";
 export { BlazingAgentsChatTransport, type BlazingAgentsChatTransportOptions, } from "./chat-transport.ts";
 export { BlazingAgents } from "./client.ts";
+export type { ApprovalDecision, ApprovalPolicy, ToolReference, } from "./contracts/entities/agent-approval.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 { ChatConfiguration, ChatConnection, ChatConnectionsResponse, ChatCredentials, ChatHealth, ChatIdentity, CreateChatConnectionBody, RotateChatConnectionBody, UpdateChatConnectionBody, } from "./contracts/entities/chat-connections.ts";
 export type { CreateMcpConnectionBody, McpAttachmentResponse, McpAttachmentsResponse, McpConnectionAuthType, McpConnectionOauthConnectResponse, McpConnectionReconnectResult, McpConnectionResponse, McpConnectionStatus, McpConnectionTestResponse, ReconnectMcpConnectionBody, UpdateMcpAttachmentBody, UpdateMcpConnectionBody, } from "./contracts/entities/mcp-connections.ts";
 export type { CreateProviderBody, ProviderListItem, ProviderModel, ProviderModelsResponse, ProviderResponse, ProvidersResponse, ProviderType, ThinkingLevelsResponse, UpdateProviderBody, } from "./contracts/entities/providers.ts";
+export type { ToolApprovalDecisionResponse, ToolApprovalState, ToolApprovalsResponse, } from "./contracts/entities/sessions.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 { BlazingAgentsDirectChatTransport, type BlazingAgentsDirectChatTransportOptions, } from "./direct-chat-transport.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, LatestSessionsListOptions, McpConnectionsResource, MemoriesListOptions, MemoriesResource, ObjectInput, ObjectPromptIdInput, ObjectPromptInput, ObjectResult, PromptsResource, ProvidersResource, ResourceRequestOptions, ResponseObservation, SessionsResource, SkillsListOptions, TasksResource, TenantResource, TerminalStreamResult, UsageResource, WorkspacesListOptions, WorkspacesResource, } from "./types.ts";
+export type { AgentClient, AgentSkillsResource, AgentsListOptions, AgentsResource, AgentVersionsListOptions, ArtifactsResource, AttributionInput, BlazingAgentsErrorCode, BlazingAgentsOptions, BlazingAgentsRequestOptions, BlazingAgentsUIMessage, BlazingAgentsUIMessageChunk, ChatConnectionsResource, ChatInput, ChatMessageInput, ChatPromptInput, ChatResult, ChatTrigger, CompletionInput, CompletionPromptIdInput, CompletionPromptInput, CompletionResult, KnownBlazingAgentsErrorCode, LatestSessionsListOptions, McpConnectionsResource, MemoriesListOptions, MemoriesResource, ObjectInput, ObjectPromptIdInput, ObjectPromptInput, ObjectResult, PromptsResource, ProvidersResource, ResourceRequestOptions, ResponseObservation, SessionsResource, SkillsListOptions, TasksResource, TenantResource, TerminalStreamResult, UsageResource, WorkspacesListOptions, WorkspacesResource, } from "./types.ts";

package/dist/resources/agents.js

@@ -59,6 +59,8 @@ export function createAgentsResource(config) {
             return update({
                 agentId,
                 abortSignal,
+                approvalInChat: version.approvalInChat,
+                approvalInTasks: version.approvalInTasks,
                 name: version.name,
                 model: version.model,
                 thinkingLevel: version.thinkingLevel,

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

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

package/dist/resources/chat-connections.js

@@ -0,0 +1,33 @@
+import { chatConnectionSchema, chatConnectionsResponseSchema, } from "../contracts/entities/chat-connections.js";
+import { requestJson } from "../http.js";
+export function createChatConnectionsResource(config) {
+    return {
+        async list({ abortSignal } = {}) {
+            return await requestJson(config, "/v1/chat-connections", { signal: abortSignal }, chatConnectionsResponseSchema);
+        },
+        async create({ abortSignal, ...body }) {
+            return await requestJson(config, "/v1/chat-connections", { signal: abortSignal, method: "POST", json: body }, chatConnectionSchema);
+        },
+        async get({ chatConnectionId, abortSignal }) {
+            return await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}`, { signal: abortSignal, method: "GET" }, chatConnectionSchema);
+        },
+        async update({ chatConnectionId, abortSignal, ...body }) {
+            return await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}`, { signal: abortSignal, method: "PATCH", json: body }, chatConnectionSchema);
+        },
+        async rotateCredentials({ chatConnectionId, abortSignal, ...body }) {
+            return await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}/credentials`, { signal: abortSignal, method: "POST", json: body }, chatConnectionSchema);
+        },
+        async checkHealth({ chatConnectionId, abortSignal }) {
+            return await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}/health`, { signal: abortSignal, method: "POST" }, chatConnectionSchema);
+        },
+        async enable({ chatConnectionId, abortSignal }) {
+            return await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}/enable`, { signal: abortSignal, method: "POST" }, chatConnectionSchema);
+        },
+        async disable({ chatConnectionId, abortSignal }) {
+            return await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}/disable`, { signal: abortSignal, method: "POST" }, chatConnectionSchema);
+        },
+        async delete({ chatConnectionId, abortSignal }) {
+            await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}`, { signal: abortSignal, method: "DELETE" });
+        },
+    };
+}

package/dist/types.d.ts

@@ -3,6 +3,7 @@ import type { ApiErrorCode } from "./contracts/api.ts";
 import type { Agent, AgentsResponse, AgentVersion, AgentVersionsResponse, CreateAgentBody, UpdateAgentBody } from "./contracts/entities/agents.ts";
 import type { ArtifactDownloadUrlResponse, ArtifactListItem, ArtifactsListResponse } from "./contracts/entities/artifacts.ts";
 import type { BlazingAgentsChatMessageMetadata } from "./contracts/entities/chat.ts";
+import type { ChatConnection, ChatConnectionsResponse, CreateChatConnectionBody, RotateChatConnectionBody, UpdateChatConnectionBody } from "./contracts/entities/chat-connections.ts";
 import type { CreateMcpConnectionBody, McpAttachmentResponse, McpAttachmentsResponse, McpConnectionOauthConnectResponse, McpConnectionReconnectResult, McpConnectionResponse, McpConnectionsResponse, McpConnectionTestResponse, ReconnectMcpConnectionBody, UpdateMcpAttachmentBody, UpdateMcpConnectionBody } from "./contracts/entities/mcp-connections.ts";
 import type { CreateMemoryBody, MemoriesListResponse, MemoryResponse, UpdateMemoryBody } from "./contracts/entities/memories.ts";
 import type { CreatePromptBody, PromptResponse, PromptsResponse, UpdatePromptBody } from "./contracts/entities/prompts.ts";
@@ -511,4 +512,29 @@ export interface UsageResource {
         agentId: string;
     } & ResourceRequestOptions): Promise<UsageResponse>;
 }
+export interface ChatConnectionsResource {
+    checkHealth(input: {
+        chatConnectionId: string;
+    } & ResourceRequestOptions): Promise<ChatConnection>;
+    create(input: CreateChatConnectionBody & ResourceRequestOptions): Promise<ChatConnection>;
+    delete(input: {
+        chatConnectionId: string;
+    } & ResourceRequestOptions): Promise<void>;
+    disable(input: {
+        chatConnectionId: string;
+    } & ResourceRequestOptions): Promise<ChatConnection>;
+    enable(input: {
+        chatConnectionId: string;
+    } & ResourceRequestOptions): Promise<ChatConnection>;
+    get(input: {
+        chatConnectionId: string;
+    } & ResourceRequestOptions): Promise<ChatConnection>;
+    list(input?: ResourceRequestOptions): Promise<ChatConnectionsResponse>;
+    rotateCredentials(input: RotateChatConnectionBody & {
+        chatConnectionId: string;
+    } & ResourceRequestOptions): Promise<ChatConnection>;
+    update(input: UpdateChatConnectionBody & {
+        chatConnectionId: string;
+    } & ResourceRequestOptions): Promise<ChatConnection>;
+}
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blazingagents/sdk",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "TypeScript SDK for the Blazing Agents API",
   "homepage": "https://docs.blazingagents.com",
   "bugs": {