@blazingagents/sdk 0.15.0 → 0.17.0

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

@@ -19,7 +19,6 @@ export declare const chatTriggerSchema: z.ZodEnum<{
  */
 export declare const usageSummarySchema: z.ZodObject<{
     agentId: z.ZodString;
-    agentVersion: z.ZodNumber;
     commitId: z.ZodString;
     completedAt: z.ZodISODateTime;
     durationMs: z.ZodNumber;
@@ -52,7 +51,6 @@ export declare const blazingAgentsChatMessageMetadataSchema: z.ZodObject<{
     blazingAgents: z.ZodObject<{
         usage: z.ZodObject<{
             agentId: z.ZodString;
-            agentVersion: z.ZodNumber;
             commitId: z.ZodString;
             completedAt: z.ZodISODateTime;
             durationMs: z.ZodNumber;
@@ -97,6 +95,75 @@ type ExclusivePromptInput<Literal extends object> = (Literal & {
     promptId: string;
     variables?: z.infer<typeof promptVariablesSchema>;
 });
+/**
+ * The JSON Schema accepted by structured generation. Zod's JSON Schema
+ * compiler (`z.fromJSONSchema`) is the single authority for the supported
+ * feature set: anything it can convert is accepted, anything it cannot
+ * (unresolvable references, unsupported keywords, …) is rejected at this
+ * untrusted boundary. The only product restriction on top is the documented
+ * "at least a schema root" rule, which keeps the empty match-anything schema
+ * out of object mode. Composition roots are needed for schemas derived from
+ * unions (for example, Pydantic's `int | None` TypeAdapter schema), and local
+ * `$ref` roots are needed for recursive Pydantic models.
+ */
+export declare const jsonSchemaShapeSchema: z.ZodCustom<z.core.JSONSchema.JSONSchema, z.core.JSONSchema.JSONSchema>;
+export declare const MAX_CHAT_FUNCTIONS = 32;
+export declare const MAX_CHAT_FUNCTION_DEFINITIONS_BYTES: number;
+export declare const MAX_CHAT_FUNCTION_PAYLOAD_BYTES: number;
+export declare const jsonByteLength: (value: unknown) => number;
+/** One caller-local function as sent to Blazing Agents: description and JSON Schema only. */
+export declare const chatFunctionDefinitionSchema: z.ZodObject<{
+    description: z.ZodString;
+    inputSchema: z.ZodCustom<z.core.JSONSchema.JSONSchema, z.core.JSONSchema.JSONSchema>;
+}, z.core.$strict>;
+export declare const chatFunctionDefinitionsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    description: z.ZodString;
+    inputSchema: z.ZodCustom<z.core.JSONSchema.JSONSchema, z.core.JSONSchema.JSONSchema>;
+}, z.core.$strict>>;
+/**
+ * Transient UI data part that authorizes one claim attempt for a function
+ * call. The SDK consumes it and never forwards it to the browser.
+ */
+export declare const chatFunctionCallEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"data-ba-function-call">;
+    data: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodJSONSchema;
+        deadlineAt: z.ZodISODateTime;
+    }, z.core.$strip>;
+    transient: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export declare const chatFunctionOutcomeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"output">;
+    value: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"error">;
+    message: z.ZodString;
+}, z.core.$strict>], "kind">;
+/** `POST .../function-calls/{functionCallId}/claim` body. */
+export declare const claimChatFunctionBodySchema: z.ZodObject<{
+    claimRequestId: z.ZodUUID;
+}, z.core.$strict>;
+export declare const claimChatFunctionResponseSchema: z.ZodObject<{
+    claimed: z.ZodLiteral<true>;
+}, z.core.$strip>;
+/** `POST .../function-calls/{functionCallId}/result` body. */
+export declare const resolveChatFunctionBodySchema: z.ZodObject<{
+    claimRequestId: z.ZodUUID;
+    outcome: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"output">;
+        value: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"error">;
+        message: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>;
+export declare const resolveChatFunctionResponseSchema: z.ZodObject<{
+    accepted: z.ZodLiteral<true>;
+}, z.core.$strip>;
+/** `POST .../tool-approval-continuations/{continuationId}/resume` body. */
+export declare const resumeToolApprovalContinuationBodySchema: z.ZodObject<{}, z.core.$strict>;
 /**
  * `POST /v1/agents/{agentId}/sessions` (create) and
  * `POST /v1/agents/{agentId}/sessions/{sessionId}` (resume) request body.
@@ -114,18 +181,24 @@ export declare const chatRequestBodySchema: z.ZodObject<{
         "submit-message": "submit-message";
     }>>;
     messageId: z.ZodOptional<z.ZodString>;
-    version: z.ZodOptional<z.ZodNumber>;
     userId: z.ZodDefault<z.ZodString>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    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> & z.ZodType<{
     message?: unknown;
     promptId?: string | undefined;
     variables?: Record<string, string> | undefined;
     trigger: "regenerate-message" | "submit-message";
     messageId?: string | undefined;
-    version?: number | undefined;
     userId: string;
     metadata: Record<string, unknown>;
+    functions?: Record<string, {
+        description: string;
+        inputSchema: z.core.JSONSchema.JSONSchema;
+    }> | undefined;
 } & ExclusivePromptInput<{
     message: null | NonNullable<unknown>;
 }>, {
@@ -134,18 +207,24 @@ export declare const chatRequestBodySchema: z.ZodObject<{
     variables?: Record<string, string> | undefined;
     trigger?: "regenerate-message" | "submit-message" | undefined;
     messageId?: string | undefined;
-    version?: number | undefined;
     userId?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
+    functions?: Record<string, {
+        description: string;
+        inputSchema: z.core.JSONSchema.JSONSchema;
+    }> | undefined;
 }, z.core.$ZodTypeInternals<{
     message?: unknown;
     promptId?: string | undefined;
     variables?: Record<string, string> | undefined;
     trigger: "regenerate-message" | "submit-message";
     messageId?: string | undefined;
-    version?: number | undefined;
     userId: string;
     metadata: Record<string, unknown>;
+    functions?: Record<string, {
+        description: string;
+        inputSchema: z.core.JSONSchema.JSONSchema;
+    }> | undefined;
 } & ExclusivePromptInput<{
     message: null | NonNullable<unknown>;
 }>, {
@@ -154,22 +233,13 @@ export declare const chatRequestBodySchema: z.ZodObject<{
     variables?: Record<string, string> | undefined;
     trigger?: "regenerate-message" | "submit-message" | undefined;
     messageId?: string | undefined;
-    version?: number | undefined;
     userId?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
+    functions?: Record<string, {
+        description: string;
+        inputSchema: z.core.JSONSchema.JSONSchema;
+    }> | undefined;
 }>>;
-/**
- * The JSON Schema accepted by structured generation. Zod's JSON Schema
- * compiler (`z.fromJSONSchema`) is the single authority for the supported
- * feature set: anything it can convert is accepted, anything it cannot
- * (unresolvable references, unsupported keywords, …) is rejected at this
- * untrusted boundary. The only product restriction on top is the documented
- * "at least a schema root" rule, which keeps the empty match-anything schema
- * out of object mode. Composition roots are needed for schemas derived from
- * unions (for example, Pydantic's `int | None` TypeAdapter schema), and local
- * `$ref` roots are needed for recursive Pydantic models.
- */
-export declare const jsonSchemaShapeSchema: z.ZodCustom<z.core.JSONSchema.JSONSchema, z.core.JSONSchema.JSONSchema>;
 /**
  * `POST /v1/agents/{agentId}/generation` — the single stateless generation
  * boundary. Output selection is explicit on the wire while prompt selection
@@ -185,7 +255,6 @@ export declare const generationRequestBodySchema: z.ZodObject<{
         type: z.ZodLiteral<"object">;
         schema: z.ZodCustom<z.core.JSONSchema.JSONSchema, z.core.JSONSchema.JSONSchema>;
     }, z.core.$strict>], "type">;
-    version: z.ZodOptional<z.ZodNumber>;
     userId: z.ZodDefault<z.ZodString>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict> & z.ZodType<{
@@ -198,7 +267,6 @@ export declare const generationRequestBodySchema: z.ZodObject<{
         type: "object";
         schema: z.core.JSONSchema.JSONSchema;
     };
-    version?: number | undefined;
     userId: string;
     metadata: Record<string, unknown>;
 } & ExclusivePromptInput<{
@@ -213,7 +281,6 @@ export declare const generationRequestBodySchema: z.ZodObject<{
         type: "object";
         schema: z.core.JSONSchema.JSONSchema;
     };
-    version?: number | undefined;
     userId?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
 }, z.core.$ZodTypeInternals<{
@@ -226,7 +293,6 @@ export declare const generationRequestBodySchema: z.ZodObject<{
         type: "object";
         schema: z.core.JSONSchema.JSONSchema;
     };
-    version?: number | undefined;
     userId: string;
     metadata: Record<string, unknown>;
 } & ExclusivePromptInput<{
@@ -241,7 +307,6 @@ export declare const generationRequestBodySchema: z.ZodObject<{
         type: "object";
         schema: z.core.JSONSchema.JSONSchema;
     };
-    version?: number | undefined;
     userId?: string | undefined;
     metadata?: Record<string, unknown> | undefined;
 }>>;
@@ -264,3 +329,9 @@ export type ChatRequestBody = z.infer<typeof chatRequestBodySchema>;
 export type GenerationRequestBody = z.infer<typeof generationRequestBodySchema>;
 export type ChatStreamErrorChunk = z.infer<typeof chatStreamErrorChunkSchema>;
 export type PromptVariables = z.infer<typeof promptVariablesSchema>;
+export type ChatFunctionDefinition = z.infer<typeof chatFunctionDefinitionSchema>;
+export type ChatFunctionDefinitions = z.infer<typeof chatFunctionDefinitionsSchema>;
+export type ChatFunctionCallEvent = z.infer<typeof chatFunctionCallEventSchema>;
+export type ChatFunctionOutcome = z.infer<typeof chatFunctionOutcomeSchema>;
+export type ClaimChatFunctionBody = z.infer<typeof claimChatFunctionBodySchema>;
+export type ResolveChatFunctionBody = z.infer<typeof resolveChatFunctionBodySchema>;

package/dist/contracts/entities/chat.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
-import { agentIdSchema, promptIdSchema, sessionIdSchema, tenantIdSchema, turnIdSchema, } from "../ids.js";
-import { agentModelIdSchema, agentVersionNumberSchema } from "./agents.js";
+import { agentIdSchema, functionCallIdSchema, promptIdSchema, sessionIdSchema, tenantIdSchema, turnIdSchema, } from "../ids.js";
+import { chatFunctionNameSchema } from "./agent-tools.js";
+import { agentModelIdSchema } from "./agents.js";
 import { metadataSchema, userIdSchema } from "./attribution.js";
 export const chatModeSchema = z.enum(["create", "resume"]);
 export const chatTriggerSchema = z.enum([
@@ -15,7 +16,6 @@ export const chatTriggerSchema = z.enum([
 export const usageSummarySchema = z
     .object({
     agentId: agentIdSchema,
-    agentVersion: agentVersionNumberSchema,
     commitId: z.string().trim().min(1),
     completedAt: z.iso.datetime({ offset: true }),
     durationMs: z.number().int().min(0),
@@ -60,41 +60,6 @@ export const blazingAgentsChatMessageMetadataSchema = z
  * against the template (missing or unknown variable → 400 invalid_request).
  */
 export const promptVariablesSchema = z.record(z.string(), z.string());
-/**
- * `POST /v1/agents/{agentId}/sessions` (create) and
- * `POST /v1/agents/{agentId}/sessions/{sessionId}` (resume) request body.
- * The URL selects the mode; on create the platform mints the `ss_` id and
- * returns it in `Location`. Exactly one of `message` or `promptId` is
- * required, and `variables` requires `promptId`. Regenerate is resume-only,
- * enforced by the route layer rather than this schema.
- */
-export const chatRequestBodySchema = z
-    .object({
-    /**
-     * AI SDK owns the runtime UIMessage schema. Core keeps this wire field
-     * unknown; the HTTP boundary validates it with `safeValidateUIMessages`
-     * before treating it as a UIMessage.
-     */
-    message: z.unknown().optional(),
-    promptId: promptIdSchema.optional(),
-    variables: promptVariablesSchema.optional(),
-    trigger: chatTriggerSchema.default("submit-message"),
-    messageId: z.string().min(1).optional(),
-    version: agentVersionNumberSchema.optional(),
-    /**
-     * End-user attribution (ADR-0001), stamped on the Session at lazy
-     * materialization and on every usage row this Turn records.
-     */
-    userId: userIdSchema.default(""),
-    metadata: metadataSchema.default({}),
-})
-    .strict()
-    .refine((body) => body.message === undefined
-    ? body.promptId !== undefined
-    : body.promptId === undefined && body.variables === undefined, {
-    message: "Provide either `message` or `promptId` (+`variables`); they are mutually exclusive, and `variables` is only allowed with `promptId`.",
-    path: ["message"],
-});
 const JSON_SCHEMA_COMPOSITION_KEYS = ["allOf", "anyOf", "oneOf"];
 function hasMeaningfulSchemaRoot(value, definitions, seenReferences) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -152,6 +117,108 @@ export const jsonSchemaShapeSchema = z.custom((value) => {
         return false;
     }
 }, { message: "schema contains an unsupported or invalid JSON Schema feature" });
+export const MAX_CHAT_FUNCTIONS = 32;
+export const MAX_CHAT_FUNCTION_DEFINITIONS_BYTES = 64 * 1024;
+export const MAX_CHAT_FUNCTION_PAYLOAD_BYTES = 256 * 1024;
+export const jsonByteLength = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
+/** One caller-local function as sent to Blazing Agents: description and JSON Schema only. */
+export const chatFunctionDefinitionSchema = z
+    .object({
+    description: z.string().trim().min(1),
+    inputSchema: jsonSchemaShapeSchema.refine((schema) => typeof schema === "object" && schema.type === "object", { message: "Function input schema must describe a JSON object." }),
+})
+    .strict();
+export const chatFunctionDefinitionsSchema = z
+    .record(chatFunctionNameSchema, chatFunctionDefinitionSchema)
+    .refine((functions) => Object.keys(functions).length <= MAX_CHAT_FUNCTIONS, {
+    message: `At most ${MAX_CHAT_FUNCTIONS} functions are allowed.`,
+})
+    .refine((functions) => jsonByteLength(functions) <= MAX_CHAT_FUNCTION_DEFINITIONS_BYTES, {
+    message: `Function definitions must not exceed ${MAX_CHAT_FUNCTION_DEFINITIONS_BYTES} bytes.`,
+});
+/**
+ * Transient UI data part that authorizes one claim attempt for a function
+ * call. The SDK consumes it and never forwards it to the browser.
+ */
+export const chatFunctionCallEventSchema = z
+    .object({
+    type: z.literal("data-ba-function-call"),
+    data: z
+        .object({
+        id: functionCallIdSchema,
+        name: chatFunctionNameSchema,
+        input: z.json(),
+        deadlineAt: z.iso.datetime({ offset: true }),
+    })
+        .strip(),
+    transient: z.literal(true),
+})
+    .strip();
+export const chatFunctionOutcomeSchema = z
+    .discriminatedUnion("kind", [
+    z.object({ kind: z.literal("output"), value: z.json() }).strict(),
+    z
+        .object({
+        kind: z.literal("error"),
+        message: z.string().min(1).max(4096),
+    })
+        .strict(),
+])
+    .refine((outcome) => jsonByteLength(outcome) <= MAX_CHAT_FUNCTION_PAYLOAD_BYTES, {
+    message: `Function outcome must not exceed ${MAX_CHAT_FUNCTION_PAYLOAD_BYTES} bytes.`,
+});
+/** `POST .../function-calls/{functionCallId}/claim` body. */
+export const claimChatFunctionBodySchema = z
+    .object({ claimRequestId: z.uuid() })
+    .strict();
+export const claimChatFunctionResponseSchema = z
+    .object({ claimed: z.literal(true) })
+    .strip();
+/** `POST .../function-calls/{functionCallId}/result` body. */
+export const resolveChatFunctionBodySchema = z
+    .object({ claimRequestId: z.uuid(), outcome: chatFunctionOutcomeSchema })
+    .strict();
+export const resolveChatFunctionResponseSchema = z
+    .object({ accepted: z.literal(true) })
+    .strip();
+/** `POST .../tool-approval-continuations/{continuationId}/resume` body. */
+export const resumeToolApprovalContinuationBodySchema = z.object({}).strict();
+/**
+ * `POST /v1/agents/{agentId}/sessions` (create) and
+ * `POST /v1/agents/{agentId}/sessions/{sessionId}` (resume) request body.
+ * The URL selects the mode; on create the platform mints the `ss_` id and
+ * returns it in `Location`. Exactly one of `message` or `promptId` is
+ * required, and `variables` requires `promptId`. Regenerate is resume-only,
+ * enforced by the route layer rather than this schema.
+ */
+export const chatRequestBodySchema = z
+    .object({
+    /**
+     * AI SDK owns the runtime UIMessage schema. Core keeps this wire field
+     * unknown; the HTTP boundary validates it with `safeValidateUIMessages`
+     * before treating it as a UIMessage.
+     */
+    message: z.unknown().optional(),
+    promptId: promptIdSchema.optional(),
+    variables: promptVariablesSchema.optional(),
+    trigger: chatTriggerSchema.default("submit-message"),
+    messageId: z.string().min(1).optional(),
+    /**
+     * End-user attribution (ADR-0001), stamped on the Session at lazy
+     * materialization and on every usage row this Turn records.
+     */
+    userId: userIdSchema.default(""),
+    metadata: metadataSchema.default({}),
+    /** Caller-local functions for this invocation; handlers stay in the caller's backend. */
+    functions: chatFunctionDefinitionsSchema.optional(),
+})
+    .strict()
+    .refine((body) => body.message === undefined
+    ? body.promptId !== undefined
+    : body.promptId === undefined && body.variables === undefined, {
+    message: "Provide either `message` or `promptId` (+`variables`); they are mutually exclusive, and `variables` is only allowed with `promptId`.",
+    path: ["message"],
+});
 /**
  * `POST /v1/agents/{agentId}/generation` — the single stateless generation
  * boundary. Output selection is explicit on the wire while prompt selection
@@ -168,7 +235,6 @@ export const generationRequestBodySchema = z
             .object({ type: z.literal("object"), schema: jsonSchemaShapeSchema })
             .strict(),
     ]),
-    version: agentVersionNumberSchema.optional(),
     userId: userIdSchema.default(""),
     metadata: metadataSchema.default({}),
 })

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

@@ -92,12 +92,8 @@ export declare const providerModelsResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const providerHistoricalUseDetailsSchema: z.ZodObject<{
-    agentVersions: z.ZodArray<z.ZodObject<{
-        agentId: z.ZodString;
-        version: z.ZodNumber;
-    }, z.core.$strip>>;
     sessionIds: z.ZodArray<z.ZodString>;
-    taskIds: z.ZodArray<z.ZodString>;
+    taskRunIds: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
 /**
  * `POST /v1/providers` — name, type, optional base URL, and the API key
@@ -128,7 +124,7 @@ export type ProviderModelsResponse = z.infer<typeof providerModelsResponseSchema
 export type ProviderModel = ProviderModelsResponse["models"][number];
 export type ProviderHistoricalUseDetails = z.infer<typeof providerHistoricalUseDetailsSchema>;
 export interface DeleteProviderOptions {
-    confirmVersionInvalidation?: boolean;
+    confirmSnapshotInvalidation?: boolean;
 }
 export type ProviderResponse = z.infer<typeof providerResponseSchema>;
 export type CreateProviderBody = z.infer<typeof createProviderBodySchema>;

package/dist/contracts/entities/providers.js

@@ -1,7 +1,6 @@
 import { z } from "zod";
-import { agentIdSchema, providerIdSchema, providerKeyFragmentSchema, sessionIdSchema, taskIdSchema, tenantIdSchema, } from "../ids.js";
+import { providerIdSchema, providerKeyFragmentSchema, sessionIdSchema, taskRunIdSchema, tenantIdSchema, } from "../ids.js";
 import { MAX_PROVIDER_NAME_LENGTH } from "../limitations.js";
-import { agentVersionNumberSchema } from "./agents.js";
 /**
  * Provider type — the enum of model providers we support. Selects catalog
  * discovery and AI SDK model behavior.
@@ -73,14 +72,8 @@ export const providerModelsResponseSchema = z
     .strip();
 export const providerHistoricalUseDetailsSchema = z
     .object({
-    agentVersions: z.array(z
-        .object({
-        agentId: agentIdSchema,
-        version: agentVersionNumberSchema,
-    })
-        .strip()),
     sessionIds: z.array(sessionIdSchema),
-    taskIds: z.array(taskIdSchema),
+    taskRunIds: z.array(taskRunIdSchema),
 })
     .strip();
 /**

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>;
@@ -151,6 +251,9 @@ export declare const toolApprovalStateSchema: z.ZodObject<{
         type: z.ZodLiteral<"mcp">;
         connectionId: z.ZodString;
         name: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        name: z.ZodString;
     }, z.core.$strict>], "type">>>;
     assistantMessageId: z.ZodOptional<z.ZodString>;
     createdAt: z.ZodOptional<z.ZodISODateTime>;
@@ -200,6 +303,9 @@ export declare const toolApprovalsResponseSchema: z.ZodObject<{
             type: z.ZodLiteral<"mcp">;
             connectionId: z.ZodString;
             name: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"function">;
+            name: z.ZodString;
         }, z.core.$strict>], "type">>>;
         assistantMessageId: z.ZodOptional<z.ZodString>;
         createdAt: z.ZodOptional<z.ZodISODateTime>;
@@ -237,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

@@ -2,8 +2,8 @@ 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 { toolExecutionReferenceSchema } from "./agent-approval.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({
@@ -104,7 +106,7 @@ export const toolApprovalContinuationStateSchema = z.enum([
 ]);
 export const toolApprovalStateSchema = z
     .object({
-    tool: toolReferenceSchema.nullable().optional(),
+    tool: toolExecutionReferenceSchema.nullable().optional(),
     assistantMessageId: z.string().min(1).optional(),
     createdAt: z.iso.datetime({ offset: true }).optional(),
     decidedAt: z.iso.datetime({ offset: true }).nullable().optional(),