@blazingagents/sdk 0.1.0

package/dist/contracts/entities/prompts.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { promptIdSchema, tenantIdSchema } from "../ids.js";
+import { MAX_PROMPT_NAME_LENGTH, MAX_PROMPT_TEMPLATE_BYTES, MAX_PROMPT_VARIABLES, } from "../limitations.js";
+import { atLeastOneFieldMessage, hasObjectKeys } from "../utils.js";
+import { metadataSchema, userIdSchema } from "./attribution.js";
+export const promptVariableTokenPattern = /{{([\s\S]*?)}}/g;
+export const promptVariableNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const promptNameSchema = z.string().trim().min(1).max(MAX_PROMPT_NAME_LENGTH);
+export function parsePromptVariables(template) {
+    const invalidVariableNames = [];
+    const seenVariables = new Set();
+    const variables = [];
+    for (const match of template.matchAll(promptVariableTokenPattern)) {
+        const variableName = match[1].trim();
+        if (!promptVariableNamePattern.test(variableName)) {
+            invalidVariableNames.push(variableName);
+            continue;
+        }
+        if (!seenVariables.has(variableName)) {
+            seenVariables.add(variableName);
+            variables.push(variableName);
+        }
+    }
+    return { invalidVariableNames, variables };
+}
+export const promptTemplateSchema = z
+    .string()
+    .trim()
+    .min(1, { message: "Prompt template is required." })
+    .max(MAX_PROMPT_TEMPLATE_BYTES, {
+    message: `Prompt template must be at most ${MAX_PROMPT_TEMPLATE_BYTES} bytes.`,
+})
+    .superRefine((template, ctx) => {
+    const { invalidVariableNames, variables } = parsePromptVariables(template);
+    if (invalidVariableNames.length > 0) {
+        ctx.addIssue({
+            code: "custom",
+            message: "Prompt variables must match [A-Za-z_][A-Za-z0-9_]*.",
+        });
+    }
+    if (variables.length > MAX_PROMPT_VARIABLES) {
+        ctx.addIssue({
+            code: "custom",
+            message: `Prompts can include at most ${MAX_PROMPT_VARIABLES} variables.`,
+        });
+    }
+});
+export const promptSchema = z
+    .object({
+    id: promptIdSchema,
+    tenantId: tenantIdSchema,
+    name: promptNameSchema,
+    template: promptTemplateSchema,
+    variables: z.array(z.string().min(1)),
+    userId: userIdSchema,
+    metadata: metadataSchema,
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+})
+    .strict();
+export const promptsResponseSchema = z
+    .object({
+    prompts: z.array(promptSchema),
+})
+    .strict();
+export const promptResponseSchema = promptSchema;
+export const createPromptBodySchema = z
+    .object({
+    name: promptNameSchema,
+    template: promptTemplateSchema,
+    userId: userIdSchema.default(""),
+    metadata: metadataSchema.default({}),
+})
+    .strict();
+export const updatePromptBodySchema = z
+    .object({
+    name: promptNameSchema.optional(),
+    template: promptTemplateSchema.optional(),
+    metadata: metadataSchema.optional(),
+})
+    .strict()
+    .refine(hasObjectKeys, {
+    message: atLeastOneFieldMessage,
+});
+export function renderPromptTemplate(template, values) {
+    return promptTemplateSchema
+        .parse(template)
+        .replace(promptVariableTokenPattern, (_token, rawVariableName) => {
+        const variableName = rawVariableName.trim();
+        const value = values[variableName];
+        if (typeof value !== "string") {
+            throw new Error(`Missing prompt variable value: ${variableName}`);
+        }
+        return value;
+    });
+}

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

@@ -0,0 +1,123 @@
+import { z } from "zod";
+/**
+ * Provider type — the enum of model providers we support. Selects catalog
+ * discovery and AI SDK model behavior.
+ * (docs/adr/0039-explicit-provider-model-pairs.md)
+ */
+export declare const providerTypeSchema: z.ZodEnum<{
+    anthropic: "anthropic";
+    custom: "custom";
+    google: "google";
+    openai: "openai";
+    openrouter: "openrouter";
+    vercel_ai_gateway: "vercel_ai_gateway";
+}>;
+export type ProviderType = z.infer<typeof providerTypeSchema>;
+/**
+ * Stored row — the full persisted record, including the Vault pointer and
+ * tenant id. Used internally by services; never sent on the wire.
+ */
+export declare const providerSchema: z.ZodObject<{
+    id: z.ZodString;
+    tenantId: z.ZodString;
+    name: z.ZodString;
+    providerType: z.ZodEnum<{
+        anthropic: "anthropic";
+        custom: "custom";
+        google: "google";
+        openai: "openai";
+        openrouter: "openrouter";
+        vercel_ai_gateway: "vercel_ai_gateway";
+    }>;
+    baseUrl: z.ZodNullable<z.ZodString>;
+    keyFragment: z.ZodString;
+    vaultSecretId: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+/**
+ * Wire response — `GET /v1/providers` and `GET /v1/providers/{id}` shape per
+ * ticket 12: `{ id, name, providerType, baseUrl, keyFragment, createdAt,
+ * updatedAt }`. The Vault pointer and tenant id are write-only/internal.
+ */
+export declare const providerResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    providerType: z.ZodEnum<{
+        anthropic: "anthropic";
+        custom: "custom";
+        google: "google";
+        openai: "openai";
+        openrouter: "openrouter";
+        vercel_ai_gateway: "vercel_ai_gateway";
+    }>;
+    baseUrl: z.ZodNullable<z.ZodString>;
+    keyFragment: z.ZodString;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const providersResponseSchema: z.ZodObject<{
+    providers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        providerType: z.ZodEnum<{
+            anthropic: "anthropic";
+            custom: "custom";
+            google: "google";
+            openai: "openai";
+            openrouter: "openrouter";
+            vercel_ai_gateway: "vercel_ai_gateway";
+        }>;
+        baseUrl: z.ZodNullable<z.ZodString>;
+        keyFragment: z.ZodString;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const providerModelsResponseSchema: z.ZodObject<{
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const providerHistoricalUseDetailsSchema: z.ZodObject<{
+    agentVersions: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        version: z.ZodNumber;
+    }, z.core.$strict>>;
+    sessionIds: z.ZodArray<z.ZodString>;
+    taskIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * `POST /v1/providers` — name, type, optional base URL, and the API key
+ * (plaintext, never stored — goes to Vault). `custom` providers require a
+ * non-empty baseUrl. Vercel AI Gateway accepts no base URL because it always
+ * uses the first-party Gateway endpoint.
+ */
+export declare const createProviderBodySchema: z.ZodObject<{
+    name: z.ZodString;
+    providerType: z.ZodEnum<{
+        anthropic: "anthropic";
+        custom: "custom";
+        google: "google";
+        openai: "openai";
+        openrouter: "openrouter";
+        vercel_ai_gateway: "vercel_ai_gateway";
+    }>;
+    baseUrl: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodLiteral<"">]>>>;
+    apiKey: z.ZodString;
+}, z.core.$strict>;
+/** `PATCH /v1/providers/{id}` — only the display name is mutable. */
+export declare const updateProviderBodySchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strict>;
+export type Provider = z.infer<typeof providerSchema>;
+export type ProvidersResponse = z.infer<typeof providersResponseSchema>;
+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;
+}
+export type ProviderResponse = z.infer<typeof providerResponseSchema>;
+export type CreateProviderBody = z.infer<typeof createProviderBodySchema>;
+export type UpdateProviderBody = z.infer<typeof updateProviderBodySchema>;

package/dist/contracts/entities/providers.js

@@ -0,0 +1,111 @@
+import { z } from "zod";
+import { agentIdSchema, providerIdSchema, providerKeyFragmentSchema, sessionIdSchema, taskIdSchema, 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.
+ * (docs/adr/0039-explicit-provider-model-pairs.md)
+ */
+export const providerTypeSchema = z.enum([
+    "openai",
+    "anthropic",
+    "openrouter",
+    "google",
+    "vercel_ai_gateway",
+    "custom",
+]);
+const providerNameSchema = z
+    .string()
+    .trim()
+    .min(1)
+    .max(MAX_PROVIDER_NAME_LENGTH);
+const providerBaseUrlSchema = z.string().trim().min(1).url().or(z.literal(""));
+/**
+ * Stored row — the full persisted record, including the Vault pointer and
+ * tenant id. Used internally by services; never sent on the wire.
+ */
+export const providerSchema = z
+    .object({
+    id: providerIdSchema,
+    tenantId: tenantIdSchema,
+    name: providerNameSchema,
+    providerType: providerTypeSchema,
+    baseUrl: z.string().nullable(),
+    keyFragment: providerKeyFragmentSchema,
+    vaultSecretId: z.string().min(1),
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+})
+    .strict();
+/**
+ * Wire response — `GET /v1/providers` and `GET /v1/providers/{id}` shape per
+ * ticket 12: `{ id, name, providerType, baseUrl, keyFragment, createdAt,
+ * updatedAt }`. The Vault pointer and tenant id are write-only/internal.
+ */
+export const providerResponseSchema = z
+    .object({
+    id: providerIdSchema,
+    name: providerNameSchema,
+    providerType: providerTypeSchema,
+    baseUrl: z.string().nullable(),
+    keyFragment: providerKeyFragmentSchema,
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+})
+    .strict();
+export const providersResponseSchema = z
+    .object({
+    providers: z.array(providerResponseSchema),
+})
+    .strict();
+export const providerModelsResponseSchema = z
+    .object({
+    models: z.array(z
+        .object({
+        id: z.string().trim().min(1),
+    })
+        .strict()),
+})
+    .strict();
+export const providerHistoricalUseDetailsSchema = z
+    .object({
+    agentVersions: z.array(z
+        .object({
+        agentId: agentIdSchema,
+        version: agentVersionNumberSchema,
+    })
+        .strict()),
+    sessionIds: z.array(sessionIdSchema),
+    taskIds: z.array(taskIdSchema),
+})
+    .strict();
+/**
+ * `POST /v1/providers` — name, type, optional base URL, and the API key
+ * (plaintext, never stored — goes to Vault). `custom` providers require a
+ * non-empty baseUrl. Vercel AI Gateway accepts no base URL because it always
+ * uses the first-party Gateway endpoint.
+ */
+export const createProviderBodySchema = z
+    .object({
+    name: providerNameSchema,
+    providerType: providerTypeSchema,
+    baseUrl: providerBaseUrlSchema.nullable().default(null),
+    apiKey: z.string().trim().min(1),
+})
+    .strict()
+    .refine((body) => body.providerType !== "custom" ||
+    (body.baseUrl !== null && body.baseUrl.length > 0), {
+    message: "baseUrl is required for custom providers",
+    path: ["baseUrl"],
+})
+    .refine((body) => body.providerType !== "vercel_ai_gateway" || body.baseUrl === null, {
+    message: "baseUrl is not accepted for Vercel AI Gateway providers",
+    path: ["baseUrl"],
+});
+/** `PATCH /v1/providers/{id}` — only the display name is mutable. */
+export const updateProviderBodySchema = z
+    .object({
+    name: providerNameSchema,
+})
+    .strict();

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

@@ -0,0 +1,156 @@
+import { z } from "zod";
+/**
+ * `GET /v1/agents/{agentId}/sessions` list item — the public wire shape:
+ * `{ id, agentVersion, createdAt, updatedAt, messageCount,
+ * lastMessagePreview, userId, metadata }`. `agentId`/`tenantId` are internal
+ * (used for filtering) and never leak to the wire. `userId`/`metadata` are
+ * stamped at lazy materialization (the first successful turn's attribution).
+ */
+export declare const sessionListItemSchema: z.ZodObject<{
+    agentVersion: z.ZodNullable<z.ZodNumber>;
+    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;
+}, z.core.$strict>;
+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>;
+        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>;
+/**
+ * `GET /v1/agents/{agentId}/sessions/{sessionId}/messages` — transcript as
+ * `UIMessage[]` verbatim, paginated backwards (newest page first) with an
+ * optional forward `?after={cursor}` for the poll loop.
+ */
+export declare const sessionMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<{
+        assistant: "assistant";
+        system: "system";
+        user: "user";
+    }>;
+    parts: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+    }, z.core.$loose>>;
+    metadata: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+/**
+ * The messages endpoint carries two cursors: `nextCursor` for continuing
+ * pagination in the requested direction (backward `?cursor=` walks older
+ * pages; forward `?after=` walks the next forward page), and `latestCursor`
+ * — the tail position (the seq of the newest message in the page) for the
+ * cron/task poll loop to pass back as `?after=`. `latestCursor` is always
+ * present when `data` is non-empty, even on the last page, so the poll loop
+ * has a cursor to watch a transcript grow.
+ */
+export declare const sessionMessagesResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            system: "system";
+            user: "user";
+        }>;
+        parts: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    latestCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const sessionMessagesQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    after: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+/** Decision-only input for one server-owned Tool approval. */
+export declare const decideToolApprovalBodySchema: z.ZodObject<{
+    approved: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const toolApprovalContinuationStateSchema: z.ZodEnum<{
+    failed: "failed";
+    queued: "queued";
+    running: "running";
+    succeeded: "succeeded";
+    waiting: "waiting";
+}>;
+export declare const toolApprovalStateSchema: z.ZodObject<{
+    approvalId: z.ZodString;
+    decision: z.ZodEnum<{
+        approved: "approved";
+        denied: "denied";
+        pending: "pending";
+    }>;
+    input: z.ZodJSONSchema;
+    reason: z.ZodNullable<z.ZodString>;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+}, z.core.$strict>;
+export declare const toolApprovalContinuationSchema: z.ZodObject<{
+    id: z.ZodString;
+    state: z.ZodEnum<{
+        failed: "failed";
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        waiting: "waiting";
+    }>;
+}, z.core.$strict>;
+export declare const toolApprovalsResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        approvalId: z.ZodString;
+        decision: z.ZodEnum<{
+            approved: "approved";
+            denied: "denied";
+            pending: "pending";
+        }>;
+        input: z.ZodJSONSchema;
+        reason: z.ZodNullable<z.ZodString>;
+        toolCallId: z.ZodString;
+        toolName: z.ZodString;
+    }, z.core.$strict>>;
+    continuation: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        state: z.ZodEnum<{
+            failed: "failed";
+            queued: "queued";
+            running: "running";
+            succeeded: "succeeded";
+            waiting: "waiting";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const toolApprovalDecisionResponseSchema: z.ZodObject<{
+    continuationId: z.ZodString;
+    state: z.ZodEnum<{
+        failed: "failed";
+        queued: "queued";
+        running: "running";
+        succeeded: "succeeded";
+        waiting: "waiting";
+    }>;
+}, z.core.$strict>;
+export type SessionListItem = z.infer<typeof sessionListItemSchema>;
+export type SessionsListResponse = z.infer<typeof sessionsListResponseSchema>;
+export type SessionMessage = z.infer<typeof sessionMessageSchema>;
+export type SessionMessagesResponse = z.infer<typeof sessionMessagesResponseSchema>;
+export type SessionMessagesQuery = z.infer<typeof sessionMessagesQuerySchema>;
+export type DecideToolApprovalBody = z.infer<typeof decideToolApprovalBodySchema>;
+export type ToolApprovalContinuationState = z.infer<typeof toolApprovalContinuationStateSchema>;
+export type ToolApprovalState = z.infer<typeof toolApprovalStateSchema>;
+export type ToolApprovalsResponse = z.infer<typeof toolApprovalsResponseSchema>;
+export type ToolApprovalDecisionResponse = z.infer<typeof toolApprovalDecisionResponseSchema>;

package/dist/contracts/entities/sessions.js

@@ -0,0 +1,120 @@
+import { z } from "zod";
+import { paginatedResponseSchema } from "../api.js";
+import { sessionIdSchema } from "../ids.js";
+import { DEFAULT_SESSION_MESSAGES_LIMIT, MAX_SESSION_MESSAGES_LIMIT, } from "../limitations.js";
+import { agentVersionNumberSchema } from "./agents.js";
+import { metadataSchema, userIdSchema } from "./attribution.js";
+/**
+ * `GET /v1/agents/{agentId}/sessions` list item — the public wire shape:
+ * `{ id, agentVersion, createdAt, updatedAt, messageCount,
+ * lastMessagePreview, userId, metadata }`. `agentId`/`tenantId` are internal
+ * (used for filtering) and never leak to the wire. `userId`/`metadata` are
+ * stamped at lazy materialization (the first successful turn's attribution).
+ */
+export const sessionListItemSchema = z
+    .object({
+    agentVersion: agentVersionNumberSchema.nullable(),
+    id: sessionIdSchema,
+    messageCount: z.number().int().nonnegative(),
+    lastMessagePreview: z.string().nullable(),
+    userId: userIdSchema,
+    metadata: metadataSchema,
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+})
+    .strict();
+export const sessionsListResponseSchema = paginatedResponseSchema(sessionListItemSchema);
+/**
+ * `GET /v1/agents/{agentId}/sessions/{sessionId}/messages` — transcript as
+ * `UIMessage[]` verbatim, paginated backwards (newest page first) with an
+ * optional forward `?after={cursor}` for the poll loop.
+ */
+export const sessionMessageSchema = z
+    .object({
+    id: z.string().min(1),
+    role: z.enum(["system", "user", "assistant"]),
+    parts: z
+        .array(z
+        .object({
+        type: z.string().min(1),
+    })
+        .passthrough())
+        .min(1),
+    metadata: z.unknown().optional(),
+})
+    .passthrough();
+/**
+ * The messages endpoint carries two cursors: `nextCursor` for continuing
+ * pagination in the requested direction (backward `?cursor=` walks older
+ * pages; forward `?after=` walks the next forward page), and `latestCursor`
+ * — the tail position (the seq of the newest message in the page) for the
+ * cron/task poll loop to pass back as `?after=`. `latestCursor` is always
+ * present when `data` is non-empty, even on the last page, so the poll loop
+ * has a cursor to watch a transcript grow.
+ */
+export const sessionMessagesResponseSchema = z
+    .object({
+    data: z.array(sessionMessageSchema),
+    nextCursor: z.string().nullable(),
+    latestCursor: z.string().nullable(),
+})
+    .strict();
+// Query params for the messages endpoint.
+export const sessionMessagesQuerySchema = z
+    .object({
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(MAX_SESSION_MESSAGES_LIMIT)
+        .default(DEFAULT_SESSION_MESSAGES_LIMIT),
+    cursor: z.string().nullable().optional(),
+    after: z.string().nullable().optional(),
+})
+    .strict()
+    .refine((value) => !(value.cursor && value.after), {
+    message: "cursor and after are mutually exclusive.",
+    path: ["after"],
+});
+/** Decision-only input for one server-owned Tool approval. */
+export const decideToolApprovalBodySchema = z
+    .object({
+    approved: z.boolean(),
+    reason: z.string().trim().min(1).max(1000).optional(),
+})
+    .strict();
+export const toolApprovalContinuationStateSchema = z.enum([
+    "waiting",
+    "queued",
+    "running",
+    "succeeded",
+    "failed",
+]);
+export const toolApprovalStateSchema = z
+    .object({
+    approvalId: z.string().min(1),
+    decision: z.enum(["pending", "approved", "denied"]),
+    input: z.json(),
+    reason: z.string().nullable(),
+    toolCallId: z.string().min(1),
+    toolName: z.string().min(1),
+})
+    .strict();
+export const toolApprovalContinuationSchema = z
+    .object({
+    id: z.string().min(1),
+    state: toolApprovalContinuationStateSchema,
+})
+    .strict();
+export const toolApprovalsResponseSchema = z
+    .object({
+    data: z.array(toolApprovalStateSchema),
+    continuation: toolApprovalContinuationSchema.nullable(),
+})
+    .strict();
+export const toolApprovalDecisionResponseSchema = z
+    .object({
+    continuationId: z.string().min(1),
+    state: toolApprovalContinuationStateSchema,
+})
+    .strict();