@blazingagents/sdk 0.16.0 → 0.18.0

package/dist/contracts/entities/session-inputs.d.ts

@@ -0,0 +1,235 @@
+import { z } from "zod";
+export declare const sessionInputStateSchema: z.ZodEnum<{
+    accepted: "accepted";
+    cancelled: "cancelled";
+    committed: "committed";
+    consumed: "consumed";
+    delivered: "delivered";
+    uncertain: "uncertain";
+}>;
+export declare const sessionInputModeSchema: z.ZodEnum<{
+    queue: "queue";
+    steer: "steer";
+}>;
+export declare const sessionInputRequestIdSchema: z.ZodString;
+export declare const sessionInputSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    sequence: z.ZodNumber;
+    message: z.ZodObject<{
+        id: z.ZodString;
+        parts: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodUnknown>;
+        role: z.ZodLiteral<"user">;
+    }, z.core.$loose>;
+    mode: z.ZodEnum<{
+        queue: "queue";
+        steer: "steer";
+    }>;
+    state: z.ZodEnum<{
+        accepted: "accepted";
+        cancelled: "cancelled";
+        committed: "committed";
+        consumed: "consumed";
+        delivered: "delivered";
+        uncertain: "uncertain";
+    }>;
+    turnId: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    consumedAt: z.ZodNullable<z.ZodISODateTime>;
+    reason: z.ZodNullable<z.ZodEnum<{
+        deleted: "deleted";
+        failed: "failed";
+        owner_lost: "owner_lost";
+        stopped: "stopped";
+    }>>;
+}, z.core.$strip>;
+export declare const sessionActivitySchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        approval: "approval";
+        idle: "idle";
+        paused: "paused";
+        running: "running";
+        stopping: "stopping";
+    }>;
+    turnId: z.ZodNullable<z.ZodString>;
+    reason: z.ZodNullable<z.ZodEnum<{
+        failed: "failed";
+        function_executor_required: "function_executor_required";
+        owner_lost: "owner_lost";
+    }>>;
+}, z.core.$strip>;
+export declare const sessionInputResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        requestId: z.ZodString;
+        sequence: z.ZodNumber;
+        message: z.ZodObject<{
+            id: z.ZodString;
+            parts: z.ZodArray<z.ZodObject<{
+                type: z.ZodString;
+            }, z.core.$loose>>;
+            metadata: z.ZodOptional<z.ZodUnknown>;
+            role: z.ZodLiteral<"user">;
+        }, z.core.$loose>;
+        mode: z.ZodEnum<{
+            queue: "queue";
+            steer: "steer";
+        }>;
+        state: z.ZodEnum<{
+            accepted: "accepted";
+            cancelled: "cancelled";
+            committed: "committed";
+            consumed: "consumed";
+            delivered: "delivered";
+            uncertain: "uncertain";
+        }>;
+        turnId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        consumedAt: z.ZodNullable<z.ZodISODateTime>;
+        reason: z.ZodNullable<z.ZodEnum<{
+            deleted: "deleted";
+            failed: "failed";
+            owner_lost: "owner_lost";
+            stopped: "stopped";
+        }>>;
+    }, z.core.$strip>;
+    activity: z.ZodObject<{
+        state: z.ZodEnum<{
+            approval: "approval";
+            idle: "idle";
+            paused: "paused";
+            running: "running";
+            stopping: "stopping";
+        }>;
+        turnId: z.ZodNullable<z.ZodString>;
+        reason: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            function_executor_required: "function_executor_required";
+            owner_lost: "owner_lost";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const sessionInputsResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        requestId: z.ZodString;
+        sequence: z.ZodNumber;
+        message: z.ZodObject<{
+            id: z.ZodString;
+            parts: z.ZodArray<z.ZodObject<{
+                type: z.ZodString;
+            }, z.core.$loose>>;
+            metadata: z.ZodOptional<z.ZodUnknown>;
+            role: z.ZodLiteral<"user">;
+        }, z.core.$loose>;
+        mode: z.ZodEnum<{
+            queue: "queue";
+            steer: "steer";
+        }>;
+        state: z.ZodEnum<{
+            accepted: "accepted";
+            cancelled: "cancelled";
+            committed: "committed";
+            consumed: "consumed";
+            delivered: "delivered";
+            uncertain: "uncertain";
+        }>;
+        turnId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        consumedAt: z.ZodNullable<z.ZodISODateTime>;
+        reason: z.ZodNullable<z.ZodEnum<{
+            deleted: "deleted";
+            failed: "failed";
+            owner_lost: "owner_lost";
+            stopped: "stopped";
+        }>>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    activity: z.ZodObject<{
+        state: z.ZodEnum<{
+            approval: "approval";
+            idle: "idle";
+            paused: "paused";
+            running: "running";
+            stopping: "stopping";
+        }>;
+        turnId: z.ZodNullable<z.ZodString>;
+        reason: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            function_executor_required: "function_executor_required";
+            owner_lost: "owner_lost";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const submitSessionInputBodySchema: z.ZodObject<{
+    requestId: z.ZodString;
+    message: z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>;
+    whenBusy: z.ZodDefault<z.ZodEnum<{
+        queue: "queue";
+        steer: "steer";
+    }>>;
+}, z.core.$strict>;
+export declare const sessionInputsQuerySchema: z.ZodObject<{
+    includeCompleted: z.ZodDefault<z.ZodBoolean>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const stopSessionBodySchema: z.ZodObject<{
+    turnId: z.ZodString;
+}, z.core.$strict>;
+export declare const stopSessionResponseSchema: z.ZodObject<{
+    stoppedTurnId: z.ZodString;
+    activity: z.ZodObject<{
+        state: z.ZodEnum<{
+            approval: "approval";
+            idle: "idle";
+            paused: "paused";
+            running: "running";
+            stopping: "stopping";
+        }>;
+        turnId: z.ZodNullable<z.ZodString>;
+        reason: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            function_executor_required: "function_executor_required";
+            owner_lost: "owner_lost";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const resumeSessionInputsResponseSchema: z.ZodObject<{
+    activity: z.ZodObject<{
+        state: z.ZodEnum<{
+            approval: "approval";
+            idle: "idle";
+            paused: "paused";
+            running: "running";
+            stopping: "stopping";
+        }>;
+        turnId: z.ZodNullable<z.ZodString>;
+        reason: z.ZodNullable<z.ZodEnum<{
+            failed: "failed";
+            function_executor_required: "function_executor_required";
+            owner_lost: "owner_lost";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SessionInputState = z.infer<typeof sessionInputStateSchema>;
+export type SessionInputMode = z.infer<typeof sessionInputModeSchema>;
+export type SessionInput = z.infer<typeof sessionInputSchema>;
+export type SessionActivity = z.infer<typeof sessionActivitySchema>;
+export type SessionInputResponse = z.infer<typeof sessionInputResponseSchema>;
+export type SessionInputsResponse = z.infer<typeof sessionInputsResponseSchema>;
+export type SubmitSessionInputBody = z.input<typeof submitSessionInputBodySchema>;
+export type SessionInputsQuery = z.input<typeof sessionInputsQuerySchema>;
+export type StopSessionBody = z.infer<typeof stopSessionBodySchema>;
+export type StopSessionResponse = z.infer<typeof stopSessionResponseSchema>;
+export type ResumeSessionInputsResponse = z.infer<typeof resumeSessionInputsResponseSchema>;
+export declare const runSessionInputsBodySchema: z.ZodObject<{
+    functions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodString;
+        inputSchema: z.ZodCustom<z.core.JSONSchema.JSONSchema, z.core.JSONSchema.JSONSchema>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type RunSessionInputsBody = z.infer<typeof runSessionInputsBodySchema>;

package/dist/contracts/entities/session-inputs.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { turnIdSchema } from "../ids.js";
+import { chatFunctionDefinitionsSchema } from "./chat.js";
+import { sessionMessageSchema } from "./sessions.js";
+export const sessionInputStateSchema = z.enum([
+    "accepted",
+    "delivered",
+    "consumed",
+    "committed",
+    "cancelled",
+    "uncertain",
+]);
+export const sessionInputModeSchema = z.enum(["queue", "steer"]);
+export const sessionInputRequestIdSchema = z
+    .string()
+    .min(1)
+    .max(128)
+    .refine((requestId) => requestId !== "." && requestId !== "..", {
+    message: "requestId must not be a URL dot segment.",
+});
+export const sessionInputSchema = z
+    .object({
+    requestId: sessionInputRequestIdSchema,
+    sequence: z.number().int().positive(),
+    message: sessionMessageSchema.extend({ role: z.literal("user") }),
+    mode: sessionInputModeSchema,
+    state: sessionInputStateSchema,
+    turnId: turnIdSchema.nullable(),
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+    consumedAt: z.iso.datetime({ offset: true }).nullable(),
+    reason: z.enum(["stopped", "failed", "owner_lost", "deleted"]).nullable(),
+})
+    .strip();
+export const sessionActivitySchema = z
+    .object({
+    state: z.enum(["idle", "running", "stopping", "approval", "paused"]),
+    turnId: turnIdSchema.nullable(),
+    reason: z
+        .enum(["failed", "owner_lost", "function_executor_required"])
+        .nullable(),
+})
+    .strip();
+export const sessionInputResponseSchema = z
+    .object({ data: sessionInputSchema, activity: sessionActivitySchema })
+    .strip();
+export const sessionInputsResponseSchema = z
+    .object({
+    data: z.array(sessionInputSchema),
+    nextCursor: z.string().nullable(),
+    activity: sessionActivitySchema,
+})
+    .strip();
+export const submitSessionInputBodySchema = z
+    .object({
+    requestId: sessionInputRequestIdSchema,
+    /** The HTTP boundary validates the user message with AI SDK. */
+    message: z.unknown().refine((message) => message !== undefined),
+    whenBusy: sessionInputModeSchema.default("queue"),
+})
+    .strict();
+export const sessionInputsQuerySchema = z
+    .object({
+    includeCompleted: z.boolean().default(false),
+    limit: z.number().int().min(1).max(200).default(100),
+    cursor: z.string().min(1).optional(),
+})
+    .strict();
+export const stopSessionBodySchema = z
+    .object({ turnId: turnIdSchema })
+    .strict();
+export const stopSessionResponseSchema = z
+    .object({ stoppedTurnId: turnIdSchema, activity: sessionActivitySchema })
+    .strip();
+export const resumeSessionInputsResponseSchema = z
+    .object({ activity: sessionActivitySchema })
+    .strip();
+export const runSessionInputsBodySchema = z
+    .object({ functions: chatFunctionDefinitionsSchema.optional() })
+    .strict();

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

@@ -4,7 +4,6 @@ import { z } from "zod";
  * leak to the wire; `userId`/`metadata` come from the first successful Turn.
  */
 export declare const sessionListItemSchema: z.ZodObject<{
-    agentVersion: z.ZodNullable<z.ZodNumber>;
     id: z.ZodString;
     messageCount: z.ZodNumber;
     lastMessagePreview: z.ZodNullable<z.ZodString>;
@@ -15,7 +14,6 @@ export declare const sessionListItemSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const sessionsListResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
-        agentVersion: z.ZodNullable<z.ZodNumber>;
         id: z.ZodString;
         messageCount: z.ZodNumber;
         lastMessagePreview: z.ZodNullable<z.ZodString>;
@@ -26,14 +24,117 @@ export declare const sessionsListResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
+export declare const sessionResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    messageCount: z.ZodNumber;
+    lastMessagePreview: z.ZodNullable<z.ZodString>;
+    userId: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    agentConfig: z.ZodObject<{
+        approvalInChat: z.ZodDefault<z.ZodObject<{
+            default: z.ZodEnum<{
+                auto: "auto";
+                deny: "deny";
+                full: "full";
+                manual: "manual";
+            }>;
+            overrides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                tool: 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">;
+                decision: z.ZodEnum<{
+                    auto: "auto";
+                    deny: "deny";
+                    full: "full";
+                    manual: "manual";
+                }>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        approvalInTasks: z.ZodDefault<z.ZodObject<{
+            default: z.ZodEnum<{
+                auto: "auto";
+                deny: "deny";
+                full: "full";
+                manual: "manual";
+            }>;
+            overrides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                tool: 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">;
+                decision: z.ZodEnum<{
+                    auto: "auto";
+                    deny: "deny";
+                    full: "full";
+                    manual: "manual";
+                }>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        name: z.ZodString;
+        model: z.ZodNullable<z.ZodString>;
+        thinkingLevel: z.ZodNullable<z.ZodString>;
+        providerId: z.ZodNullable<z.ZodString>;
+        autoCompaction: z.ZodBoolean;
+        compactionReserveTokens: z.ZodNumber;
+        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>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 /**
  * `GET /v1/sessions/latest` list item — one per Agent: the Agent's most
  * recently updated Session (optionally among one end user's Sessions).
  * Carries `agentId` and the Agent's current model, Thinking level, and status,
- * independently of the Session's pinned Version.
+ * independently of the Session's saved configuration.
  */
 export declare const latestSessionListItemSchema: z.ZodObject<{
-    agentVersion: z.ZodNullable<z.ZodNumber>;
     id: z.ZodString;
     messageCount: z.ZodNumber;
     lastMessagePreview: z.ZodNullable<z.ZodString>;
@@ -51,7 +152,6 @@ export declare const latestSessionListItemSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const latestSessionsListResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
-        agentVersion: z.ZodNullable<z.ZodNumber>;
         id: z.ZodString;
         messageCount: z.ZodNumber;
         lastMessagePreview: z.ZodNullable<z.ZodString>;
@@ -243,6 +343,7 @@ export declare const toolApprovalDecisionResponseSchema: z.ZodObject<{
     }>;
 }, z.core.$strip>;
 export type SessionListItem = z.infer<typeof sessionListItemSchema>;
+export type SessionResponse = z.infer<typeof sessionResponseSchema>;
 export type SessionsListResponse = z.infer<typeof sessionsListResponseSchema>;
 export type LatestSessionListItem = z.infer<typeof latestSessionListItemSchema>;
 export type LatestSessionsListResponse = z.infer<typeof latestSessionsListResponseSchema>;

package/dist/contracts/entities/sessions.js

@@ -3,7 +3,7 @@ import { paginatedResponseSchema } from "../api.js";
 import { agentIdSchema, sessionIdSchema } from "../ids.js";
 import { DEFAULT_SESSION_MESSAGES_LIMIT, MAX_SESSION_MESSAGES_LIMIT, } from "../limitations.js";
 import { toolExecutionReferenceSchema } from "./agent-approval.js";
-import { agentSchema, agentVersionNumberSchema } from "./agents.js";
+import { agentConfigSchema, agentSchema } from "./agents.js";
 import { metadataSchema, userIdSchema } from "./attribution.js";
 /**
  * `GET /v1/agents/{agentId}/sessions` list item. `agentId`/`tenantId` never
@@ -11,7 +11,6 @@ import { metadataSchema, userIdSchema } from "./attribution.js";
  */
 export const sessionListItemSchema = z
     .object({
-    agentVersion: agentVersionNumberSchema.nullable(),
     id: sessionIdSchema,
     messageCount: z.number().int().nonnegative(),
     lastMessagePreview: z.string().nullable(),
@@ -22,11 +21,14 @@ export const sessionListItemSchema = z
 })
     .strip();
 export const sessionsListResponseSchema = paginatedResponseSchema(sessionListItemSchema);
+export const sessionResponseSchema = sessionListItemSchema
+    .extend({ agentConfig: agentConfigSchema })
+    .strip();
 /**
  * `GET /v1/sessions/latest` list item — one per Agent: the Agent's most
  * recently updated Session (optionally among one end user's Sessions).
  * Carries `agentId` and the Agent's current model, Thinking level, and status,
- * independently of the Session's pinned Version.
+ * independently of the Session's saved configuration.
  */
 export const latestSessionListItemSchema = sessionListItemSchema
     .extend({