@perstack/api-client 0.0.54 → 0.0.55

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { activityOrGroupSchema, checkpointSchema as perstackCheckpointSchema, instructionMessageSchema, messageSchema, stepSchema, toolCallSchema, toolMessageSchema, toolResultSchema, usageSchema, userMessageSchema } from "@perstack/core";
+import { activityOrGroupSchema, instructionMessageSchema, messageSchema, toolCallSchema, toolMessageSchema, toolResultSchema, usageSchema, userMessageSchema } from "@perstack/core";
 
 //#region src/lib/api-key.ts
 function matchWildcard(value, pattern) {
@@ -73,16 +73,16 @@ function createNetworkError(error) {
 		cause: error instanceof Error ? error : void 0
 	};
 }
-async function handleHttpError(response$19) {
+async function handleHttpError(response) {
 	let errorBody;
 	try {
-		errorBody = await response$19.json();
+		errorBody = await response.json();
 	} catch {
 		errorBody = void 0;
 	}
 	return {
 		ok: false,
-		error: createHttpError(response$19.status, response$19.statusText, errorBody)
+		error: createHttpError(response.status, response.statusText, errorBody)
 	};
 }
 function createHttpError(status, statusText, body) {
@@ -219,20 +219,20 @@ function createFetcher(config) {
 			}
 		});
 	}
-	async function request$19(method, path, body, options) {
+	async function request(method, path, body, options) {
 		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
 		try {
-			const response$19 = await fetch(buildUrl(path), {
+			const response = await fetch(buildUrl(path), {
 				method,
 				headers: buildHeaders(body ? { hasBody: true } : void 0),
 				body: body ? JSON.stringify(body) : void 0,
 				signal,
 				credentials: getCredentials()
 			});
-			if (!response$19.ok) return handleHttpError(response$19);
+			if (!response.ok) return handleHttpError(response);
 			return {
 				ok: true,
-				data: await response$19.json()
+				data: await response.json()
 			};
 		} catch (error) {
 			if (error instanceof Error && error.name === "AbortError") {
@@ -256,16 +256,16 @@ function createFetcher(config) {
 	async function requestBlob(path, options) {
 		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
 		try {
-			const response$19 = await fetch(buildUrl(path), {
+			const response = await fetch(buildUrl(path), {
 				method: "GET",
 				headers: buildHeaders(),
 				signal,
 				credentials: getCredentials()
 			});
-			if (!response$19.ok) return handleHttpError(response$19);
+			if (!response.ok) return handleHttpError(response);
 			return {
 				ok: true,
-				data: await response$19.blob()
+				data: await response.blob()
 			};
 		} catch (error) {
 			if (error instanceof Error && error.name === "AbortError") {
@@ -289,17 +289,17 @@ function createFetcher(config) {
 	async function requestStream(path, options) {
 		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
 		try {
-			const response$19 = await fetch(buildUrl(path), {
+			const response = await fetch(buildUrl(path), {
 				method: "GET",
 				headers: buildHeaders(),
 				signal,
 				credentials: getCredentials()
 			});
-			if (!response$19.ok) {
+			if (!response.ok) {
 				cleanup();
-				return handleHttpError(response$19);
+				return handleHttpError(response);
 			}
-			if (!response$19.body) {
+			if (!response.body) {
 				cleanup();
 				return {
 					ok: false,
@@ -310,7 +310,7 @@ function createFetcher(config) {
 			const idleTimeout = options?.streamIdleTimeout ?? timeout;
 			return {
 				ok: true,
-				data: wrapStreamWithIdleTimeout(response$19.body, idleTimeout, options?.signal)
+				data: wrapStreamWithIdleTimeout(response.body, idleTimeout, options?.signal)
 			};
 		} catch (error) {
 			cleanup();
@@ -333,13 +333,13 @@ function createFetcher(config) {
 	async function requestNoContent(method, path, options) {
 		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
 		try {
-			const response$19 = await fetch(buildUrl(path), {
+			const response = await fetch(buildUrl(path), {
 				method,
 				headers: buildHeaders(),
 				signal,
 				credentials: getCredentials()
 			});
-			if (!response$19.ok) return handleHttpError(response$19);
+			if (!response.ok) return handleHttpError(response);
 			return {
 				ok: true,
 				data: void 0
@@ -364,10 +364,10 @@ function createFetcher(config) {
 		}
 	}
 	return {
-		get: (path, options) => request$19("GET", path, void 0, options),
-		post: (path, body, options) => request$19("POST", path, body, options),
-		put: (path, body, options) => request$19("PUT", path, body, options),
-		delete: (path, options) => request$19("DELETE", path, void 0, options),
+		get: (path, options) => request("GET", path, void 0, options),
+		post: (path, body, options) => request("POST", path, body, options),
+		put: (path, body, options) => request("PUT", path, body, options),
+		delete: (path, options) => request("DELETE", path, void 0, options),
 		deleteNoContent: (path, options) => requestNoContent("DELETE", path, options),
 		getBlob: (path, options) => requestBlob(path, options),
 		getStream: (path, options) => requestStream(path, options)
@@ -609,6 +609,11 @@ const errorConflict = z.object({
 	error: z.literal("Conflict"),
 	reason: z.string()
 }).describe("Request conflicts with current state of the resource.");
+const errorServiceUnavailable = z.object({
+	code: z.literal(503),
+	error: z.literal("Service Unavailable"),
+	reason: z.string()
+}).describe("Service temporarily unavailable. Retry with exponential backoff.");
 const errorValidationFailed = z.object({
 	code: z.literal(422),
 	error: z.literal("Validation Failed"),
@@ -650,16 +655,16 @@ const applicationSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/applications/create.ts
-const request$18 = { body: z.object({
+const request$17 = { body: z.object({
 	name: applicationNameSchema,
 	applicationGroupId: cuidSchema.optional()
 }) };
-const response$18 = z.object({ data: z.object({ application: applicationSchema }) });
+const response$17 = z.object({ data: z.object({ application: applicationSchema }) });
 
 //#endregion
 //#region ../models/src/api/applications/getAll.ts
-const request$17 = { query: z.object({
-	name: z.union([z.string(), z.array(z.string())]).optional().transform((v) => Array.isArray(v) ? v.join(",") : v),
+const request$16 = { query: z.object({
+	name: z.preprocess((val) => Array.isArray(val) ? val.join(",") : val, z.string().optional()),
 	sort: z.enum([
 		"name",
 		"createdAt",
@@ -669,21 +674,21 @@ const request$17 = { query: z.object({
 	take: z.coerce.number().min(1).max(100).default(20),
 	skip: z.coerce.number().min(0).default(0)
 }) };
-const response$17 = z.object({
+const response$16 = z.object({
 	data: z.object({ applications: z.array(applicationSchema) }),
 	meta: paginationMeta
 });
 
 //#endregion
 //#region ../models/src/api/applications/update.ts
-const request$16 = {
+const request$15 = {
 	params: z.object({ applicationId: cuidSchema }),
 	body: z.object({
 		name: applicationNameSchema.optional(),
 		status: applicationStatusSchema.exclude(["deleted"]).optional()
 	}).refine((data) => data.name !== void 0 || data.status !== void 0, { message: "At least one field must be provided" })
 };
-const response$16 = z.object({ data: z.object({ application: applicationSchema }) });
+const response$15 = z.object({ data: z.object({ application: applicationSchema }) });
 
 //#endregion
 //#region ../models/src/domain/secret.ts
@@ -705,28 +710,28 @@ const secretSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/env/secrets/create.ts
-const request$15 = { body: z.object({
+const request$14 = { body: z.object({
 	applicationId: cuidSchema,
 	name: secretNameSchema,
 	value: secretValueSchema
 }) };
-const response$15 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
+const response$14 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
 
 //#endregion
 //#region ../models/src/api/env/secrets/getAll.ts
-const request$14 = { query: z.object({ applicationId: cuidSchema.optional() }) };
-const response$14 = z.object({ data: z.object({ secrets: z.array(secretMetadataSchema) }) });
+const request$13 = { query: z.object({ applicationId: cuidSchema.optional() }) };
+const response$13 = z.object({ data: z.object({ secrets: z.array(secretMetadataSchema) }) });
 
 //#endregion
 //#region ../models/src/api/env/secrets/update.ts
-const request$13 = {
+const request$12 = {
 	params: z.object({ name: z.string().min(1) }),
 	body: z.object({
 		applicationId: cuidSchema,
 		value: secretValueSchema
 	})
 };
-const response$13 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
+const response$12 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
 
 //#endregion
 //#region ../models/src/domain/variable.ts
@@ -750,28 +755,28 @@ const variableResponseSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/env/variables/create.ts
-const request$12 = { body: z.object({
+const request$11 = { body: z.object({
 	applicationId: cuidSchema,
 	name: variableNameSchema,
 	value: variableValueSchema
 }) };
-const response$12 = z.object({ data: z.object({ variable: variableResponseSchema }) });
+const response$11 = z.object({ data: z.object({ variable: variableResponseSchema }) });
 
 //#endregion
 //#region ../models/src/api/env/variables/getAll.ts
-const request$11 = { query: z.object({ applicationId: cuidSchema }) };
-const response$11 = z.object({ data: z.object({ variables: z.array(variableResponseSchema) }) });
+const request$10 = { query: z.object({ applicationId: cuidSchema }) };
+const response$10 = z.object({ data: z.object({ variables: z.array(variableResponseSchema) }) });
 
 //#endregion
 //#region ../models/src/api/env/variables/update.ts
-const request$10 = {
+const request$9 = {
 	params: z.object({ name: z.string().min(1) }),
 	body: z.object({
 		applicationId: cuidSchema,
 		value: variableValueSchema
 	})
 };
-const response$10 = z.object({ data: z.object({ variable: variableResponseSchema }) });
+const response$9 = z.object({ data: z.object({ variable: variableResponseSchema }) });
 
 //#endregion
 //#region ../models/src/domain/expertScope.ts
@@ -902,7 +907,7 @@ const expertWithMetadataSchema = expertSchema.extend({
 
 //#endregion
 //#region ../models/src/api/experts/getAll.ts
-const request$9 = { query: z.object({
+const request$8 = { query: z.object({
 	filter: z.string().describe("Filter by scope name (partial match)").optional(),
 	category: z.enum([
 		"general",
@@ -916,114 +921,11 @@ const request$9 = { query: z.object({
 	take: z.coerce.number().min(1).max(100).default(20),
 	skip: z.coerce.number().min(0).default(0)
 }) };
-const response$9 = z.object({
+const response$8 = z.object({
 	data: z.object({ experts: z.array(expertScopeSchema.extend({ currentVersion: expertVersionSchema.nullable() })) }),
 	meta: paginationMeta
 });
 
-//#endregion
-//#region ../models/src/domain/checkpoint.ts
-const delegationTargetSchema = z.object({
-	expert: expertSchema,
-	toolCallId: z.string().min(1).max(maxCheckpointToolCallIdLength),
-	toolName: z.string().min(1).max(maxSkillToolNameLength),
-	query: z.string().min(1)
-});
-/**
-* API Checkpoint schema - extended checkpoint format for API responses.
-* Includes additional fields computed from runtime checkpoint and step data:
-* - activities: computed via getActivities() from @perstack/core
-* - inputMessages, newMessages, toolCalls, toolResults: step-related data
-* - expert: full Expert type (with instruction, skills, etc.)
-* - startedAt/finishedAt: ISO string format (runtime uses Unix timestamps)
-*/
-const apiCheckpointSchema = z.object({
-	type: z.literal("checkpoint"),
-	id: cuidSchema,
-	jobId: cuidSchema,
-	runId: cuidSchema,
-	activities: z.array(activityOrGroupSchema),
-	stepNumber: z.number().int().min(1),
-	status: z.enum([
-		"init",
-		"proceeding",
-		"completed",
-		"stoppedByInteractiveTool",
-		"stoppedByDelegate",
-		"stoppedByExceededMaxSteps",
-		"stoppedByError"
-	]),
-	expert: expertSchema,
-	delegateTo: z.array(delegationTargetSchema).optional(),
-	delegatedBy: z.object({
-		expert: expertSchema,
-		toolCallId: z.string().min(1).max(maxCheckpointToolCallIdLength),
-		toolName: z.string().min(1).max(maxSkillToolNameLength),
-		checkpointId: cuidSchema,
-		runId: cuidSchema
-	}).optional(),
-	inputMessages: z.array(z.union([
-		instructionMessageSchema,
-		userMessageSchema,
-		toolMessageSchema
-	])).optional(),
-	messages: z.array(messageSchema),
-	newMessages: z.array(messageSchema),
-	toolCalls: z.array(toolCallSchema).optional(),
-	toolResults: z.array(toolResultSchema).optional(),
-	pendingToolCalls: z.array(toolCallSchema).optional(),
-	partialToolResults: z.array(toolResultSchema).optional(),
-	usage: usageSchema,
-	contextWindow: z.number().int().min(0).optional(),
-	contextWindowUsage: z.number().int().min(0).optional(),
-	error: z.object({
-		name: z.string().min(1),
-		message: z.string().min(1),
-		statusCode: z.number().int().min(100).max(599).optional(),
-		isRetryable: z.boolean()
-	}).optional(),
-	retryCount: z.number().int().min(0).optional(),
-	startedAt: datetimeSchema,
-	finishedAt: datetimeSchema.optional()
-});
-
-//#endregion
-//#region ../models/src/api/jobs/checkpoints/create.ts
-/**
-* Request checkpoint schema - `id` and `runId` are omitted because:
-* - `id` is server-generated (CUID)
-* - `runId` is optional in request, server will use job's run ID
-*/
-const requestCheckpointSchema = perstackCheckpointSchema.omit({
-	id: true,
-	runId: true
-}).extend({ runId: z.string().optional() });
-const request$8 = {
-	params: z.object({ jobId: cuidSchema }),
-	body: z.object({
-		checkpoint: requestCheckpointSchema,
-		step: stepSchema
-	})
-};
-const response$8 = z.object({ data: z.object({ checkpoint: apiCheckpointSchema }) });
-
-//#endregion
-//#region ../models/src/api/jobs/checkpoints/getAll.ts
-const request$7 = {
-	params: z.object({ jobId: cuidSchema }),
-	query: z.object({
-		filter: z.string().min(1).max(256).optional(),
-		sort: z.enum(["createdAt", "updatedAt"]).optional(),
-		order: z.enum(["asc", "desc"]).optional(),
-		take: z.coerce.number().min(1).max(100).default(20),
-		skip: z.coerce.number().min(0).default(0)
-	})
-};
-const response$7 = z.object({
-	data: z.object({ checkpoints: z.array(apiCheckpointSchema) }),
-	meta: paginationMeta
-});
-
 //#endregion
 //#region ../support-models/src/index.ts
 const anthropicSupportModels = [
@@ -1198,8 +1100,8 @@ const jobStatusSchema = z.enum([
 const modelNames = getSupportModelNames();
 const firstModel = modelNames[0];
 if (firstModel === void 0) throw new Error("No support models available");
-const modelEnum = z.enum([firstModel, ...modelNames.slice(1)]);
-const jobSchema = z.object({
+const jobModelSchema = z.enum([firstModel, ...modelNames.slice(1)]);
+const jobBaseSchema = z.object({
 	type: z.literal("job"),
 	id: cuidSchema,
 	organizationId: cuidSchema,
@@ -1207,12 +1109,12 @@ const jobSchema = z.object({
 	createdAt: datetimeSchema,
 	updatedAt: datetimeSchema,
 	status: jobStatusSchema,
+	currentExecutionId: cuidSchema.optional(),
 	coordinatorExpertKey: expertKeyFieldSchema,
 	query: z.string().min(1).max(maxExpertJobQueryLength).optional(),
 	expert: expertWithMetadataSchema,
-	expertDraftRefId: cuidSchema.optional(),
 	provider: providerSchema,
-	model: modelEnum,
+	model: jobModelSchema,
 	reasoningBudget: reasoningBudgetSchema,
 	runtimeVersion: runtimeVersionSchema,
 	maxSteps: z.number().int().min(1),
@@ -1223,22 +1125,30 @@ const jobSchema = z.object({
 	usage: usageSchema,
 	lastActivity: activityOrGroupSchema.nullable().optional()
 });
+const publishedJobSchema = jobBaseSchema.extend({
+	expertVersionId: cuidSchema,
+	expertDraftRefId: z.undefined()
+});
+const draftJobSchema = jobBaseSchema.extend({
+	expertVersionId: z.undefined(),
+	expertDraftRefId: cuidSchema
+});
+const jobSchema = z.union([publishedJobSchema, draftJobSchema]);
 
 //#endregion
 //#region ../models/src/api/jobs/continue.ts
-const request$6 = {
+const request$7 = {
 	params: z.object({ jobId: cuidSchema }),
 	body: z.object({
 		query: z.string().min(1).max(maxExpertJobQueryLength),
-		interactiveToolCallResult: z.boolean().optional(),
 		provider: providerSchema.optional(),
-		model: jobSchema.shape.model.optional(),
+		model: jobModelSchema.optional(),
 		reasoningBudget: reasoningBudgetSchema.optional(),
 		maxSteps: z.coerce.number().optional(),
 		maxRetries: z.coerce.number().optional()
 	})
 };
-const response$6 = z.object({ data: z.object({ job: jobSchema }) });
+const response$7 = z.object({ data: z.object({ job: jobSchema }) });
 
 //#endregion
 //#region ../models/src/api/jobs/create.ts
@@ -1246,12 +1156,12 @@ const baseBodySchema = z.object({
 	applicationId: cuidSchema.describe("Application ID to create the job in"),
 	query: z.string().min(1).max(maxExpertJobQueryLength),
 	provider: providerSchema,
-	model: jobSchema.shape.model.optional(),
+	model: jobModelSchema.optional(),
 	reasoningBudget: reasoningBudgetSchema.optional(),
 	maxSteps: z.coerce.number().optional(),
 	maxRetries: z.coerce.number().optional()
 });
-const request$5 = { body: baseBodySchema.extend({
+const request$6 = { body: baseBodySchema.extend({
 	expertKey: expertKeyFieldSchema.optional(),
 	draftRefId: cuidSchema.describe("Draft ref ID to run the job with").optional()
 }).refine((data) => {
@@ -1259,11 +1169,11 @@ const request$5 = { body: baseBodySchema.extend({
 	const hasDraftRefId = data.draftRefId !== void 0;
 	return hasExpertKey && !hasDraftRefId || !hasExpertKey && hasDraftRefId;
 }, { message: "Either expertKey or draftRefId must be provided, but not both" }) };
-const response$5 = z.object({ data: z.object({ job: jobSchema }) });
+const response$6 = z.object({ data: z.object({ job: jobSchema }) });
 
 //#endregion
 //#region ../models/src/api/jobs/getAll.ts
-const request$4 = { query: z.object({
+const request$5 = { query: z.object({
 	sort: z.enum(["createdAt", "updatedAt"]).optional(),
 	order: z.enum(["asc", "desc"]).optional(),
 	take: z.coerce.number().min(1).max(100).default(20),
@@ -1274,18 +1184,139 @@ const request$4 = { query: z.object({
 	statuses: z.preprocess((val) => typeof val === "string" ? val.split(",") : val, z.array(jobStatusSchema).optional()),
 	expertKeyFilter: z.string().max(100).optional()
 }) };
-const response$4 = z.object({
+const response$5 = z.object({
 	data: z.object({ jobs: z.array(jobSchema) }),
 	meta: paginationMeta
 });
 
 //#endregion
-//#region ../models/src/api/jobs/update.ts
+//#region ../models/src/domain/checkpoint.ts
+const delegationTargetSchema = z.object({
+	expert: expertSchema,
+	toolCallId: z.string().min(1).max(maxCheckpointToolCallIdLength),
+	toolName: z.string().min(1).max(maxSkillToolNameLength),
+	query: z.string().min(1)
+});
+/**
+* API Checkpoint schema - extended checkpoint format for API responses.
+* Includes additional fields computed from runtime checkpoint and step data:
+* - activities: computed via getActivities() from @perstack/core
+* - inputMessages, newMessages, toolCalls, toolResults: step-related data
+* - expert: full Expert type (with instruction, skills, etc.)
+* - startedAt/finishedAt: ISO string format (runtime uses Unix timestamps)
+*/
+const apiCheckpointSchema = z.object({
+	type: z.literal("checkpoint"),
+	id: cuidSchema,
+	jobId: cuidSchema,
+	runId: cuidSchema,
+	activities: z.array(activityOrGroupSchema),
+	stepNumber: z.number().int().min(1),
+	status: z.enum([
+		"init",
+		"proceeding",
+		"completed",
+		"stoppedByInteractiveTool",
+		"stoppedByDelegate",
+		"stoppedByExceededMaxSteps",
+		"stoppedByError"
+	]),
+	expert: expertSchema,
+	delegateTo: z.array(delegationTargetSchema).optional(),
+	delegatedBy: z.object({
+		expert: expertSchema,
+		toolCallId: z.string().min(1).max(maxCheckpointToolCallIdLength),
+		toolName: z.string().min(1).max(maxSkillToolNameLength),
+		checkpointId: cuidSchema,
+		runId: cuidSchema
+	}).optional(),
+	inputMessages: z.array(z.union([
+		instructionMessageSchema,
+		userMessageSchema,
+		toolMessageSchema
+	])).optional(),
+	messages: z.array(messageSchema),
+	newMessages: z.array(messageSchema),
+	toolCalls: z.array(toolCallSchema).optional(),
+	toolResults: z.array(toolResultSchema).optional(),
+	pendingToolCalls: z.array(toolCallSchema).optional(),
+	partialToolResults: z.array(toolResultSchema).optional(),
+	usage: usageSchema,
+	contextWindow: z.number().int().min(0).optional(),
+	contextWindowUsage: z.number().int().min(0).optional(),
+	error: z.object({
+		name: z.string().min(1),
+		message: z.string().min(1),
+		statusCode: z.number().int().min(100).max(599).optional(),
+		isRetryable: z.boolean()
+	}).optional(),
+	retryCount: z.number().int().min(0).optional(),
+	startedAt: datetimeSchema,
+	finishedAt: datetimeSchema.optional()
+});
+
+//#endregion
+//#region ../models/src/api/jobs/runs/checkpoints/getAll.ts
+const request$4 = {
+	params: z.object({
+		jobId: cuidSchema,
+		runId: cuidSchema
+	}),
+	query: z.object({
+		filter: z.string().min(1).max(256).optional(),
+		sort: z.enum(["createdAt", "updatedAt"]).optional(),
+		order: z.enum(["asc", "desc"]).optional(),
+		take: z.coerce.number().min(1).max(100).default(20),
+		skip: z.coerce.number().min(0).default(0)
+	})
+};
+const response$4 = z.object({
+	data: z.object({ checkpoints: z.array(apiCheckpointSchema) }),
+	meta: paginationMeta
+});
+
+//#endregion
+//#region ../models/src/domain/run.ts
+const runStatusSchema = z.enum([
+	"queued",
+	"processing",
+	"completed",
+	"stoppedByInteractiveTool",
+	"stoppedByDelegate",
+	"stoppedByExceededMaxSteps",
+	"stoppedByError"
+]);
+const runSchema = z.object({
+	type: z.literal("run"),
+	id: cuidSchema,
+	jobId: cuidSchema,
+	executionId: cuidSchema.optional(),
+	parentRunId: cuidSchema.optional(),
+	organizationId: cuidSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	status: runStatusSchema,
+	expertKey: expertKeyFieldSchema,
+	expert: expertWithMetadataSchema,
+	stepNumber: z.number().int().min(0),
+	usage: usageSchema
+});
+
+//#endregion
+//#region ../models/src/api/jobs/runs/getAll.ts
 const request$3 = {
 	params: z.object({ jobId: cuidSchema }),
-	body: z.object({ status: jobStatusSchema })
+	query: z.object({
+		sort: z.enum(["createdAt", "updatedAt"]).optional(),
+		order: z.enum(["asc", "desc"]).optional(),
+		take: z.coerce.number().min(1).max(100).default(20),
+		skip: z.coerce.number().min(0).default(0)
+	})
 };
-const response$3 = z.object({ data: z.object({ job: jobSchema }) });
+const response$3 = z.object({
+	data: z.object({ runs: z.array(runSchema) }),
+	meta: paginationMeta
+});
 
 //#endregion
 //#region ../models/src/domain/providerSetting.ts
@@ -1397,13 +1428,82 @@ const request = {
 const response = z.object({ data: z.object({ providerSetting: providerSettingResponseSchema }) });
 
 //#endregion
-//#region src/endpoints/applications.ts
-const BASE_PATH$5 = "/api/v1/applications";
-function createApplicationsApi(fetcher) {
+//#region src/endpoints/jobs-runs-checkpoints.ts
+function createRunCheckpointsApi(fetcher, basePath) {
+	return {
+		async list(jobId, runId, params, options) {
+			if (params) {
+				const result = request$4.query.safeParse(params);
+				if (!result.success) return {
+					ok: false,
+					error: createValidationError(result.error)
+				};
+			}
+			const queryString = buildQueryString(params);
+			return fetcher.get(`${basePath}/${jobId}/runs/${runId}/checkpoints${queryString}`, options);
+		},
+		async get(jobId, runId, checkpointId, options) {
+			return fetcher.get(`${basePath}/${jobId}/runs/${runId}/checkpoints/${checkpointId}`, options);
+		}
+	};
+}
+
+//#endregion
+//#region src/endpoints/jobs-runs.ts
+function createRunsApi(fetcher, basePath) {
+	return {
+		async list(jobId, params, options) {
+			if (params) {
+				const result = request$3.query.safeParse(params);
+				if (!result.success) return {
+					ok: false,
+					error: createValidationError(result.error)
+				};
+			}
+			const queryString = buildQueryString(params);
+			return fetcher.get(`${basePath}/${jobId}/runs${queryString}`, options);
+		},
+		async get(jobId, runId, options) {
+			return fetcher.get(`${basePath}/${jobId}/runs/${runId}`, options);
+		},
+		checkpoints: createRunCheckpointsApi(fetcher, basePath)
+	};
+}
+
+//#endregion
+//#region src/endpoints/jobs.ts
+const BASE_PATH$5 = "/api/v1/jobs";
+/**
+* Error thrown when stream ends abnormally.
+*/
+var StreamError = class extends Error {
+	constructor(type, jobId, message) {
+		super(message ?? `Stream error: ${type}`);
+		this.type = type;
+		this.jobId = jobId;
+		this.name = "StreamError";
+	}
+};
+/**
+* Error thrown when stream connection or reading fails.
+*/
+var StreamConnectionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "StreamConnectionError";
+	}
+};
+function isErrorEventData(data) {
+	return typeof data === "object" && data !== null && "type" in data && typeof data.type === "string" && "jobId" in data && typeof data.jobId === "string";
+}
+function isCompleteEventData(data) {
+	return typeof data === "object" && data !== null && "status" in data && typeof data.status === "string" && "jobId" in data && typeof data.jobId === "string";
+}
+function createJobsApi(fetcher) {
 	return {
 		async list(params, options) {
 			if (params) {
-				const result = request$17.query.safeParse(params);
+				const result = request$5.query.safeParse(params);
 				if (!result.success) return {
 					ok: false,
 					error: createValidationError(result.error)
@@ -1415,110 +1515,166 @@ function createApplicationsApi(fetcher) {
 		async get(id, options) {
 			return fetcher.get(`${BASE_PATH$5}/${id}`, options);
 		},
-		async create(input, options) {
-			const result = request$18.body.safeParse(input);
+		async start(input, options) {
+			const result = request$6.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
 			return fetcher.post(BASE_PATH$5, input, options);
 		},
+		async continue(id, input, options) {
+			const result = request$7.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(`${BASE_PATH$5}/${id}/continue`, input, options);
+		},
+		async cancel(id, options) {
+			return fetcher.post(`${BASE_PATH$5}/${id}/cancel`, {}, options);
+		},
+		async *stream(id, options) {
+			const result = await fetcher.getStream(`${BASE_PATH$5}/${id}/stream`, options);
+			if (!result.ok) throw new StreamConnectionError(result.error.message);
+			const reader = result.data.getReader();
+			try {
+				for await (const sseEvent of parseSSEEvents(reader)) if (sseEvent.event === "message") yield sseEvent.data;
+				else if (sseEvent.event === "error" && isErrorEventData(sseEvent.data)) throw new StreamError(sseEvent.data.type, sseEvent.data.jobId, sseEvent.data.message);
+				else if (sseEvent.event === "complete" && isCompleteEventData(sseEvent.data)) return;
+			} catch (error) {
+				if (error instanceof StreamError || error instanceof StreamConnectionError) throw error;
+				if (error instanceof DOMException && error.name === "AbortError") throw error;
+				throw new StreamConnectionError(error instanceof Error ? error.message : "Stream read error");
+			}
+		},
+		runs: createRunsApi(fetcher, BASE_PATH$5)
+	};
+}
+
+//#endregion
+//#region src/endpoints/applications.ts
+const BASE_PATH$4 = "/api/v1/applications";
+function createApplicationsApi(fetcher) {
+	return {
+		async list(params, options) {
+			if (params) {
+				const result = request$16.query.safeParse(params);
+				if (!result.success) return {
+					ok: false,
+					error: createValidationError(result.error)
+				};
+			}
+			const queryString = buildQueryString(params);
+			return fetcher.get(`${BASE_PATH$4}${queryString}`, options);
+		},
+		async get(id, options) {
+			return fetcher.get(`${BASE_PATH$4}/${id}`, options);
+		},
+		async create(input, options) {
+			const result = request$17.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(BASE_PATH$4, input, options);
+		},
 		async update(id, input, options) {
-			const result = request$16.body.safeParse(input);
+			const result = request$15.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(`${BASE_PATH$5}/${id}`, input, options);
+			return fetcher.post(`${BASE_PATH$4}/${id}`, input, options);
 		},
 		async delete(id, options) {
-			return fetcher.delete(`${BASE_PATH$5}/${id}`, options);
+			return fetcher.delete(`${BASE_PATH$4}/${id}`, options);
 		}
 	};
 }
 
 //#endregion
 //#region src/endpoints/env-secrets.ts
-const BASE_PATH$4 = "/api/v1/env/secrets";
+const BASE_PATH$3 = "/api/v1/env/secrets";
 function createSecretsApi(fetcher) {
 	return {
 		async list(params, options) {
 			if (params) {
-				const result = request$14.query.safeParse(params);
+				const result = request$13.query.safeParse(params);
 				if (!result.success) return {
 					ok: false,
 					error: createValidationError(result.error)
 				};
 			}
 			const queryString = buildQueryString(params);
-			return fetcher.get(`${BASE_PATH$4}${queryString}`, options);
+			return fetcher.get(`${BASE_PATH$3}${queryString}`, options);
 		},
 		async get(name, options) {
 			const encodedName = encodeURIComponent(name);
-			return fetcher.get(`${BASE_PATH$4}/${encodedName}`, options);
+			return fetcher.get(`${BASE_PATH$3}/${encodedName}`, options);
 		},
 		async create(input, options) {
-			const result = request$15.body.safeParse(input);
+			const result = request$14.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(BASE_PATH$4, input, options);
+			return fetcher.post(BASE_PATH$3, input, options);
 		},
 		async update(name, input, options) {
-			const result = request$13.body.safeParse(input);
+			const result = request$12.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
 			const encodedName = encodeURIComponent(name);
-			return fetcher.put(`${BASE_PATH$4}/${encodedName}`, input, options);
+			return fetcher.put(`${BASE_PATH$3}/${encodedName}`, input, options);
 		},
 		async delete(name, options) {
 			const encodedName = encodeURIComponent(name);
-			return fetcher.deleteNoContent(`${BASE_PATH$4}/${encodedName}`, options);
+			return fetcher.deleteNoContent(`${BASE_PATH$3}/${encodedName}`, options);
 		}
 	};
 }
 
 //#endregion
 //#region src/endpoints/env-variables.ts
-const BASE_PATH$3 = "/api/v1/env/variables";
+const BASE_PATH$2 = "/api/v1/env/variables";
 function createVariablesApi(fetcher) {
 	return {
 		async list(params, options) {
-			const result = request$11.query.safeParse(params);
+			const result = request$10.query.safeParse(params);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
 			const queryString = buildQueryString(params);
-			return fetcher.get(`${BASE_PATH$3}${queryString}`, options);
+			return fetcher.get(`${BASE_PATH$2}${queryString}`, options);
 		},
 		async get(name, options) {
 			const encodedName = encodeURIComponent(name);
-			return fetcher.get(`${BASE_PATH$3}/${encodedName}`, options);
+			return fetcher.get(`${BASE_PATH$2}/${encodedName}`, options);
 		},
 		async create(input, options) {
-			const result = request$12.body.safeParse(input);
+			const result = request$11.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(BASE_PATH$3, input, options);
+			return fetcher.post(BASE_PATH$2, input, options);
 		},
 		async update(name, input, options) {
-			const result = request$10.body.safeParse(input);
+			const result = request$9.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
 			const encodedName = encodeURIComponent(name);
-			return fetcher.put(`${BASE_PATH$3}/${encodedName}`, input, options);
+			return fetcher.put(`${BASE_PATH$2}/${encodedName}`, input, options);
 		},
 		async delete(name, options) {
 			const encodedName = encodeURIComponent(name);
-			return fetcher.deleteNoContent(`${BASE_PATH$3}/${encodedName}`, options);
+			return fetcher.deleteNoContent(`${BASE_PATH$2}/${encodedName}`, options);
 		}
 	};
 }
@@ -1543,198 +1699,44 @@ function createVersionsApi(fetcher, basePath) {
 
 //#endregion
 //#region src/endpoints/experts.ts
-const BASE_PATH$2 = "/api/v1/experts";
+const BASE_PATH$1 = "/api/v1/experts";
 function createExpertsApi(fetcher) {
 	return {
 		async list(params, options) {
 			if (params) {
-				const result = request$9.query.safeParse(params);
+				const result = request$8.query.safeParse(params);
 				if (!result.success) return {
 					ok: false,
 					error: createValidationError(result.error)
 				};
 			}
 			const queryString = buildQueryString(params);
-			return fetcher.get(`${BASE_PATH$2}${queryString}`, options);
+			return fetcher.get(`${BASE_PATH$1}${queryString}`, options);
 		},
 		async get(key, options) {
 			const encodedKey = encodeURIComponent(key);
-			return fetcher.get(`${BASE_PATH$2}/${encodedKey}`, options);
+			return fetcher.get(`${BASE_PATH$1}/${encodedKey}`, options);
 		},
 		async getFeatured(options) {
-			return fetcher.get(`${BASE_PATH$2}/featured`, options);
+			return fetcher.get(`${BASE_PATH$1}/featured`, options);
 		},
 		async getMeta(key, options) {
 			const encodedKey = encodeURIComponent(key);
-			return fetcher.get(`${BASE_PATH$2}/${encodedKey}/meta`, options);
+			return fetcher.get(`${BASE_PATH$1}/${encodedKey}/meta`, options);
 		},
 		async publish(scopeName, options) {
 			const encodedScopeName = encodeURIComponent(scopeName);
-			return fetcher.post(`${BASE_PATH$2}/${encodedScopeName}/publish`, {}, options);
+			return fetcher.post(`${BASE_PATH$1}/${encodedScopeName}/publish`, {}, options);
 		},
 		async unpublish(scopeName, options) {
 			const encodedScopeName = encodeURIComponent(scopeName);
-			return fetcher.post(`${BASE_PATH$2}/${encodedScopeName}/unpublish`, {}, options);
+			return fetcher.post(`${BASE_PATH$1}/${encodedScopeName}/unpublish`, {}, options);
 		},
 		async yank(key, options) {
 			const encodedKey = encodeURIComponent(key);
-			return fetcher.delete(`${BASE_PATH$2}/${encodedKey}`, options);
-		},
-		versions: createVersionsApi(fetcher, BASE_PATH$2)
-	};
-}
-
-//#endregion
-//#region src/endpoints/jobs-checkpoints.ts
-function isErrorEventData(data) {
-	return typeof data === "object" && data !== null && "type" in data && typeof data.type === "string" && "jobId" in data && typeof data.jobId === "string";
-}
-function isCompleteEventData(data) {
-	return typeof data === "object" && data !== null && "status" in data && typeof data.status === "string" && "jobId" in data && typeof data.jobId === "string";
-}
-function createCheckpointsApi(fetcher, basePath) {
-	return {
-		async list(jobId, params, options) {
-			if (params) {
-				const result = request$7.query.safeParse(params);
-				if (!result.success) return {
-					ok: false,
-					error: createValidationError(result.error)
-				};
-			}
-			const queryString = buildQueryString(params);
-			return fetcher.get(`${basePath}/${jobId}/checkpoints${queryString}`, options);
-		},
-		async get(jobId, checkpointId, options) {
-			return fetcher.get(`${basePath}/${jobId}/checkpoints/${checkpointId}`, options);
-		},
-		async create(jobId, input, options) {
-			const result = request$8.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(`${basePath}/${jobId}/checkpoints`, input, options);
-		},
-		async *stream(jobId, options) {
-			const result = await fetcher.getStream(`${basePath}/${jobId}/checkpoints/stream`, options);
-			if (!result.ok) {
-				yield {
-					ok: false,
-					error: result.error
-				};
-				return;
-			}
-			const reader = result.data.getReader();
-			try {
-				for await (const checkpoint of parseSSE(reader)) yield {
-					ok: true,
-					data: checkpoint
-				};
-			} catch (error) {
-				if (error instanceof DOMException && error.name === "AbortError") yield {
-					ok: false,
-					error: createAbortError()
-				};
-				else yield {
-					ok: false,
-					error: createNetworkError(error)
-				};
-			}
-		},
-		async *streamEvents(jobId, options) {
-			const result = await fetcher.getStream(`${basePath}/${jobId}/checkpoints/stream`, options);
-			if (!result.ok) {
-				yield {
-					ok: false,
-					error: result.error
-				};
-				return;
-			}
-			const reader = result.data.getReader();
-			try {
-				for await (const sseEvent of parseSSEEvents(reader)) if (sseEvent.event === "message") yield {
-					ok: true,
-					data: {
-						event: "message",
-						data: sseEvent.data
-					}
-				};
-				else if (sseEvent.event === "error" && isErrorEventData(sseEvent.data)) yield {
-					ok: true,
-					data: {
-						event: "error",
-						data: sseEvent.data
-					}
-				};
-				else if (sseEvent.event === "complete" && isCompleteEventData(sseEvent.data)) yield {
-					ok: true,
-					data: {
-						event: "complete",
-						data: sseEvent.data
-					}
-				};
-			} catch (error) {
-				if (error instanceof DOMException && error.name === "AbortError") yield {
-					ok: false,
-					error: createAbortError()
-				};
-				else yield {
-					ok: false,
-					error: createNetworkError(error)
-				};
-			}
-		}
-	};
-}
-
-//#endregion
-//#region src/endpoints/jobs.ts
-const BASE_PATH$1 = "/api/v1/jobs";
-function createJobsApi(fetcher) {
-	return {
-		async list(params, options) {
-			if (params) {
-				const result = request$4.query.safeParse(params);
-				if (!result.success) return {
-					ok: false,
-					error: createValidationError(result.error)
-				};
-			}
-			const queryString = buildQueryString(params);
-			return fetcher.get(`${BASE_PATH$1}${queryString}`, options);
-		},
-		async get(id, options) {
-			return fetcher.get(`${BASE_PATH$1}/${id}`, options);
-		},
-		async start(input, options) {
-			const result = request$5.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(BASE_PATH$1, input, options);
-		},
-		async update(id, input, options) {
-			const result = request$3.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(`${BASE_PATH$1}/${id}`, input, options);
-		},
-		async continue(id, input, options) {
-			const result = request$6.body.safeParse(input);
-			if (!result.success) return {
-				ok: false,
-				error: createValidationError(result.error)
-			};
-			return fetcher.post(`${BASE_PATH$1}/${id}/continue`, input, options);
-		},
-		async cancel(id, options) {
-			return fetcher.post(`${BASE_PATH$1}/${id}/cancel`, {}, options);
+			return fetcher.delete(`${BASE_PATH$1}/${encodedKey}`, options);
 		},
-		checkpoints: createCheckpointsApi(fetcher, BASE_PATH$1)
+		versions: createVersionsApi(fetcher, BASE_PATH$1)
 	};
 }
 
@@ -1806,5 +1808,5 @@ function createApiClient(config) {
 }
 
 //#endregion
-export { buildAuthHeaders, buildQueryString, createAbortError, createApiClient, createFetcher, createHttpError, createNetworkError, createTimeoutError, createValidationError, handleHttpError, isAbortError, isClientError, isHttpError, isNetworkError, isTimeoutError, isValidationError, matchExperts, matchOperations, matchWildcard, parseApiKeyPermissions, parseSSE, parseSSEEvents, stringifyApiKeyPermissions };
+export { StreamConnectionError, StreamError, buildAuthHeaders, buildQueryString, createAbortError, createApiClient, createFetcher, createHttpError, createNetworkError, createTimeoutError, createValidationError, handleHttpError, isAbortError, isClientError, isHttpError, isNetworkError, isTimeoutError, isValidationError, matchExperts, matchOperations, matchWildcard, parseApiKeyPermissions, parseSSE, parseSSEEvents, stringifyApiKeyPermissions };
 //# sourceMappingURL=index.mjs.map