@blazingagents/sdk 0.1.0

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

@@ -0,0 +1,183 @@
+import { z } from "zod";
+export declare const agentInstructionsSchema: z.ZodString;
+/** Provider-native model id, passed through without interpretation. */
+export declare const agentModelIdSchema: z.ZodString;
+export declare const agentToolsSchema: z.ZodArray<z.ZodEnum<{
+    memory: "memory";
+    workspace: "workspace";
+    write_todos: "write_todos";
+}>>;
+export declare const agentMcpConnectionIdsSchema: z.ZodArray<z.ZodString>;
+export declare const agentVersionNumberSchema: z.ZodNumber;
+export declare const agentStatusSchema: z.ZodEnum<{
+    active: "active";
+    disabled: "disabled";
+}>;
+export declare const agentSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    name: z.ZodString;
+    model: z.ZodNullable<z.ZodString>;
+    providerId: z.ZodNullable<z.ZodString>;
+    workspaceId: z.ZodString;
+    memoryInjectionEnabled: z.ZodBoolean;
+    tools: z.ZodArray<z.ZodEnum<{
+        memory: "memory";
+        workspace: "workspace";
+        write_todos: "write_todos";
+    }>>;
+    instructions: z.ZodString;
+    userId: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    mcpConnectionIds: z.ZodArray<z.ZodString>;
+    avatarUrl: z.ZodNullable<z.ZodURL>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    version: z.ZodNumber;
+    status: z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+    }>;
+}, z.core.$strict>;
+export declare const agentsResponseSchema: z.ZodObject<{
+    agents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tenantId: z.ZodString;
+        name: z.ZodString;
+        model: z.ZodNullable<z.ZodString>;
+        providerId: z.ZodNullable<z.ZodString>;
+        workspaceId: z.ZodString;
+        memoryInjectionEnabled: z.ZodBoolean;
+        tools: z.ZodArray<z.ZodEnum<{
+            memory: "memory";
+            workspace: "workspace";
+            write_todos: "write_todos";
+        }>>;
+        instructions: z.ZodString;
+        userId: z.ZodString;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        mcpConnectionIds: z.ZodArray<z.ZodString>;
+        avatarUrl: z.ZodNullable<z.ZodURL>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        version: z.ZodNumber;
+        status: z.ZodEnum<{
+            active: "active";
+            disabled: "disabled";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const agentResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    name: z.ZodString;
+    model: z.ZodNullable<z.ZodString>;
+    providerId: z.ZodNullable<z.ZodString>;
+    workspaceId: z.ZodString;
+    memoryInjectionEnabled: z.ZodBoolean;
+    tools: z.ZodArray<z.ZodEnum<{
+        memory: "memory";
+        workspace: "workspace";
+        write_todos: "write_todos";
+    }>>;
+    instructions: z.ZodString;
+    userId: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    mcpConnectionIds: z.ZodArray<z.ZodString>;
+    avatarUrl: z.ZodNullable<z.ZodURL>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    version: z.ZodNumber;
+    status: z.ZodEnum<{
+        active: "active";
+        disabled: "disabled";
+    }>;
+}, z.core.$strict>;
+export declare const agentsListQuerySchema: z.ZodObject<{
+    userId: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const agentVersionSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    tenantId: z.ZodString;
+    version: z.ZodNumber;
+    name: z.ZodString;
+    model: z.ZodNullable<z.ZodString>;
+    providerId: z.ZodNullable<z.ZodString>;
+    memoryInjectionEnabled: z.ZodBoolean;
+    tools: z.ZodArray<z.ZodEnum<{
+        memory: "memory";
+        workspace: "workspace";
+        write_todos: "write_todos";
+    }>>;
+    instructions: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    mcpConnectionIds: z.ZodArray<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const agentVersionsListQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strict>;
+export declare const agentVersionsResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        tenantId: z.ZodString;
+        version: z.ZodNumber;
+        name: z.ZodString;
+        model: z.ZodNullable<z.ZodString>;
+        providerId: z.ZodNullable<z.ZodString>;
+        memoryInjectionEnabled: z.ZodBoolean;
+        tools: z.ZodArray<z.ZodEnum<{
+            memory: "memory";
+            workspace: "workspace";
+            write_todos: "write_todos";
+        }>>;
+        instructions: z.ZodString;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        mcpConnectionIds: z.ZodArray<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const createAgentBodySchema: z.ZodObject<{
+    name: z.ZodString;
+    model: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    providerId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    memoryInjectionEnabled: z.ZodDefault<z.ZodBoolean>;
+    tools: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        memory: "memory";
+        workspace: "workspace";
+        write_todos: "write_todos";
+    }>>>;
+    instructions: z.ZodDefault<z.ZodString>;
+    userId: z.ZodDefault<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    mcpConnectionIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const updateAgentBodySchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    providerId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    memoryInjectionEnabled: z.ZodOptional<z.ZodBoolean>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        memory: "memory";
+        workspace: "workspace";
+        write_todos: "write_todos";
+    }>>>;
+    instructions: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    mcpConnectionIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type Agent = z.infer<typeof agentSchema>;
+export type AgentsResponse = z.infer<typeof agentsResponseSchema>;
+export type AgentResponse = z.infer<typeof agentResponseSchema>;
+export type AgentsListQuery = z.infer<typeof agentsListQuerySchema>;
+export type AgentVersion = z.infer<typeof agentVersionSchema>;
+export type AgentStatus = z.infer<typeof agentStatusSchema>;
+export type AgentVersionsListQuery = z.infer<typeof agentVersionsListQuerySchema>;
+export type AgentVersionsResponse = z.infer<typeof agentVersionsResponseSchema>;
+export type CreateAgentBody = z.input<typeof createAgentBodySchema>;
+export type UpdateAgentBody = z.infer<typeof updateAgentBodySchema>;

package/dist/contracts/entities/agents.js

@@ -0,0 +1,153 @@
+import { z } from "zod";
+import { cursorSchema, paginatedResponseSchema } from "../api.js";
+import { agentIdSchema, mcpConnectionIdSchema, providerIdSchema, tenantIdSchema, workspaceIdSchema, } from "../ids.js";
+import { DEFAULT_AGENT_VERSIONS_LIST_LIMIT, MAX_AGENT_INSTRUCTIONS_LENGTH, MAX_AGENT_NAME_LENGTH, MAX_AGENT_VERSIONS_LIST_LIMIT, MAX_MCP_CONNECTIONS_PER_AGENT, } from "../limitations.js";
+import { atLeastOneFieldMessage, hasObjectKeys, hasUniqueValues, } from "../utils.js";
+import { agentToolGroupIds } from "./agent-tools.js";
+import { metadataSchema, userIdSchema } from "./attribution.js";
+const agentNameSchema = z.string().trim().min(1).max(MAX_AGENT_NAME_LENGTH);
+export const agentInstructionsSchema = z
+    .string()
+    .max(MAX_AGENT_INSTRUCTIONS_LENGTH);
+/** Provider-native model id, passed through without interpretation. */
+export const agentModelIdSchema = z.string().trim().min(1);
+export const agentToolsSchema = z
+    .array(z.enum(agentToolGroupIds))
+    .refine(hasUniqueValues, {
+    message: "Tool group ids must be unique.",
+});
+export const agentMcpConnectionIdsSchema = z
+    .array(mcpConnectionIdSchema)
+    .max(MAX_MCP_CONNECTIONS_PER_AGENT)
+    .refine(hasUniqueValues, {
+    message: "MCP connection ids must be unique.",
+});
+export const agentVersionNumberSchema = z
+    .number()
+    .int()
+    .min(1)
+    .max(2_147_483_647);
+export const agentStatusSchema = z.enum(["active", "disabled"]);
+const providerModelPairMessage = "Provider and model must either both be set or both be null.";
+function hasProviderModelPair(input) {
+    return (input.model === null) === (input.providerId === null);
+}
+export const agentSchema = z
+    .object({
+    id: agentIdSchema,
+    tenantId: tenantIdSchema,
+    name: agentNameSchema,
+    model: agentModelIdSchema.nullable(),
+    providerId: providerIdSchema.nullable(),
+    workspaceId: workspaceIdSchema,
+    memoryInjectionEnabled: z.boolean(),
+    tools: agentToolsSchema,
+    instructions: agentInstructionsSchema,
+    userId: userIdSchema,
+    metadata: metadataSchema,
+    mcpConnectionIds: agentMcpConnectionIdsSchema,
+    /** A short-lived signed URL for the private, platform-owned avatar. */
+    avatarUrl: z.url().nullable(),
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+    version: agentVersionNumberSchema,
+    status: agentStatusSchema,
+})
+    .strict()
+    .refine(hasProviderModelPair, {
+    message: providerModelPairMessage,
+    path: ["providerId"],
+});
+export const agentsResponseSchema = z
+    .object({
+    agents: z.array(agentSchema),
+})
+    .strict();
+export const agentResponseSchema = agentSchema;
+export const agentsListQuerySchema = z
+    .object({
+    userId: userIdSchema.optional(),
+    workspaceId: workspaceIdSchema.optional(),
+})
+    .strict();
+export const agentVersionSchema = z
+    .object({
+    agentId: agentIdSchema,
+    tenantId: tenantIdSchema,
+    version: agentVersionNumberSchema,
+    name: agentSchema.shape.name,
+    model: agentSchema.shape.model,
+    providerId: agentSchema.shape.providerId,
+    memoryInjectionEnabled: agentSchema.shape.memoryInjectionEnabled,
+    tools: agentSchema.shape.tools,
+    instructions: agentSchema.shape.instructions,
+    metadata: agentSchema.shape.metadata,
+    mcpConnectionIds: agentSchema.shape.mcpConnectionIds,
+    createdAt: agentSchema.shape.createdAt,
+})
+    .strict()
+    .refine(hasProviderModelPair, {
+    message: providerModelPairMessage,
+    path: ["providerId"],
+});
+export const agentVersionsListQuerySchema = z
+    .object({
+    cursor: cursorSchema.optional(),
+    limit: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(MAX_AGENT_VERSIONS_LIST_LIMIT)
+        .default(DEFAULT_AGENT_VERSIONS_LIST_LIMIT),
+})
+    .strict();
+export const agentVersionsResponseSchema = paginatedResponseSchema(agentVersionSchema);
+export const createAgentBodySchema = z
+    .object({
+    name: agentNameSchema,
+    model: agentModelIdSchema.nullable().default(null),
+    providerId: providerIdSchema.nullable().default(null),
+    workspaceId: workspaceIdSchema.optional(),
+    memoryInjectionEnabled: z.boolean().default(false),
+    tools: agentToolsSchema.default([]),
+    instructions: agentInstructionsSchema.default(""),
+    userId: userIdSchema.default(""),
+    metadata: metadataSchema.default({}),
+    mcpConnectionIds: agentMcpConnectionIdsSchema.default([]),
+})
+    .strict()
+    .refine(hasProviderModelPair, {
+    message: providerModelPairMessage,
+    path: ["providerId"],
+});
+export const updateAgentBodySchema = z
+    .object({
+    name: agentNameSchema.optional(),
+    model: agentModelIdSchema.nullable().optional(),
+    providerId: providerIdSchema.nullable().optional(),
+    workspaceId: workspaceIdSchema.optional(),
+    memoryInjectionEnabled: z.boolean().optional(),
+    tools: agentToolsSchema.optional(),
+    instructions: agentInstructionsSchema.optional(),
+    metadata: metadataSchema.optional(),
+    mcpConnectionIds: agentMcpConnectionIdsSchema.optional(),
+})
+    .strict()
+    .refine(hasObjectKeys, {
+    message: atLeastOneFieldMessage,
+})
+    .refine((input) => {
+    if (input.model === undefined && input.providerId === undefined) {
+        return true;
+    }
+    if (input.providerId === undefined) {
+        return input.model !== null;
+    }
+    if (input.model === undefined) {
+        return false;
+    }
+    return (input.model === null) === (input.providerId === null);
+}, {
+    message: providerModelPairMessage,
+    path: ["providerId"],
+});

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

@@ -0,0 +1,71 @@
+import { z } from "zod";
+export declare const artifactFilenameSchema: z.ZodString;
+/**
+ * Public metadata returned by Tenant-level Artifact resources.
+ */
+export declare const artifactListItemSchema: z.ZodObject<{
+    artifactId: z.ZodString;
+    agentId: z.ZodString;
+    tenantId: z.ZodString;
+    sessionId: z.ZodString;
+    filename: z.ZodString;
+    mediaType: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    userId: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const artifactsListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        artifactId: z.ZodString;
+        agentId: z.ZodString;
+        tenantId: z.ZodString;
+        sessionId: z.ZodString;
+        filename: z.ZodString;
+        mediaType: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        userId: z.ZodString;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const artifactsListQuerySchema: z.ZodObject<{
+    agentId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export declare const publishArtifactsInputSchema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const publishArtifactResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    artifactId: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodLiteral<true>;
+    message: z.ZodString;
+    path: z.ZodString;
+}, z.core.$strict>]>;
+export declare const publishArtifactsOutputSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        artifactId: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        error: z.ZodLiteral<true>;
+        message: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export declare const artifactDownloadUrlResponseSchema: z.ZodObject<{
+    url: z.ZodURL;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type ArtifactListItem = z.infer<typeof artifactListItemSchema>;
+export type ArtifactsListResponse = z.infer<typeof artifactsListResponseSchema>;
+export type ArtifactsListQuery = z.infer<typeof artifactsListQuerySchema>;
+export type PublishArtifactsInput = z.infer<typeof publishArtifactsInputSchema>;
+export type PublishArtifactResult = z.infer<typeof publishArtifactResultSchema>;
+export type PublishArtifactsOutput = z.infer<typeof publishArtifactsOutputSchema>;
+export type ArtifactDownloadUrlResponse = z.infer<typeof artifactDownloadUrlResponseSchema>;

package/dist/contracts/entities/artifacts.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import { paginatedResponseSchema } from "../api.js";
+import { agentIdSchema, artifactIdSchema, sessionIdSchema, tenantIdSchema, } from "../ids.js";
+import { MAX_ARTIFACT_BYTES, MAX_ARTIFACT_PUBLICATIONS_PER_CALL, } from "../limitations.js";
+import { metadataSchema, userIdSchema } from "./attribution.js";
+export const artifactFilenameSchema = z
+    .string()
+    .min(1)
+    .refine((filename) => filename.trim().length > 0)
+    .refine((filename) => filename !== "." && filename !== "..")
+    .refine((filename) => !(filename.includes("/") || filename.includes("\\")));
+/**
+ * Public metadata returned by Tenant-level Artifact resources.
+ */
+export const artifactListItemSchema = z
+    .object({
+    artifactId: artifactIdSchema,
+    agentId: agentIdSchema,
+    tenantId: tenantIdSchema,
+    sessionId: sessionIdSchema,
+    filename: artifactFilenameSchema,
+    mediaType: z.string().trim().min(1),
+    sizeBytes: z.number().int().nonnegative().max(MAX_ARTIFACT_BYTES),
+    userId: userIdSchema,
+    metadata: metadataSchema,
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+})
+    .strict();
+export const artifactsListResponseSchema = paginatedResponseSchema(artifactListItemSchema);
+export const artifactsListQuerySchema = z
+    .object({
+    agentId: agentIdSchema.optional(),
+    sessionId: sessionIdSchema.optional(),
+    cursor: z.string().nullable().optional(),
+})
+    .strict();
+export const publishArtifactsInputSchema = z
+    .object({
+    paths: z
+        .array(z.string().trim().min(1))
+        .min(1)
+        .max(MAX_ARTIFACT_PUBLICATIONS_PER_CALL),
+})
+    .strict();
+export const publishArtifactResultSchema = z.union([
+    z
+        .object({
+        artifactId: artifactIdSchema,
+        path: z.string().trim().min(1),
+    })
+        .strict(),
+    z
+        .object({
+        error: z.literal(true),
+        message: z.string().trim().min(1),
+        path: z.string().trim().min(1),
+    })
+        .strict(),
+]);
+export const publishArtifactsOutputSchema = z
+    .object({
+    results: z.array(publishArtifactResultSchema).min(1),
+})
+    .strict();
+export const artifactDownloadUrlResponseSchema = z
+    .object({
+    url: z.url(),
+    expiresAt: z.iso.datetime({ offset: true }),
+})
+    .strict();

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

@@ -0,0 +1,27 @@
+import { z } from "zod";
+/**
+ * End-user attribution — the uniform ownership dimension on every
+ * tenant-owned product resource (ADR-0001). `userId` is an opaque
+ * tenant-chosen string (`''` = tenant-level, immutable after creation);
+ * `metadata` is a mutable jsonb object. Neither is ever on tenant config
+ * (apikeys, providers, quotas).
+ *
+ * These are the shared zod primitives every attributed entity reuses so the
+ * two fields stay shape-identical across agents, Workspaces, prompts,
+ * sessions, tasks, task runs, artifacts, and usage rows.
+ */
+export declare const userIdSchema: z.ZodString;
+export declare const metadataSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+/**
+ * The create-body shape for an attributed resource: both fields optional
+ * with tenant-level defaults (`userId: ''`, `metadata: {}`). `userId` is
+ * set at creation and immutable — update bodies accept `metadata` only
+ * (they do not include `userId`, so a `userId` in a PUT body is rejected
+ * by the update body's `.strict()`).
+ */
+export declare const attributionCreateInputSchema: z.ZodObject<{
+    userId: z.ZodDefault<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type UserId = z.infer<typeof userIdSchema>;
+export type Metadata = z.infer<typeof metadataSchema>;

package/dist/contracts/entities/attribution.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+/**
+ * End-user attribution — the uniform ownership dimension on every
+ * tenant-owned product resource (ADR-0001). `userId` is an opaque
+ * tenant-chosen string (`''` = tenant-level, immutable after creation);
+ * `metadata` is a mutable jsonb object. Neither is ever on tenant config
+ * (apikeys, providers, quotas).
+ *
+ * These are the shared zod primitives every attributed entity reuses so the
+ * two fields stay shape-identical across agents, Workspaces, prompts,
+ * sessions, tasks, task runs, artifacts, and usage rows.
+ */
+export const userIdSchema = z.string();
+export const metadataSchema = z.record(z.string(), z.unknown());
+/**
+ * The create-body shape for an attributed resource: both fields optional
+ * with tenant-level defaults (`userId: ''`, `metadata: {}`). `userId` is
+ * set at creation and immutable — update bodies accept `metadata` only
+ * (they do not include `userId`, so a `userId` in a PUT body is rejected
+ * by the update body's `.strict()`).
+ */
+export const attributionCreateInputSchema = z
+    .object({
+    userId: userIdSchema.default(""),
+    metadata: metadataSchema.default({}),
+})
+    .strict();