@blazingagents/sdk 0.8.0 → 0.9.1

package/README.md

@@ -16,7 +16,7 @@ requires Node.js 24 or newer.
 ## Features
 
 - Typed clients for Agents, Workspaces, Skills, Providers, Prompts, Tasks,
-  Sessions, Artifacts, usage, and Tenant settings.
+  Sessions, Artifacts, Slack and Telegram Chat Connections, usage, and Tenant settings.
 - Stateful chat and stateless text or structured-object generation.
 - Public Zod contracts for validating API requests and responses.
 - Cursor pagination and binary transfers.
@@ -232,3 +232,9 @@ ordinary-policy reference). Persisted approval decisions remain
 The root package exports `ApprovalDecision`, `ApprovalPolicy`, `ToolReference`,
 and `ToolApprovalState`; runtime policy schemas are exported from
 `@blazingagents/sdk/contracts`.
+
+## Slack and Telegram
+
+Use the [connection example](https://github.com/blazingagents/typescript-sdk/blob/main/examples/chat-integrations.md) to connect an existing
+Agent through REST. BA hosts the Chat SDK runtime, conversation history, and
+approval cards; no additional SDK resource is required.

package/dist/client.d.ts

@@ -1,6 +1,7 @@
-import type { AgentClient, AgentsResource, ArtifactsResource, BlazingAgentsOptions, BlazingAgentsRequestOptions, ChatInput, ChatResult, CompletionInput, CompletionResult, McpConnectionsResource, MemoriesResource, ObjectInput, ObjectResult, PromptsResource, ProvidersResource, SessionsResource, TasksResource, TenantResource, UsageResource, WorkspacesResource } from "./types.ts";
+import type { AgentClient, AgentsResource, ArtifactsResource, BlazingAgentsOptions, BlazingAgentsRequestOptions, ChatConnectionsResource, ChatInput, ChatResult, CompletionInput, CompletionResult, McpConnectionsResource, MemoriesResource, ObjectInput, ObjectResult, PromptsResource, ProvidersResource, SessionsResource, TasksResource, TenantResource, UsageResource, WorkspacesResource } from "./types.ts";
 export declare class BlazingAgents {
     private readonly config;
+    readonly chatConnections: ChatConnectionsResource;
     readonly agents: AgentsResource;
     readonly sessions: SessionsResource;
     readonly providers: ProvidersResource;

package/dist/client.js

@@ -1,6 +1,7 @@
 import { chat, completion, objectGeneration } from "./generation.js";
 import { createAgentsResource } from "./resources/agents.js";
 import { createArtifactsResource } from "./resources/artifacts.js";
+import { createChatConnectionsResource } from "./resources/chat-connections.js";
 import { createMcpConnectionsResource } from "./resources/mcp-connections.js";
 import { createMemoriesResource } from "./resources/memories.js";
 import { createPromptsResource } from "./resources/prompts.js";
@@ -15,6 +16,7 @@ const DEFAULT_BASE_URL = "https://api.blazingagents.com";
 const TRAILING_SLASH_RE = /\/+$/;
 export class BlazingAgents {
     config;
+    chatConnections;
     agents;
     sessions;
     providers;
@@ -36,6 +38,7 @@ export class BlazingAgents {
                 : { clientRequestId: options.clientRequestId }),
             onResponse: options.onResponse,
         };
+        this.chatConnections = createChatConnectionsResource(this.config);
         this.agents = createAgentsResource(this.config);
         this.sessions = createSessionsResource(this.config);
         this.providers = createProvidersResource(this.config);

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/usage.d.ts

@@ -42,6 +42,15 @@ export declare const usageQuerySchema: z.ZodObject<{
     }>>;
     limit: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
+/**
+ * Query for the bounded dashboard-oriented usage overview. The date range has
+ * the same semantics as `usageQuerySchema`; `limit` bounds each ranking.
+ */
+export declare const usageOverviewQuerySchema: z.ZodObject<{
+    from: z.ZodOptional<z.ZodISODate>;
+    to: z.ZodOptional<z.ZodISODate>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
 /**
  * Usage bucket — one row per group. `sessionId` is the platform session id
  * (`ss_…`) or `null` for the `''` stateless sentinel (mapped at the read
@@ -88,8 +97,130 @@ export declare const usageResponseSchema: z.ZodObject<{
         durationMs: z.ZodNumber;
     }, z.core.$strip>;
 }, z.core.$strip>;
+/**
+ * Dashboard usage data from one bounded aggregation. `byModel` may contain
+ * one final `{ provider: null, model: null }` bucket for usage outside the
+ * top-N models.
+ */
+export declare const usageOverviewResponseSchema: z.ZodObject<{
+    totals: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        requestCount: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>;
+    daily: z.ZodArray<z.ZodObject<{
+        day: z.ZodNullable<z.ZodString>;
+        agentId: z.ZodNullable<z.ZodString>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        userId: z.ZodNullable<z.ZodString>;
+        provider: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        requestCount: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>>;
+    byAgent: z.ZodArray<z.ZodObject<{
+        day: z.ZodNullable<z.ZodString>;
+        agentId: z.ZodNullable<z.ZodString>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        userId: z.ZodNullable<z.ZodString>;
+        provider: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        requestCount: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>>;
+    byUser: z.ZodArray<z.ZodObject<{
+        day: z.ZodNullable<z.ZodString>;
+        agentId: z.ZodNullable<z.ZodString>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        userId: z.ZodNullable<z.ZodString>;
+        provider: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        requestCount: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>>;
+    byModel: z.ZodArray<z.ZodObject<{
+        day: z.ZodNullable<z.ZodString>;
+        agentId: z.ZodNullable<z.ZodString>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        userId: z.ZodNullable<z.ZodString>;
+        provider: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        requestCount: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>>;
+    activeAgentCount: z.ZodNumber;
+}, z.core.$strip>;
+/** Applies the request-dependent ranking and daily-series guarantees. */
+export declare function usageOverviewResponseSchemaForQuery(query?: Partial<UsageOverviewQuery>): z.ZodObject<{
+    totals: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        requestCount: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>;
+    daily: z.ZodArray<z.ZodObject<{
+        day: z.ZodNullable<z.ZodString>;
+        agentId: z.ZodNullable<z.ZodString>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        userId: z.ZodNullable<z.ZodString>;
+        provider: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        requestCount: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>>;
+    byAgent: z.ZodArray<z.ZodObject<{
+        day: z.ZodNullable<z.ZodString>;
+        agentId: z.ZodNullable<z.ZodString>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        userId: z.ZodNullable<z.ZodString>;
+        provider: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        requestCount: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>>;
+    byUser: z.ZodArray<z.ZodObject<{
+        day: z.ZodNullable<z.ZodString>;
+        agentId: z.ZodNullable<z.ZodString>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        userId: z.ZodNullable<z.ZodString>;
+        provider: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        requestCount: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>>;
+    byModel: z.ZodArray<z.ZodObject<{
+        day: z.ZodNullable<z.ZodString>;
+        agentId: z.ZodNullable<z.ZodString>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        userId: z.ZodNullable<z.ZodString>;
+        provider: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        requestCount: z.ZodNumber;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>>;
+    activeAgentCount: z.ZodNumber;
+}, z.core.$strip>;
 export type UsageGroupBy = z.infer<typeof usageGroupBySchema>;
 export type UsageQuery = z.infer<typeof usageQuerySchema>;
 export type UsageBucket = z.infer<typeof usageBucketSchema>;
 export type UsageTotals = z.infer<typeof usageTotalsSchema>;
 export type UsageResponse = z.infer<typeof usageResponseSchema>;
+export type UsageOverviewQuery = z.infer<typeof usageOverviewQuerySchema>;
+export type UsageOverviewResponse = z.infer<typeof usageOverviewResponseSchema>;

package/dist/contracts/entities/usage.js

@@ -1,7 +1,35 @@
 import { z } from "zod";
 import { agentIdSchema, sessionIdSchema } from "../ids.js";
-import { DEFAULT_USAGE_SESSION_TOP_N, MAX_USAGE_RANGE_DAYS, MAX_USAGE_SESSION_TOP_N, } from "../limitations.js";
+import { DEFAULT_USAGE_OVERVIEW_TOP_N, DEFAULT_USAGE_RANGE_DAYS, DEFAULT_USAGE_SESSION_TOP_N, MAX_USAGE_OVERVIEW_TOP_N, MAX_USAGE_RANGE_DAYS, MAX_USAGE_SESSION_TOP_N, } from "../limitations.js";
 import { userIdSchema } from "./attribution.js";
+function validateUsageRange(value, ctx) {
+    if ((value.from === undefined) !== (value.to === undefined)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "`from` and `to` must both be present or both be absent.",
+            path: value.from === undefined ? ["from"] : ["to"],
+        });
+    }
+    if (value.from && value.to) {
+        const fromMs = new Date(`${value.from}T00:00:00Z`).getTime();
+        const toMs = new Date(`${value.to}T00:00:00Z`).getTime();
+        const spanDays = (toMs - fromMs) / (1000 * 60 * 60 * 24);
+        if (spanDays > MAX_USAGE_RANGE_DAYS) {
+            ctx.addIssue({
+                code: "custom",
+                message: `Usage range must be at most ${MAX_USAGE_RANGE_DAYS} days.`,
+                path: ["to"],
+            });
+        }
+        if (toMs < fromMs) {
+            ctx.addIssue({
+                code: "custom",
+                message: "`to` must be after `from`.",
+                path: ["to"],
+            });
+        }
+    }
+}
 /**
  * `GET /v1/usage` groupBy — `day|agent|model|session|user`. `session` is
  * top-N by tokens; the others are exhaustive and bounded. `user` is the
@@ -46,39 +74,24 @@ export const usageQuerySchema = z
         .default(DEFAULT_USAGE_SESSION_TOP_N),
 })
     .strict()
-    .superRefine((value, ctx) => {
-    /**
-     * Require either both `from` and `to` or neither — a partial range
-     * (only one bound) is rejected so the caller doesn't silently get the
-     * default window when they meant to specify a custom range.
-     */
-    if ((value.from === undefined) !== (value.to === undefined)) {
-        ctx.addIssue({
-            code: "custom",
-            message: "`from` and `to` must both be present or both be absent.",
-            path: value.from === undefined ? ["from"] : ["to"],
-        });
-    }
-    if (value.from && value.to) {
-        const fromMs = new Date(`${value.from}T00:00:00Z`).getTime();
-        const toMs = new Date(`${value.to}T00:00:00Z`).getTime();
-        const spanDays = (toMs - fromMs) / (1000 * 60 * 60 * 24);
-        if (spanDays > MAX_USAGE_RANGE_DAYS) {
-            ctx.addIssue({
-                code: "custom",
-                message: `Usage range must be at most ${MAX_USAGE_RANGE_DAYS} days.`,
-                path: ["to"],
-            });
-        }
-        if (toMs < fromMs) {
-            ctx.addIssue({
-                code: "custom",
-                message: "`to` must be after `from`.",
-                path: ["to"],
-            });
-        }
-    }
-});
+    .superRefine(validateUsageRange);
+/**
+ * Query for the bounded dashboard-oriented usage overview. The date range has
+ * the same semantics as `usageQuerySchema`; `limit` bounds each ranking.
+ */
+export const usageOverviewQuerySchema = z
+    .object({
+    from: z.iso.date().optional(),
+    to: z.iso.date().optional(),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(MAX_USAGE_OVERVIEW_TOP_N)
+        .default(DEFAULT_USAGE_OVERVIEW_TOP_N),
+})
+    .strict()
+    .superRefine(validateUsageRange);
 /**
  * Usage bucket — one row per group. `sessionId` is the platform session id
  * (`ss_…`) or `null` for the `''` stateless sentinel (mapped at the read
@@ -115,3 +128,73 @@ export const usageResponseSchema = z
     totals: usageTotalsSchema,
 })
     .strip();
+/**
+ * Dashboard usage data from one bounded aggregation. `byModel` may contain
+ * one final `{ provider: null, model: null }` bucket for usage outside the
+ * top-N models.
+ */
+export const usageOverviewResponseSchema = z
+    .object({
+    totals: usageTotalsSchema,
+    daily: z.array(usageBucketSchema).max(MAX_USAGE_RANGE_DAYS + 1),
+    byAgent: z.array(usageBucketSchema).max(MAX_USAGE_OVERVIEW_TOP_N),
+    byUser: z.array(usageBucketSchema).max(MAX_USAGE_OVERVIEW_TOP_N),
+    byModel: z.array(usageBucketSchema).max(MAX_USAGE_OVERVIEW_TOP_N + 1),
+    activeAgentCount: z.number().int().nonnegative(),
+})
+    .strip()
+    .superRefine((value, ctx) => {
+    const remainderCount = value.byModel.filter(({ model, provider }) => model === null && provider === null).length;
+    const normalCount = value.byModel.length - remainderCount;
+    const hasIncompleteModel = value.byModel.some(({ model, provider }) => (model === null) !== (provider === null));
+    if (remainderCount > 1 ||
+        normalCount > MAX_USAGE_OVERVIEW_TOP_N ||
+        hasIncompleteModel) {
+        ctx.addIssue({
+            code: "custom",
+            message: "Model usage must contain at most 20 models and one remainder.",
+            path: ["byModel"],
+        });
+    }
+});
+/** Applies the request-dependent ranking and daily-series guarantees. */
+export function usageOverviewResponseSchemaForQuery(query = {}) {
+    const limit = query.limit ?? DEFAULT_USAGE_OVERVIEW_TOP_N;
+    const expectedDays = query.from && query.to
+        ? (new Date(`${query.to}T00:00:00Z`).getTime() -
+            new Date(`${query.from}T00:00:00Z`).getTime()) /
+            (1000 * 60 * 60 * 24) +
+            1
+        : DEFAULT_USAGE_RANGE_DAYS;
+    return usageOverviewResponseSchema.superRefine((value, ctx) => {
+        const normalModelCount = value.byModel.filter(({ model, provider }) => model !== null || provider !== null).length;
+        if (value.byAgent.length > limit ||
+            value.byUser.length > limit ||
+            normalModelCount > limit) {
+            ctx.addIssue({
+                code: "custom",
+                message: "Usage rankings exceed the requested limit.",
+                path: ["byAgent"],
+            });
+        }
+        const days = value.daily.map(({ day }) => day);
+        const firstDay = query.from ?? days[0];
+        const completeDailyRange = days.length === expectedDays &&
+            firstDay !== null &&
+            firstDay !== undefined &&
+            days.every((day, index) => {
+                const expected = new Date(new Date(`${firstDay}T00:00:00Z`).getTime() +
+                    index * 24 * 60 * 60 * 1000)
+                    .toISOString()
+                    .slice(0, 10);
+                return day === expected;
+            });
+        if (!completeDailyRange) {
+            ctx.addIssue({
+                code: "custom",
+                message: "Daily usage must cover the complete selected range.",
+                path: ["daily"],
+            });
+        }
+    });
+}

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

@@ -7,6 +7,7 @@ export { artifactDownloadUrlResponseSchema, artifactListItemSchema, artifactsLis
 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";
@@ -16,6 +17,7 @@ export { decideToolApprovalBodySchema, latestSessionListItemSchema, latestSessio
 export { copySkillBodySchema, createSkillBodySchema, skillCopyResultsSchema, skillDetailSchema, skillsListResponseSchema, } from "./entities/skills.ts";
 export { createTaskBodySchema, createTaskResponseSchema, createTaskRunBodySchema, createTaskRunResponseSchema, taskListItemSchema, taskResponseSchema, taskRunMessagesResponseSchema, taskRunResponseSchema, taskRunSchema, taskRunStatusSchema, taskRunsListResponseSchema, taskScheduleKindSchema, taskSchema, tasksListResponseSchema, updateTaskBodySchema, } from "./entities/tasks.ts";
 export { quotaSchema, subscriptionStatusSchema, tenantResponseSchema, tenantSchema, tenantSettingsResponseSchema, updateTenantSettingsBodySchema, } from "./entities/tenants.ts";
-export { usageResponseSchema } from "./entities/usage.ts";
+export type { UsageBucket, UsageOverviewQuery, UsageOverviewResponse, UsageResponse, UsageTotals, } from "./entities/usage.ts";
+export { usageOverviewQuerySchema, usageOverviewResponseSchema, usageResponseSchema, } from "./entities/usage.ts";
 export { createWorkspaceBodySchema, updateWorkspaceBodySchema, workspaceSchema, workspacesListResponseSchema, } from "./entities/workspaces.ts";
 export { agentIdSchema, apiKeyTokenSchema, isAdminAgentId, promptIdSchema, sessionIdSchema, } from "./ids.ts";

package/dist/contracts/index.js

@@ -6,6 +6,7 @@ export { agentResponseSchema, agentSchema, agentStatusSchema, agentsResponseSche
 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";
@@ -14,6 +15,6 @@ export { decideToolApprovalBodySchema, latestSessionListItemSchema, latestSessio
 export { copySkillBodySchema, createSkillBodySchema, skillCopyResultsSchema, skillDetailSchema, skillsListResponseSchema, } from "./entities/skills.js";
 export { createTaskBodySchema, createTaskResponseSchema, createTaskRunBodySchema, createTaskRunResponseSchema, taskListItemSchema, taskResponseSchema, taskRunMessagesResponseSchema, taskRunResponseSchema, taskRunSchema, taskRunStatusSchema, taskRunsListResponseSchema, taskScheduleKindSchema, taskSchema, tasksListResponseSchema, updateTaskBodySchema, } from "./entities/tasks.js";
 export { quotaSchema, subscriptionStatusSchema, tenantResponseSchema, tenantSchema, tenantSettingsResponseSchema, updateTenantSettingsBodySchema, } from "./entities/tenants.js";
-export { usageResponseSchema } from "./entities/usage.js";
+export { usageOverviewQuerySchema, usageOverviewResponseSchema, usageResponseSchema, } from "./entities/usage.js";
 export { createWorkspaceBodySchema, updateWorkspaceBodySchema, workspaceSchema, workspacesListResponseSchema, } from "./entities/workspaces.js";
 export { agentIdSchema, apiKeyTokenSchema, isAdminAgentId, promptIdSchema, sessionIdSchema, } from "./ids.js";

package/dist/contracts/limitations.d.ts

@@ -122,6 +122,8 @@ export declare const MAX_USAGE_RANGE_DAYS = 31;
 export declare const DEFAULT_USAGE_RANGE_DAYS = 30;
 export declare const DEFAULT_USAGE_SESSION_TOP_N = 50;
 export declare const MAX_USAGE_SESSION_TOP_N = 200;
+export declare const DEFAULT_USAGE_OVERVIEW_TOP_N = 5;
+export declare const MAX_USAGE_OVERVIEW_TOP_N = 20;
 export declare const MIN_QUOTA_RESET_DAY = 1;
 export declare const MAX_QUOTA_RESET_DAY = 28;
 /**

package/dist/contracts/limitations.js

@@ -123,6 +123,8 @@ export const MAX_USAGE_RANGE_DAYS = 31;
 export const DEFAULT_USAGE_RANGE_DAYS = 30;
 export const DEFAULT_USAGE_SESSION_TOP_N = 50;
 export const MAX_USAGE_SESSION_TOP_N = 200;
+export const DEFAULT_USAGE_OVERVIEW_TOP_N = 5;
+export const MAX_USAGE_OVERVIEW_TOP_N = 20;
 // Quota — reset day between 1 and 28.
 export const MIN_QUOTA_RESET_DAY = 1;
 export const MAX_QUOTA_RESET_DAY = 28;

package/dist/index.d.ts

@@ -12,12 +12,14 @@ 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 { UsageBucket, UsageOverviewQuery, UsageOverviewResponse, UsageTotals, } from "./contracts/entities/usage.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/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/resources/sessions.js

@@ -35,6 +35,9 @@ export function createSessionsResource(config) {
                     limit: options.limit,
                     // Stryker disable next-line ConditionalExpression: URL serialization omits an undefined query value.
                     ...(options.userId === undefined ? {} : { userId: options.userId }),
+                    ...(options.byAgent === undefined
+                        ? {}
+                        : { byAgent: options.byAgent }),
                 },
             }, latestSessionsListResponseSchema);
         },

package/dist/resources/usage.js

@@ -1,4 +1,4 @@
-import { usageResponseSchema } from "../contracts/entities/usage.js";
+import { usageOverviewResponseSchemaForQuery, usageResponseSchema, } from "../contracts/entities/usage.js";
 import { requestJson } from "../http.js";
 /**
  * `client.usage` — get over `/v1/usage` (tenant-wide) and
@@ -16,5 +16,8 @@ export function createUsageResource(config) {
         async getForAgent({ agentId, abortSignal, ...query }) {
             return await requestJson(config, `/v1/agents/${agentId}/usage`, { query, signal: abortSignal }, usageResponseSchema);
         },
+        async overview({ abortSignal, ...query } = {}) {
+            return await requestJson(config, "/v1/usage/overview", { query, signal: abortSignal }, usageOverviewResponseSchemaForQuery(query));
+        },
     };
 }

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";
@@ -11,7 +12,7 @@ import type { DecideToolApprovalBody, LatestSessionsListResponse, SessionMessage
 import type { CreateSkillBody, SkillArchiveType, SkillCopyResults, SkillDetail, SkillsListResponse } from "./contracts/entities/skills.ts";
 import type { CreateTaskBody, CreateTaskResponse, CreateTaskRunBody, CreateTaskRunResponse, TaskResponse, TaskRunMessagesResponse, TaskRunResponse, TaskRunsListResponse, TasksListResponse, UpdateTaskBody } from "./contracts/entities/tasks.ts";
 import type { TenantSettingsResponse, UpdateTenantSettingsBody } from "./contracts/entities/tenants.ts";
-import type { UsageQuery, UsageResponse } from "./contracts/entities/usage.ts";
+import type { UsageOverviewQuery, UsageOverviewResponse, UsageQuery, UsageResponse } from "./contracts/entities/usage.ts";
 import type { CreateWorkspaceBody, UpdateWorkspaceBody, Workspace, WorkspacesListResponse } from "./contracts/entities/workspaces.ts";
 export type KnownBlazingAgentsErrorCode = ApiErrorCode | "invalid_response" | "network_error" | "request_aborted" | "stream_error";
 export type BlazingAgentsErrorCode = KnownBlazingAgentsErrorCode | (string & {});
@@ -373,6 +374,7 @@ export interface SessionsListOptions extends ResourceRequestOptions {
     userId?: string;
 }
 export interface LatestSessionsListOptions extends ResourceRequestOptions {
+    byAgent?: boolean;
     cursor?: string;
     limit?: number;
     userId?: string;
@@ -402,9 +404,9 @@ export interface SessionsResource {
         agentId: string;
     } & SessionsListOptions): Promise<SessionsListResponse>;
     /**
-     * `GET /v1/sessions/latest` — each Agent's most recently updated Session
-     * across the Tenant, one item per Agent, newest first. `userId` narrows
-     * the candidate Sessions to one end user's before picking the latest.
+     * `GET /v1/sessions/latest` — the Tenant's most recently updated Sessions,
+     * newest first. Set `byAgent` to return at most one Session per Agent.
+     * `userId` narrows the candidate Sessions to one end user's.
      */
     listLatest(input?: LatestSessionsListOptions): Promise<LatestSessionsListResponse>;
     messages(input: {
@@ -510,5 +512,32 @@ export interface UsageResource {
     getForAgent(input: Partial<UsageQuery> & {
         agentId: string;
     } & ResourceRequestOptions): Promise<UsageResponse>;
+    /** Returns totals, daily usage, and bounded Agent, user, and model rankings. */
+    overview(input?: Partial<UsageOverviewQuery> & ResourceRequestOptions): Promise<UsageOverviewResponse>;
+}
+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.8.0",
+  "version": "0.9.1",
   "description": "TypeScript SDK for the Blazing Agents API",
   "homepage": "https://docs.blazingagents.com",
   "bugs": {