@perstack/api-client 0.0.47 → 0.0.48

package/dist/{index.mjs → bundle.mjs}

@@ -5,7 +5,10 @@ import { activityOrGroupSchema, checkpointSchema as perstackCheckpointSchema, in
 //#region ../constants/index.ts
 const organizationNameRegex = /^[a-z0-9][a-z0-9_.-]*$/;
 const maxOrganizationNameLength = 128;
+const applicationNameRegex = /^[a-z0-9][a-z0-9_.-]*$/;
 const maxApplicationNameLength = 255;
+const maxVariableValueLength = 65536;
+const maxSecretValueLength = 65536;
 const expertKeyRegex = /^((?:@[a-z0-9][a-z0-9_.-]*\/)?[a-z0-9][a-z0-9_.-]*)(?:@((?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?)|@([a-z0-9][a-z0-9_.-]*))?$/;
 const expertNameRegex = /^(@[a-z0-9][a-z0-9_-]*\/)?[a-z0-9][a-z0-9_-]*$/;
 const scopeNameRegex = /^[a-z0-9][a-z0-9_-]*$/;
@@ -53,7 +56,7 @@ const providerSchema = z.enum([
 	"amazon-bedrock",
 	"google-vertex"
 ]);
-const datetimeSchema = z.string().datetime();
+const datetimeSchema = z.string().datetime({ offset: true });
 const expertKeyFieldSchema = z.string().min(1).max(maxExpertKeyLength).regex(expertKeyRegex);
 const expertNameFieldSchema = z.string().min(1).max(maxExpertNameLength).regex(expertNameRegex);
 const expertVersionFieldSchema = z.string().min(1).max(maxExpertVersionTagLength).regex(expertVersionRegex);
@@ -98,41 +101,84 @@ const organizationSchema = z.object({
 });
 
 //#endregion
-//#region ../models/src/domain/application.ts
-const applicationNameSchema = z.string().min(1).max(maxApplicationNameLength);
-const applicationStatusSchema = z.enum([
+//#region ../models/src/domain/user.ts
+const userStatusSchema = z.enum([
 	"active",
 	"inactive",
 	"deleted"
 ]);
-const applicationSchema = z.object({
-	type: z.literal("application"),
+const userSchema = z.object({
+	type: z.literal("user"),
 	id: cuidSchema,
-	organizationId: cuidSchema,
-	organization: organizationSchema,
+	email: z.string().email(),
+	emailVerified: z.boolean(),
+	name: z.string().min(1).max(255).optional(),
+	image: z.string().url().optional(),
+	status: userStatusSchema,
+	organizations: z.array(organizationSchema),
 	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema,
-	name: applicationNameSchema,
-	status: applicationStatusSchema
+	updatedAt: datetimeSchema
 });
 
 //#endregion
-//#region ../models/src/api/applications/create.ts
-const request$38 = { body: z.object({
-	name: applicationNameSchema,
-	applicationGroupId: cuidSchema.optional()
-}) };
-const response$40 = z.object({ data: z.object({ application: applicationSchema }) });
+//#region ../models/src/domain/apiKey.ts
+const apiKeyPermissionsSchema = z.object({
+	operations: z.array(z.string()),
+	experts: z.union([z.array(z.string()), z.literal("*")]).optional()
+});
+const apiKeySchema = z.object({
+	type: z.literal("apiKey"),
+	id: cuidSchema,
+	name: z.string().min(1).max(255).optional(),
+	start: z.string().optional(),
+	prefix: z.string().optional(),
+	user: userSchema.optional(),
+	enabled: z.boolean(),
+	expiresAt: datetimeSchema.optional(),
+	permissions: apiKeyPermissionsSchema.optional(),
+	lastRequest: datetimeSchema.optional(),
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema
+});
+const createApiKeyInputSchema = z.object({
+	name: z.string().min(1).max(255).optional(),
+	organizationId: cuidSchema,
+	operations: z.array(z.string()).optional(),
+	experts: z.union([z.array(z.string()), z.literal("*")]).optional(),
+	expiresIn: z.number().min(60).optional()
+});
+const createApiKeyResponseSchema = z.object({
+	apiKey: apiKeySchema,
+	key: z.string()
+});
 
 //#endregion
-//#region ../models/src/api/applications/delete.ts
-const request$37 = { params: z.object({ applicationId: cuidSchema }) };
-const response$39 = z.object({ data: z.object({ application: applicationSchema }) });
+//#region ../models/src/api/api-keys/create.ts
+const request$49 = { body: z.object({
+	name: z.string().min(1).max(255).optional(),
+	operations: z.array(z.string()).optional(),
+	experts: z.union([z.array(z.string()), z.literal("*")]).optional(),
+	wildcardApplicationAccess: z.boolean().optional(),
+	applicationIds: z.array(cuidSchema).optional(),
+	expiresIn: z.number().min(60).optional()
+}) };
+const response$51 = z.object({ data: z.object({
+	apiKey: apiKeySchema.extend({
+		permissions: apiKeyPermissionsSchema.optional(),
+		wildcardApplicationAccess: z.boolean(),
+		applicationIds: z.array(cuidSchema)
+	}),
+	key: z.string()
+}) });
 
 //#endregion
-//#region ../models/src/api/applications/get.ts
-const request$36 = { params: z.object({ applicationId: cuidSchema }) };
-const response$38 = z.object({ data: z.object({ application: applicationSchema }) });
+//#region ../models/src/api/api-keys/get.ts
+const request$48 = { params: z.object({ apiKeyId: cuidSchema }) };
+const response$50 = z.object({ data: z.object({ apiKey: apiKeySchema.extend({
+	permissions: apiKeyPermissionsSchema.optional(),
+	wildcardApplicationAccess: z.boolean(),
+	applicationIds: z.array(cuidSchema)
+}) }) });
 
 //#endregion
 //#region ../../node_modules/ts-dedent/dist/index.js
@@ -219,9 +265,73 @@ const errorUnauthorizedFlexible = z.object({
 	reason: z.string()
 }).describe("Unauthorized");
 
+//#endregion
+//#region ../models/src/api/api-keys/getAll.ts
+const request$47 = { query: z.object({
+	take: z.coerce.number().min(1).max(100).default(20),
+	skip: z.coerce.number().min(0).default(0)
+}) };
+const apiKeyWithApplicationsSchema = apiKeySchema.extend({
+	permissions: apiKeyPermissionsSchema.optional(),
+	wildcardApplicationAccess: z.boolean(),
+	applicationIds: z.array(cuidSchema)
+});
+const response$49 = z.object({
+	data: z.object({ apiKeys: z.array(apiKeyWithApplicationsSchema) }),
+	meta: paginationMeta
+});
+
+//#endregion
+//#region ../models/src/api/api-keys/revoke.ts
+const request$46 = { params: z.object({ apiKeyId: cuidSchema }) };
+const response$48 = z.object({ data: z.object({ apiKey: apiKeySchema.extend({
+	permissions: apiKeyPermissionsSchema.optional(),
+	wildcardApplicationAccess: z.boolean(),
+	applicationIds: z.array(cuidSchema)
+}) }) });
+
+//#endregion
+//#region ../models/src/domain/application.ts
+const applicationNameSchema = z.string().min(1).max(maxApplicationNameLength).regex(applicationNameRegex);
+const applicationStatusSchema = z.enum([
+	"active",
+	"inactive",
+	"deleted"
+]);
+const applicationSchema = z.object({
+	type: z.literal("application"),
+	id: cuidSchema,
+	organizationId: cuidSchema,
+	organization: organizationSchema,
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	name: applicationNameSchema,
+	status: applicationStatusSchema,
+	expertCount: z.number().describe("Number of expert draft scopes associated with this application").optional(),
+	providers: z.array(providerSchema).describe("List of configured providers for this application").optional()
+});
+
+//#endregion
+//#region ../models/src/api/applications/create.ts
+const request$45 = { body: z.object({
+	name: applicationNameSchema,
+	applicationGroupId: cuidSchema.optional()
+}) };
+const response$47 = z.object({ data: z.object({ application: applicationSchema }) });
+
+//#endregion
+//#region ../models/src/api/applications/delete.ts
+const request$44 = { params: z.object({ applicationId: cuidSchema }) };
+const response$46 = z.object({ data: z.object({ application: applicationSchema }) });
+
+//#endregion
+//#region ../models/src/api/applications/get.ts
+const request$43 = { params: z.object({ applicationId: cuidSchema }) };
+const response$45 = z.object({ data: z.object({ application: applicationSchema }) });
+
 //#endregion
 //#region ../models/src/api/applications/getAll.ts
-const request$35 = { query: z.object({
+const request$42 = { query: z.object({
 	name: z.union([z.string(), z.array(z.string())]).optional().transform((v) => Array.isArray(v) ? v.join(",") : v),
 	sort: z.enum([
 		"name",
@@ -229,29 +339,29 @@ const request$35 = { query: z.object({
 		"updatedAt"
 	]).optional(),
 	order: z.enum(["asc", "desc"]).optional(),
-	take: z.coerce.number().min(1).max(100).default(100),
+	take: z.coerce.number().min(1).max(100).default(20),
 	skip: z.coerce.number().min(0).default(0)
 }) };
-const response$37 = z.object({
+const response$44 = z.object({
 	data: z.object({ applications: z.array(applicationSchema) }),
 	meta: paginationMeta
 });
 
 //#endregion
 //#region ../models/src/api/applications/update.ts
-const request$34 = {
+const request$41 = {
 	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$36 = z.object({ data: z.object({ application: applicationSchema }) });
+const response$43 = z.object({ data: z.object({ application: applicationSchema }) });
 
 //#endregion
 //#region ../models/src/domain/secret.ts
 const secretNameSchema = z.string().min(1, "Secret name is required").max(255, "Secret name must be 255 characters or less").regex(/^[A-Z][A-Z0-9_]*$/, "Secret name must start with uppercase letter and contain only uppercase letters, numbers, and underscores");
-const secretValueSchema = z.string().min(1, "Secret value is required");
+const secretValueSchema = z.string().min(1, "Secret value is required").max(maxSecretValueLength);
 const secretMetadataSchema = z.object({
 	name: z.string(),
 	createdAt: datetimeSchema,
@@ -268,49 +378,49 @@ const secretSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/env/secrets/create.ts
-const request$33 = { body: z.object({
+const request$40 = { body: z.object({
 	applicationId: cuidSchema,
 	name: secretNameSchema,
 	value: secretValueSchema
 }) };
-const response$35 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
+const response$42 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
 
 //#endregion
 //#region ../models/src/api/env/secrets/delete.ts
-const request$32 = {
+const request$39 = {
 	params: z.object({ name: z.string().min(1) }),
 	query: z.object({ applicationId: cuidSchema })
 };
-const response$34 = z.null();
+const response$41 = z.null();
 
 //#endregion
 //#region ../models/src/api/env/secrets/get.ts
-const request$31 = {
+const request$38 = {
 	params: z.object({ name: z.string().min(1) }),
 	query: z.object({ applicationId: cuidSchema })
 };
-const response$33 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
+const response$40 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
 
 //#endregion
 //#region ../models/src/api/env/secrets/getAll.ts
-const request$30 = { query: z.object({ applicationId: cuidSchema.optional() }) };
-const response$32 = z.object({ data: z.object({ secrets: z.array(secretMetadataSchema) }) });
+const request$37 = { query: z.object({ applicationId: cuidSchema.optional() }) };
+const response$39 = z.object({ data: z.object({ secrets: z.array(secretMetadataSchema) }) });
 
 //#endregion
 //#region ../models/src/api/env/secrets/update.ts
-const request$29 = {
+const request$36 = {
 	params: z.object({ name: z.string().min(1) }),
 	body: z.object({
 		applicationId: cuidSchema,
 		value: secretValueSchema
 	})
 };
-const response$31 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
+const response$38 = z.object({ data: z.object({ secret: secretMetadataSchema }) });
 
 //#endregion
 //#region ../models/src/domain/variable.ts
-const variableNameSchema = z.string().min(1).max(255).regex(/^[A-Z_][A-Z0-9_]*$/, "Variable name must start with uppercase letter or underscore, and contain only uppercase letters, digits, and underscores");
-const variableValueSchema = z.string();
+const variableNameSchema = z.string().min(1).max(255).regex(/^[A-Z][A-Z0-9_]*$/, "Variable name must start with uppercase letter and contain only uppercase letters, digits, and underscores");
+const variableValueSchema = z.string().max(maxVariableValueLength);
 const variableSchema = z.object({
 	type: z.literal("variable"),
 	id: cuidSchema,
@@ -329,44 +439,44 @@ const variableResponseSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/env/variables/create.ts
-const request$28 = { body: z.object({
+const request$35 = { body: z.object({
 	applicationId: cuidSchema,
 	name: variableNameSchema,
 	value: variableValueSchema
 }) };
-const response$30 = z.object({ data: z.object({ variable: variableResponseSchema }) });
+const response$37 = z.object({ data: z.object({ variable: variableResponseSchema }) });
 
 //#endregion
 //#region ../models/src/api/env/variables/delete.ts
-const request$27 = {
+const request$34 = {
 	params: z.object({ name: z.string().min(1) }),
 	query: z.object({ applicationId: cuidSchema })
 };
-const response$29 = z.null();
+const response$36 = z.null();
 
 //#endregion
 //#region ../models/src/api/env/variables/get.ts
-const request$26 = {
+const request$33 = {
 	params: z.object({ name: z.string().min(1) }),
 	query: z.object({ applicationId: cuidSchema })
 };
-const response$28 = z.object({ data: z.object({ variable: variableResponseSchema }) });
+const response$35 = z.object({ data: z.object({ variable: variableResponseSchema }) });
 
 //#endregion
 //#region ../models/src/api/env/variables/getAll.ts
-const request$25 = { query: z.object({ applicationId: cuidSchema }) };
-const response$27 = z.object({ data: z.object({ variables: z.array(variableResponseSchema) }) });
+const request$32 = { query: z.object({ applicationId: cuidSchema }) };
+const response$34 = z.object({ data: z.object({ variables: z.array(variableResponseSchema) }) });
 
 //#endregion
 //#region ../models/src/api/env/variables/update.ts
-const request$24 = {
+const request$31 = {
 	params: z.object({ name: z.string().min(1) }),
 	body: z.object({
 		applicationId: cuidSchema,
 		value: variableValueSchema
 	})
 };
-const response$26 = z.object({ data: z.object({ variable: variableResponseSchema }) });
+const response$33 = z.object({ data: z.object({ variable: variableResponseSchema }) });
 
 //#endregion
 //#region ../models/src/domain/expertScope.ts
@@ -507,8 +617,8 @@ const expertDefinitionSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/experts/delete.ts
-const request$23 = { params: z.object({ scopeName: scopeNameRefSchema }) };
-const response$25 = z.object({ data: expertMetadataSchema.extend({
+const request$30 = { params: z.object({ scopeName: scopeNameRefSchema }) };
+const response$32 = z.object({ data: expertMetadataSchema.extend({
 	yanked: z.literal(true),
 	latestTagUpdated: z.boolean()
 }) });
@@ -554,14 +664,14 @@ const expertDefinitionContentSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/experts/drafts/create.ts
-const request$22 = {
+const request$29 = {
 	params: z.object({ scopeName: scopeNameSchema }),
 	body: z.object({
 		applicationId: cuidSchema,
 		experts: z.array(expertSchema)
 	})
 };
-const response$24 = z.object({ data: z.object({
+const response$31 = z.object({ data: z.object({
 	scope: expertDraftScopeSchema,
 	draftRef: expertDraftRefSchema,
 	definition: expertDefinitionContentSchema
@@ -569,22 +679,22 @@ const response$24 = z.object({ data: z.object({
 
 //#endregion
 //#region ../models/src/api/experts/drafts/delete.ts
-const request$21 = { params: z.object({
+const request$28 = { params: z.object({
 	scopeName: scopeNameSchema,
 	draftRef: expertDraftRefSchema.shape.id
 }) };
-const response$23 = z.object({ data: z.object({
+const response$30 = z.object({ data: z.object({
 	deleted: z.boolean(),
 	draftRef: z.string()
 }) });
 
 //#endregion
 //#region ../models/src/api/experts/drafts/get.ts
-const request$20 = { params: z.object({
+const request$27 = { params: z.object({
 	scopeName: scopeNameSchema,
 	draftRef: expertDraftRefSchema.shape.id
 }) };
-const response$22 = z.object({ data: z.object({
+const response$29 = z.object({ data: z.object({
 	scope: expertDraftScopeSchema,
 	draftRef: expertDraftRefSchema,
 	definition: expertDefinitionContentSchema
@@ -592,28 +702,28 @@ const response$22 = z.object({ data: z.object({
 
 //#endregion
 //#region ../models/src/api/experts/drafts/getAll.ts
-const request$19 = {
+const request$26 = {
 	params: z.object({ scopeName: expertDraftScopeSchema.shape.name }),
 	query: z.object({
-		limit: z.coerce.number().int().min(1).max(100).optional().default(20),
-		offset: z.coerce.number().int().min(0).optional().default(0)
+		take: z.coerce.number().int().min(1).max(100).default(20),
+		skip: z.coerce.number().int().min(0).default(0)
 	})
 };
-const response$21 = z.object({ data: z.object({
-	draftRefs: z.array(expertDraftRefSchema),
-	total: z.number().int().min(0)
-}) });
+const response$28 = z.object({
+	data: z.object({ draftRefs: z.array(expertDraftRefSchema) }),
+	meta: paginationMeta
+});
 
 //#endregion
 //#region ../models/src/api/experts/drafts/update.ts
-const request$18 = {
+const request$25 = {
 	params: z.object({
 		scopeName: scopeNameSchema,
 		draftRef: expertDraftRefSchema.shape.id
 	}),
 	body: z.object({ experts: z.array(expertSchema) })
 };
-const response$20 = z.object({ data: z.object({
+const response$27 = z.object({ data: z.object({
 	scope: expertDraftScopeSchema,
 	draftRef: expertDraftRefSchema,
 	definition: expertDefinitionContentSchema
@@ -621,7 +731,7 @@ const response$20 = z.object({ data: z.object({
 
 //#endregion
 //#region ../models/src/api/experts/drafts/version.ts
-const request$17 = {
+const request$24 = {
 	params: z.object({
 		scopeName: scopeNameSchema,
 		draftRef: z.string().min(1)
@@ -631,7 +741,7 @@ const request$17 = {
 		tag: z.string().max(maxExpertVersionTagLength, "Tag is too long.").regex(tagNameRegex, "Invalid tag format. (e.g. latest)").optional()
 	})
 };
-const response$19 = z.object({ data: z.object({
+const response$26 = z.object({ data: z.object({
 	scope: expertScopeSchema,
 	version: expertVersionSchema,
 	definitionUrl: z.string()
@@ -639,7 +749,7 @@ const response$19 = z.object({ data: z.object({
 
 //#endregion
 //#region ../models/src/api/experts/featured.ts
-const response$18 = z.object({ data: z.object({ featuredExperts: z.array(z.object({
+const response$25 = z.object({ data: z.object({ featuredExperts: z.array(z.object({
 	scope: expertScopeSchema,
 	currentVersion: expertVersionSchema,
 	displayOrder: z.number().int().min(0).max(2),
@@ -648,15 +758,15 @@ const response$18 = z.object({ data: z.object({ featuredExperts: z.array(z.objec
 
 //#endregion
 //#region ../models/src/api/experts/get.ts
-const request$16 = { params: z.object({ scopeName: scopeNameRefSchema }) };
-const response$17 = z.object({ data: z.object({
+const request$23 = { params: z.object({ scopeName: scopeNameRefSchema }) };
+const response$24 = z.object({ data: z.object({
 	definition: expertDefinitionSchema,
 	yanked: z.boolean().optional()
 }) });
 
 //#endregion
 //#region ../models/src/api/experts/getAll.ts
-const request$15 = { query: z.object({
+const request$22 = { query: z.object({
 	filter: z.string().describe("Filter by scope name (partial match)").optional(),
 	category: z.enum([
 		"general",
@@ -667,36 +777,36 @@ const request$15 = { query: z.object({
 		"automation"
 	]).describe("Filter by category").optional(),
 	includeDrafts: z.coerce.boolean().default(false).describe("Include unpublished scopes (owner only)").optional(),
-	limit: z.coerce.number().min(1).max(100).default(20).describe("Maximum results").optional(),
-	offset: z.coerce.number().min(0).default(0).describe("Pagination offset").optional()
+	take: z.coerce.number().min(1).max(100).default(20),
+	skip: z.coerce.number().min(0).default(0)
 }) };
-const response$16 = z.object({ data: z.object({
-	experts: z.array(expertScopeSchema.extend({ currentVersion: expertVersionSchema })),
-	total: z.number()
-}) });
+const response$23 = z.object({
+	data: z.object({ experts: z.array(expertScopeSchema.extend({ currentVersion: expertVersionSchema })) }),
+	meta: paginationMeta
+});
 
 //#endregion
 //#region ../models/src/api/experts/meta.ts
-const request$14 = {
+const request$21 = {
 	params: z.object({ scopeName: scopeNameRefSchema }),
 	query: z.object({ public: z.enum(["true", "false"]).transform((val) => val === "true").optional().default(false).describe("Public access check (no auth)") })
 };
-const response$15 = z.object({ data: expertMetadataSchema.extend({ definitionUrl: z.string() }) });
+const response$22 = z.object({ data: expertMetadataSchema.extend({ definitionUrl: z.string() }) });
 
 //#endregion
 //#region ../models/src/api/experts/publish.ts
-const request$13 = { params: z.object({ scopeName: scopeNameSchema }) };
-const response$14 = z.object({ data: z.object({ scope: expertScopeSchema }) });
+const request$20 = { params: z.object({ scopeName: scopeNameSchema }) };
+const response$21 = z.object({ data: z.object({ scope: expertScopeSchema }) });
 
 //#endregion
 //#region ../models/src/api/experts/unpublish.ts
-const request$12 = { params: z.object({ scopeName: scopeNameSchema }) };
-const response$13 = z.object({ data: z.object({ scope: expertScopeSchema }) });
+const request$19 = { params: z.object({ scopeName: scopeNameSchema }) };
+const response$20 = z.object({ data: z.object({ scope: expertScopeSchema }) });
 
 //#endregion
 //#region ../models/src/api/experts/versions.ts
-const request$11 = { params: z.object({ scopeName: scopeNameSchema }) };
-const response$12 = z.object({ data: z.object({ versions: z.array(expertVersionSchema) }) });
+const request$18 = { params: z.object({ scopeName: scopeNameSchema }) };
+const response$19 = z.object({ data: z.object({ versions: z.array(expertVersionSchema) }) });
 
 //#endregion
 //#region ../models/src/domain/checkpoint.ts
@@ -775,44 +885,44 @@ const requestCheckpointSchema = perstackCheckpointSchema.omit({
 	id: true,
 	runId: true
 }).extend({ runId: z.string().optional() });
-const request$10 = {
+const request$17 = {
 	params: z.object({ jobId: cuidSchema }),
 	body: z.object({
 		checkpoint: requestCheckpointSchema,
 		step: stepSchema
 	})
 };
-const response$11 = z.object({ data: z.object({ checkpoint: apiCheckpointSchema }) });
+const response$18 = z.object({ data: z.object({ checkpoint: apiCheckpointSchema }) });
 
 //#endregion
 //#region ../models/src/api/jobs/checkpoints/get.ts
-const request$9 = { params: z.object({
+const request$16 = { params: z.object({
 	jobId: cuidSchema,
 	checkpointId: cuidSchema
 }) };
-const response$10 = z.object({ data: z.object({ checkpoint: apiCheckpointSchema }) });
+const response$17 = z.object({ data: z.object({ checkpoint: apiCheckpointSchema }) });
 
 //#endregion
 //#region ../models/src/api/jobs/checkpoints/getAll.ts
-const request$8 = {
+const request$15 = {
 	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(10),
+		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$16 = z.object({
 	data: z.object({ checkpoints: z.array(apiCheckpointSchema) }),
 	meta: paginationMeta
 });
 
 //#endregion
 //#region ../models/src/api/jobs/checkpoints/stream.ts
-const request$7 = { params: z.object({ jobId: cuidSchema }) };
-const response$8 = z.object({ data: apiCheckpointSchema });
+const request$14 = { params: z.object({ jobId: cuidSchema }) };
+const response$15 = z.object({ data: apiCheckpointSchema });
 
 //#endregion
 //#region ../support-models/src/index.ts
@@ -1014,7 +1124,7 @@ const jobSchema = z.object({
 
 //#endregion
 //#region ../models/src/api/jobs/continue.ts
-const request$6 = {
+const request$13 = {
 	params: z.object({ jobId: cuidSchema }),
 	body: z.object({
 		query: jobSchema.shape.query.optional(),
@@ -1027,11 +1137,11 @@ const request$6 = {
 		maxRetries: z.coerce.number().optional()
 	})
 };
-const response$7 = z.object({ data: z.object({ job: jobSchema }) });
+const response$14 = z.object({ data: z.object({ job: jobSchema }) });
 
 //#endregion
 //#region ../models/src/api/jobs/create.ts
-const request$5 = { body: z.object({
+const request$12 = { body: z.object({
 	applicationId: cuidSchema.describe("Application ID to create the job in"),
 	expertKey: expertKeyFieldSchema,
 	query: jobSchema.shape.query.optional(),
@@ -1042,135 +1152,33 @@ const request$5 = { body: z.object({
 	maxSteps: z.coerce.number().optional(),
 	maxRetries: z.coerce.number().optional()
 }) };
-const response$6 = z.object({ data: z.object({ job: jobSchema }) });
+const response$13 = z.object({ data: z.object({ job: jobSchema }) });
 
 //#endregion
 //#region ../models/src/api/jobs/get.ts
-const request$4 = { params: z.object({ jobId: cuidSchema }) };
-const response$5 = z.object({ data: z.object({ job: jobSchema }) });
+const request$11 = { params: z.object({ jobId: cuidSchema }) };
+const response$12 = z.object({ data: z.object({ job: jobSchema }) });
 
 //#endregion
 //#region ../models/src/api/jobs/getAll.ts
-const request$3 = { query: z.object({
+const request$10 = { query: z.object({
 	sort: z.enum(["createdAt", "updatedAt"]).optional(),
 	order: z.enum(["asc", "desc"]).optional(),
-	take: z.coerce.number().min(1).max(100).default(100),
+	take: z.coerce.number().min(1).max(100).default(20),
 	skip: z.coerce.number().min(0).default(0)
 }) };
-const response$4 = z.object({
+const response$11 = z.object({
 	data: z.object({ jobs: z.array(jobSchema) }),
 	meta: paginationMeta
 });
 
 //#endregion
 //#region ../models/src/api/jobs/update.ts
-const request$2 = {
+const request$9 = {
 	params: z.object({ jobId: cuidSchema }),
 	body: z.object({ status: jobStatusSchema })
 };
-const response$3 = z.object({ data: z.object({ job: jobSchema }) });
-
-//#endregion
-//#region ../models/src/api/jobs/workspace/get.ts
-const workspaceCommitSchema = z.object({
-	sha: z.string(),
-	message: z.string(),
-	author: z.string(),
-	timestamp: z.string()
-});
-const workspaceStatsSchema = z.object({
-	commits: z.number().int().min(0),
-	filesChanged: z.number().int().min(0),
-	additions: z.number().int().min(0),
-	deletions: z.number().int().min(0)
-});
-const workspaceSchema = z.object({
-	jobId: z.string(),
-	branch: z.string(),
-	baseBranch: z.string(),
-	lastCommit: workspaceCommitSchema.optional(),
-	stats: workspaceStatsSchema.optional()
-});
-const request$1 = { params: z.object({ jobId: cuidSchema }) };
-const response$2 = z.object({ data: z.object({ workspace: workspaceSchema }) });
-
-//#endregion
-//#region ../models/src/api/jobs/workspace/tree.ts
-const workspaceItemSchema = z.object({
-	type: z.enum(["directory", "file"]),
-	path: z.string(),
-	name: z.string(),
-	size: z.number().optional(),
-	sha: z.string().optional()
-});
-const request = {
-	params: z.object({ jobId: cuidSchema }),
-	query: z.object({
-		path: z.string().optional(),
-		recursive: z.coerce.boolean().optional()
-	})
-};
-const response$1 = z.object({ data: z.object({ items: z.array(workspaceItemSchema) }) });
-
-//#endregion
-//#region ../models/src/domain/user.ts
-const userStatusSchema = z.enum([
-	"active",
-	"inactive",
-	"deleted"
-]);
-const userSchema = z.object({
-	type: z.literal("user"),
-	id: cuidSchema,
-	email: z.string().email(),
-	emailVerified: z.boolean(),
-	name: z.string().min(1).max(255).optional(),
-	image: z.string().url().optional(),
-	status: userStatusSchema,
-	organizations: z.array(organizationSchema),
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema
-});
-
-//#endregion
-//#region ../models/src/api/session/get.ts
-const response = z.object({ data: z.object({
-	user: userSchema,
-	organization: organizationSchema,
-	application: applicationSchema.nullable()
-}) });
-
-//#endregion
-//#region ../models/src/domain/apiKey.ts
-const apiKeyPermissionsSchema = z.object({
-	operations: z.array(z.string()),
-	experts: z.union([z.array(z.string()), z.literal("*")]).optional()
-});
-const apiKeySchema = z.object({
-	type: z.literal("apiKey"),
-	id: cuidSchema,
-	name: z.string().min(1).max(255).optional(),
-	start: z.string().optional(),
-	prefix: z.string().optional(),
-	user: userSchema.optional(),
-	enabled: z.boolean(),
-	expiresAt: datetimeSchema.optional(),
-	permissions: apiKeyPermissionsSchema.optional(),
-	lastRequest: datetimeSchema.optional(),
-	createdAt: datetimeSchema,
-	updatedAt: datetimeSchema
-});
-const createApiKeyInputSchema = z.object({
-	name: z.string().min(1).max(255).optional(),
-	organizationId: cuidSchema,
-	operations: z.array(z.string()).optional(),
-	experts: z.union([z.array(z.string()), z.literal("*")]).optional(),
-	expiresIn: z.number().min(60).optional()
-});
-const createApiKeyResponseSchema = z.object({
-	apiKey: apiKeySchema,
-	key: z.string()
-});
+const response$10 = z.object({ data: z.object({ job: jobSchema }) });
 
 //#endregion
 //#region ../models/src/domain/providerSetting.ts
@@ -1228,6 +1236,112 @@ const providerSettingSchema = z.object({
 	createdAt: datetimeSchema,
 	updatedAt: datetimeSchema
 });
+const providerSettingResponseSchema = z.object({
+	type: z.literal("providerSetting"),
+	id: cuidSchema,
+	provider: providerSchema,
+	settings: providerSettingsSchema.optional(),
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema
+});
+const providerApiKeyMetadataSchema = z.object({
+	id: cuidSchema,
+	name: z.string(),
+	createdAt: datetimeSchema,
+	updatedAt: datetimeSchema,
+	lastUsedAt: datetimeSchema.nullable(),
+	expiresAt: datetimeSchema.nullable()
+});
+
+//#endregion
+//#region ../models/src/api/provider-settings/api-keys/create.ts
+const request$8 = {
+	params: z.object({
+		applicationId: cuidSchema,
+		provider: providerSchema
+	}),
+	body: z.object({
+		name: z.string().min(1).max(255),
+		value: z.string().min(1)
+	})
+};
+const response$9 = z.object({ data: z.object({ apiKey: providerApiKeyMetadataSchema }) });
+
+//#endregion
+//#region ../models/src/api/provider-settings/api-keys/delete.ts
+const request$7 = { params: z.object({
+	applicationId: cuidSchema,
+	provider: providerSchema,
+	apiKeyId: cuidSchema
+}) };
+const response$8 = z.null();
+
+//#endregion
+//#region ../models/src/api/provider-settings/api-keys/getAll.ts
+const request$6 = { params: z.object({
+	applicationId: cuidSchema,
+	provider: providerSchema
+}) };
+const response$7 = z.object({ data: z.object({ apiKeys: z.array(providerApiKeyMetadataSchema) }) });
+
+//#endregion
+//#region ../models/src/api/provider-settings/create.ts
+const request$5 = {
+	params: z.object({ applicationId: cuidSchema }),
+	body: z.object({
+		provider: providerSchema,
+		settings: providerSettingsSchema.optional()
+	})
+};
+const response$6 = z.object({ data: z.object({ providerSetting: providerSettingResponseSchema }) });
+
+//#endregion
+//#region ../models/src/api/provider-settings/delete.ts
+const request$4 = { params: z.object({
+	applicationId: cuidSchema,
+	provider: providerSchema
+}) };
+const response$5 = z.null();
+
+//#endregion
+//#region ../models/src/api/provider-settings/get.ts
+const request$3 = { params: z.object({
+	applicationId: cuidSchema,
+	provider: providerSchema
+}) };
+const response$4 = z.object({ data: z.object({
+	providerSetting: providerSettingResponseSchema,
+	apiKeys: z.array(providerApiKeyMetadataSchema)
+}) });
+
+//#endregion
+//#region ../models/src/api/provider-settings/getAll.ts
+const request$2 = { params: z.object({ applicationId: cuidSchema }) };
+const response$3 = z.object({ data: z.object({ providerSettings: z.array(providerSettingResponseSchema) }) });
+
+//#endregion
+//#region ../models/src/api/provider-settings/update.ts
+const request$1 = {
+	params: z.object({
+		applicationId: cuidSchema,
+		provider: providerSchema
+	}),
+	body: z.object({ settings: providerSettingsSchema.optional() })
+};
+const response$2 = z.object({ data: z.object({ providerSetting: providerSettingResponseSchema }) });
+
+//#endregion
+//#region ../models/src/api/session/get.ts
+const response$1 = z.object({ data: z.object({
+	user: userSchema,
+	organization: organizationSchema,
+	application: applicationSchema.nullable()
+}) });
+
+//#endregion
+//#region ../models/src/api/session/setApplication.ts
+const request = { body: z.object({ applicationId: z.string().min(1, "Application ID is required") }) };
+const response = z.object({ data: z.object({ success: z.literal(true) }) });
 
 //#endregion
 //#region ../models/src/domain/providerApiKey.ts
@@ -1278,6 +1392,7 @@ const runSchema = z.object({
 //#region src/lib/errors.ts
 function createValidationError(error) {
 	return {
+		errorType: "validation",
 		code: 400,
 		message: `Validation failed: ${error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`,
 		reason: error.issues
@@ -1285,158 +1400,254 @@ function createValidationError(error) {
 }
 function createAbortError() {
 	return {
+		errorType: "abort",
 		code: 0,
 		message: "Request aborted",
 		aborted: true
 	};
 }
+function createTimeoutError() {
+	return {
+		errorType: "timeout",
+		code: 0,
+		message: "Request timed out"
+	};
+}
 function createNetworkError(error) {
 	return {
+		errorType: "network",
 		code: 0,
 		message: error instanceof Error ? error.message : "Network error",
-		reason: error
+		reason: error,
+		cause: error instanceof Error ? error : void 0
+	};
+}
+async function handleHttpError(response$52) {
+	let errorBody;
+	try {
+		errorBody = await response$52.json();
+	} catch {
+		errorBody = void 0;
+	}
+	return {
+		ok: false,
+		error: createHttpError(response$52.status, response$52.statusText, errorBody)
 	};
 }
 function createHttpError(status, statusText, body) {
 	if (typeof body === "object" && body !== null) {
 		const hasReason = "reason" in body;
 		if ("error" in body && typeof body.error === "string") return {
+			errorType: "http",
 			code: status,
 			message: body.error,
 			reason: hasReason ? body.reason : void 0
 		};
 		if (hasReason) return {
+			errorType: "http",
 			code: status,
 			message: statusText,
 			reason: body.reason
 		};
 	}
 	return {
+		errorType: "http",
 		code: status,
 		message: statusText
 	};
 }
+function isHttpError(error) {
+	return error.errorType === "http";
+}
+function isNetworkError(error) {
+	return error.errorType === "network";
+}
+function isTimeoutError(error) {
+	return error.errorType === "timeout";
+}
+function isValidationError(error) {
+	return error.errorType === "validation";
+}
+function isAbortError(error) {
+	return error.errorType === "abort";
+}
+function isClientError(error) {
+	return error.errorType !== "http";
+}
+
+//#endregion
+//#region src/endpoints/api-keys.ts
+const BASE_PATH$6 = "/api/v1/api_keys";
+function createApiKeysApi(fetcher) {
+	return {
+		async create(input, options) {
+			const result = request$49.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(BASE_PATH$6, input, options);
+		},
+		async list(input, options) {
+			const queryParams = new URLSearchParams();
+			if (input?.take !== void 0) queryParams.set("take", String(input.take));
+			if (input?.skip !== void 0) queryParams.set("skip", String(input.skip));
+			const queryString = queryParams.toString();
+			const url = queryString ? `${BASE_PATH$6}?${queryString}` : BASE_PATH$6;
+			return fetcher.get(url, options);
+		},
+		async get(id, options) {
+			const result = request$48.params.safeParse({ apiKeyId: id });
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.get(`${BASE_PATH$6}/${id}`, options);
+		},
+		async revoke(id, options) {
+			const result = request$46.params.safeParse({ apiKeyId: id });
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(`${BASE_PATH$6}/${id}/revoke`, {}, options);
+		}
+	};
+}
 
 //#endregion
-//#region src/endpoints/applications.ts
-const BASE_PATH$4 = "/api/v1/applications";
-function buildQueryString$4(params) {
+//#region src/lib/query-string.ts
+function buildQueryString(params) {
 	if (!params) return "";
 	const searchParams = new URLSearchParams();
-	if (params.name !== void 0) searchParams.set("name", params.name);
-	if (params.sort !== void 0) searchParams.set("sort", params.sort);
-	if (params.order !== void 0) searchParams.set("order", params.order);
-	if (params.take !== void 0) searchParams.set("take", params.take.toString());
-	if (params.skip !== void 0) searchParams.set("skip", params.skip.toString());
+	for (const [key, value] of Object.entries(params)) if (value !== void 0) searchParams.set(key, String(value));
 	const queryString = searchParams.toString();
 	return queryString ? `?${queryString}` : "";
 }
+
+//#endregion
+//#region src/endpoints/applications.ts
+const BASE_PATH$5 = "/api/v1/applications";
 function createApplicationsApi(fetcher) {
 	return {
 		async list(params, options) {
 			if (params) {
-				const result = request$35.query.safeParse(params);
+				const result = request$42.query.safeParse(params);
 				if (!result.success) return {
 					ok: false,
 					error: createValidationError(result.error)
 				};
 			}
-			const queryString = buildQueryString$4(params);
-			return fetcher.get(`${BASE_PATH$4}${queryString}`, options);
+			const queryString = buildQueryString(params);
+			return fetcher.get(`${BASE_PATH$5}${queryString}`, options);
 		},
 		async get(id, options) {
-			return fetcher.get(`${BASE_PATH$4}/${id}`, options);
+			return fetcher.get(`${BASE_PATH$5}/${id}`, options);
 		},
 		async create(input, options) {
-			const result = request$38.body.safeParse(input);
+			const result = request$45.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$5, input, options);
 		},
 		async update(id, input, options) {
-			const result = request$34.body.safeParse(input);
+			const result = request$41.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(`${BASE_PATH$4}/${id}`, input, options);
+			return fetcher.post(`${BASE_PATH$5}/${id}`, input, options);
 		},
 		async delete(id, options) {
-			return fetcher.delete(`${BASE_PATH$4}/${id}`, options);
+			return fetcher.delete(`${BASE_PATH$5}/${id}`, options);
 		}
 	};
 }
 
 //#endregion
 //#region src/endpoints/env-secrets.ts
-const BASE_PATH$3 = "/api/v1/env/secrets";
+const BASE_PATH$4 = "/api/v1/env/secrets";
 function createSecretsApi(fetcher) {
 	return {
-		async list(options) {
-			return fetcher.get(BASE_PATH$3, options);
+		async list(params, options) {
+			if (params) {
+				const result = request$37.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(name, options) {
 			const encodedName = encodeURIComponent(name);
-			return fetcher.get(`${BASE_PATH$3}/${encodedName}`, options);
+			return fetcher.get(`${BASE_PATH$4}/${encodedName}`, options);
 		},
 		async create(input, options) {
-			const result = request$33.body.safeParse(input);
+			const result = request$40.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$4, input, options);
 		},
 		async update(name, input, options) {
-			const result = request$29.body.safeParse(input);
+			const result = request$36.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$4}/${encodedName}`, input, options);
 		},
 		async delete(name, options) {
 			const encodedName = encodeURIComponent(name);
-			return fetcher.deleteNoContent(`${BASE_PATH$3}/${encodedName}`, options);
+			return fetcher.deleteNoContent(`${BASE_PATH$4}/${encodedName}`, options);
 		}
 	};
 }
 
 //#endregion
 //#region src/endpoints/env-variables.ts
-const BASE_PATH$2 = "/api/v1/env/variables";
+const BASE_PATH$3 = "/api/v1/env/variables";
 function createVariablesApi(fetcher) {
 	return {
-		async list(options) {
-			return fetcher.get(BASE_PATH$2, options);
+		async list(params, options) {
+			const result = request$32.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);
 		},
 		async get(name, options) {
 			const encodedName = encodeURIComponent(name);
-			return fetcher.get(`${BASE_PATH$2}/${encodedName}`, options);
+			return fetcher.get(`${BASE_PATH$3}/${encodedName}`, options);
 		},
 		async create(input, options) {
-			const result = request$28.body.safeParse(input);
+			const result = request$35.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(BASE_PATH$2, input, options);
+			return fetcher.post(BASE_PATH$3, input, options);
 		},
 		async update(name, input, options) {
-			const result = request$24.body.safeParse(input);
+			const result = request$31.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
 			const encodedName = encodeURIComponent(name);
-			return fetcher.put(`${BASE_PATH$2}/${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$2}/${encodedName}`, options);
+			return fetcher.deleteNoContent(`${BASE_PATH$3}/${encodedName}`, options);
 		}
 	};
 }
@@ -1452,26 +1663,18 @@ function createEnvApi(fetcher) {
 
 //#endregion
 //#region src/endpoints/experts-drafts.ts
-function buildQueryString$3(params) {
-	if (!params) return "";
-	const searchParams = new URLSearchParams();
-	if (params.limit !== void 0) searchParams.set("limit", params.limit.toString());
-	if (params.offset !== void 0) searchParams.set("offset", params.offset.toString());
-	const queryString = searchParams.toString();
-	return queryString ? `?${queryString}` : "";
-}
 function createDraftsApi(fetcher, basePath) {
 	return {
 		async list(scopeName, params, options) {
 			if (params) {
-				const result = request$19.query.safeParse(params);
+				const result = request$26.query.safeParse(params);
 				if (!result.success) return {
 					ok: false,
 					error: createValidationError(result.error)
 				};
 			}
 			const encodedScopeName = encodeURIComponent(scopeName);
-			const queryString = buildQueryString$3(params);
+			const queryString = buildQueryString(params);
 			return fetcher.get(`${basePath}/${encodedScopeName}/drafts${queryString}`, options);
 		},
 		async get(scopeName, draftRef, options) {
@@ -1480,7 +1683,7 @@ function createDraftsApi(fetcher, basePath) {
 			return fetcher.get(`${basePath}/${encodedScopeName}/drafts/${encodedDraftRef}`, options);
 		},
 		async create(scopeName, input, options) {
-			const result = request$22.body.safeParse(input);
+			const result = request$29.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
@@ -1489,7 +1692,7 @@ function createDraftsApi(fetcher, basePath) {
 			return fetcher.post(`${basePath}/${encodedScopeName}/drafts`, input, options);
 		},
 		async update(scopeName, draftRef, input, options) {
-			const result = request$18.body.safeParse(input);
+			const result = request$25.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
@@ -1504,7 +1707,7 @@ function createDraftsApi(fetcher, basePath) {
 			return fetcher.delete(`${basePath}/${encodedScopeName}/drafts/${encodedDraftRef}`, options);
 		},
 		async assignVersion(scopeName, draftRef, input, options) {
-			const result = request$17.body.safeParse(input);
+			const result = request$24.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
@@ -1527,56 +1730,45 @@ function createVersionsApi(fetcher, basePath) {
 
 //#endregion
 //#region src/endpoints/experts.ts
-const BASE_PATH$1 = "/api/v1/experts";
-function buildQueryString$2(params) {
-	if (!params) return "";
-	const searchParams = new URLSearchParams();
-	if (params.filter !== void 0) searchParams.set("filter", params.filter);
-	if (params.category !== void 0) searchParams.set("category", params.category);
-	if (params.includeDrafts !== void 0) searchParams.set("includeDrafts", params.includeDrafts.toString());
-	if (params.limit !== void 0) searchParams.set("limit", params.limit.toString());
-	if (params.offset !== void 0) searchParams.set("offset", params.offset.toString());
-	const queryString = searchParams.toString();
-	return queryString ? `?${queryString}` : "";
-}
+const BASE_PATH$2 = "/api/v1/experts";
 function createExpertsApi(fetcher) {
 	return {
 		async list(params, options) {
 			if (params) {
-				const result = request$15.query.safeParse(params);
+				const result = request$22.query.safeParse(params);
 				if (!result.success) return {
 					ok: false,
 					error: createValidationError(result.error)
 				};
 			}
-			const queryString = buildQueryString$2(params);
-			return fetcher.get(`${BASE_PATH$1}${queryString}`, options);
+			const queryString = buildQueryString(params);
+			return fetcher.get(`${BASE_PATH$2}${queryString}`, options);
 		},
 		async get(key, options) {
 			const encodedKey = encodeURIComponent(key);
-			return fetcher.get(`${BASE_PATH$1}/${encodedKey}`, options);
+			return fetcher.get(`${BASE_PATH$2}/${encodedKey}`, options);
 		},
 		async getFeatured(options) {
-			return fetcher.get(`${BASE_PATH$1}/featured`, options);
+			return fetcher.get(`${BASE_PATH$2}/featured`, options);
 		},
 		async getMeta(key, options) {
 			const encodedKey = encodeURIComponent(key);
-			return fetcher.get(`${BASE_PATH$1}/${encodedKey}/meta`, options);
+			return fetcher.get(`${BASE_PATH$2}/${encodedKey}/meta`, options);
 		},
 		async publish(scopeName, options) {
 			const encodedScopeName = encodeURIComponent(scopeName);
-			return fetcher.post(`${BASE_PATH$1}/${encodedScopeName}/publish`, {}, options);
+			return fetcher.post(`${BASE_PATH$2}/${encodedScopeName}/publish`, {}, options);
 		},
 		async unpublish(scopeName, options) {
 			const encodedScopeName = encodeURIComponent(scopeName);
-			return fetcher.post(`${BASE_PATH$1}/${encodedScopeName}/unpublish`, {}, options);
+			return fetcher.post(`${BASE_PATH$2}/${encodedScopeName}/unpublish`, {}, options);
 		},
 		async yank(key, options) {
 			const encodedKey = encodeURIComponent(key);
-			return fetcher.delete(`${BASE_PATH$1}/${encodedKey}`, options);
+			return fetcher.delete(`${BASE_PATH$2}/${encodedKey}`, options);
 		},
-		drafts: createDraftsApi(fetcher, BASE_PATH$1),
-		versions: createVersionsApi(fetcher, BASE_PATH$1)
+		drafts: createDraftsApi(fetcher, BASE_PATH$2),
+		versions: createVersionsApi(fetcher, BASE_PATH$2)
 	};
 }
 
@@ -1606,34 +1798,24 @@ async function* parseSSE(reader) {
 
 //#endregion
 //#region src/endpoints/jobs-checkpoints.ts
-function buildQueryString$1(params) {
-	if (!params) return "";
-	const searchParams = new URLSearchParams();
-	if (params.take !== void 0) searchParams.set("take", params.take.toString());
-	if (params.skip !== void 0) searchParams.set("skip", params.skip.toString());
-	if (params.sort !== void 0) searchParams.set("sort", params.sort);
-	if (params.order !== void 0) searchParams.set("order", params.order);
-	const queryString = searchParams.toString();
-	return queryString ? `?${queryString}` : "";
-}
 function createCheckpointsApi(fetcher, basePath) {
 	return {
 		async list(jobId, params, options) {
 			if (params) {
-				const result = request$8.query.safeParse(params);
+				const result = request$15.query.safeParse(params);
 				if (!result.success) return {
 					ok: false,
 					error: createValidationError(result.error)
 				};
 			}
-			const queryString = buildQueryString$1(params);
+			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$10.body.safeParse(input);
+			const result = request$17.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
@@ -1642,104 +1824,134 @@ function createCheckpointsApi(fetcher, basePath) {
 		},
 		async *stream(jobId, options) {
 			const result = await fetcher.getStream(`${basePath}/${jobId}/checkpoints/stream`, options);
-			if (!result.ok) throw new Error(`Failed to start checkpoint stream: ${result.error.message}`);
+			if (!result.ok) {
+				yield {
+					ok: false,
+					error: result.error
+				};
+				return;
+			}
 			const reader = result.data.getReader();
-			for await (const checkpoint of parseSSE(reader)) yield checkpoint;
-		}
-	};
-}
-
-//#endregion
-//#region src/endpoints/jobs-workspace.ts
-function buildTreeQueryString(params) {
-	if (!params) return "";
-	const searchParams = new URLSearchParams();
-	if (params.path !== void 0) searchParams.set("path", params.path);
-	if (params.recursive !== void 0) searchParams.set("recursive", params.recursive.toString());
-	const queryString = searchParams.toString();
-	return queryString ? `?${queryString}` : "";
-}
-function createWorkspaceApi(fetcher, basePath) {
-	return {
-		async get(jobId, options) {
-			return fetcher.get(`${basePath}/${jobId}/workspace`, options);
-		},
-		async tree(jobId, params, options) {
-			if (params) {
-				const result = request.query.safeParse(params);
-				if (!result.success) return {
+			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: createValidationError(result.error)
+					error: createAbortError()
+				};
+				else yield {
+					ok: false,
+					error: createNetworkError(error)
 				};
 			}
-			const queryString = buildTreeQueryString(params);
-			return fetcher.get(`${basePath}/${jobId}/workspace/tree${queryString}`, options);
-		},
-		async blob(jobId, path, options) {
-			const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
-			return fetcher.getBlob(`${basePath}/${jobId}/workspace/blob/${normalizedPath}`, options);
 		}
 	};
 }
 
 //#endregion
 //#region src/endpoints/jobs.ts
-const BASE_PATH = "/api/v1/jobs";
-function buildQueryString(params) {
-	if (!params) return "";
-	const searchParams = new URLSearchParams();
-	if (params.take !== void 0) searchParams.set("take", params.take.toString());
-	if (params.skip !== void 0) searchParams.set("skip", params.skip.toString());
-	if (params.sort !== void 0) searchParams.set("sort", params.sort);
-	if (params.order !== void 0) searchParams.set("order", params.order);
-	const queryString = searchParams.toString();
-	return queryString ? `?${queryString}` : "";
-}
+const BASE_PATH$1 = "/api/v1/jobs";
 function createJobsApi(fetcher) {
 	return {
 		async list(params, options) {
 			if (params) {
-				const result = request$3.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}${queryString}`, options);
+			return fetcher.get(`${BASE_PATH$1}${queryString}`, options);
 		},
 		async get(id, options) {
-			return fetcher.get(`${BASE_PATH}/${id}`, options);
+			return fetcher.get(`${BASE_PATH$1}/${id}`, options);
 		},
 		async start(input, options) {
-			const result = request$5.body.safeParse(input);
+			const result = request$12.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(BASE_PATH, input, options);
+			return fetcher.post(BASE_PATH$1, input, options);
 		},
 		async update(id, input, options) {
-			const result = request$2.body.safeParse(input);
+			const result = request$9.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(`${BASE_PATH}/${id}`, input, options);
+			return fetcher.post(`${BASE_PATH$1}/${id}`, input, options);
 		},
 		async continue(id, input, options) {
-			const result = request$6.body.safeParse(input);
+			const result = request$13.body.safeParse(input);
 			if (!result.success) return {
 				ok: false,
 				error: createValidationError(result.error)
 			};
-			return fetcher.post(`${BASE_PATH}/${id}/continue`, input, options);
+			return fetcher.post(`${BASE_PATH$1}/${id}/continue`, input, options);
 		},
 		async cancel(id, options) {
-			return fetcher.post(`${BASE_PATH}/${id}/cancel`, {}, options);
+			return fetcher.post(`${BASE_PATH$1}/${id}/cancel`, {}, options);
 		},
-		checkpoints: createCheckpointsApi(fetcher, BASE_PATH),
-		workspace: createWorkspaceApi(fetcher, BASE_PATH)
+		checkpoints: createCheckpointsApi(fetcher, BASE_PATH$1)
+	};
+}
+
+//#endregion
+//#region src/endpoints/provider-settings.ts
+const BASE_PATH = "/api/v1/applications";
+function createProviderSettingsApi(fetcher) {
+	return {
+		async list(applicationId, options) {
+			return fetcher.get(`${BASE_PATH}/${applicationId}/provider_settings`, options);
+		},
+		async get(applicationId, provider, options) {
+			const encodedProvider = encodeURIComponent(provider);
+			return fetcher.get(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}`, options);
+		},
+		async create(applicationId, input, options) {
+			const result = request$5.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			return fetcher.post(`${BASE_PATH}/${applicationId}/provider_settings`, input, options);
+		},
+		async update(applicationId, provider, input, options) {
+			const result = request$1.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			const encodedProvider = encodeURIComponent(provider);
+			return fetcher.post(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}`, input, options);
+		},
+		async delete(applicationId, provider, options) {
+			const encodedProvider = encodeURIComponent(provider);
+			return fetcher.deleteNoContent(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}`, options);
+		},
+		async listApiKeys(applicationId, provider, options) {
+			const encodedProvider = encodeURIComponent(provider);
+			return fetcher.get(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}/api_keys`, options);
+		},
+		async createApiKey(applicationId, provider, input, options) {
+			const result = request$8.body.safeParse(input);
+			if (!result.success) return {
+				ok: false,
+				error: createValidationError(result.error)
+			};
+			const encodedProvider = encodeURIComponent(provider);
+			return fetcher.post(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}/api_keys`, input, options);
+		},
+		async deleteApiKey(applicationId, provider, apiKeyId, options) {
+			const encodedProvider = encodeURIComponent(provider);
+			const encodedApiKeyId = encodeURIComponent(apiKeyId);
+			return fetcher.deleteNoContent(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}/api_keys/${encodedApiKeyId}`, options);
+		}
 	};
 }
 
@@ -1755,8 +1967,9 @@ function createFetcher(config) {
 	function buildUrl(path) {
 		return `${baseUrl}${path}`;
 	}
-	function buildHeaders() {
-		const headers = { "Content-Type": "application/json" };
+	function buildHeaders(options) {
+		const headers = {};
+		if (options?.hasBody) headers["Content-Type"] = "application/json";
 		if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
 		return headers;
 	}
@@ -1765,7 +1978,11 @@ function createFetcher(config) {
 	}
 	function createTimeoutSignal(externalSignal) {
 		const controller = new AbortController();
-		const timeoutId = setTimeout(() => controller.abort(), timeout);
+		let timedOut = false;
+		const timeoutId = setTimeout(() => {
+			timedOut = true;
+			controller.abort();
+		}, timeout);
 		let abortHandler;
 		if (externalSignal) if (externalSignal.aborted) controller.abort();
 		else {
@@ -1777,40 +1994,86 @@ function createFetcher(config) {
 			cleanup: () => {
 				clearTimeout(timeoutId);
 				if (abortHandler && externalSignal) externalSignal.removeEventListener("abort", abortHandler);
-			}
+			},
+			isTimeout: () => timedOut
 		};
 	}
-	async function request$39(method, path, body, options) {
-		const { signal, cleanup } = createTimeoutSignal(options?.signal);
+	function wrapStreamWithIdleTimeout(stream, idleTimeoutMs, externalSignal) {
+		const reader = stream.getReader();
+		const controller = new AbortController();
+		let timeoutId;
+		let abortHandler;
+		if (externalSignal) if (externalSignal.aborted) controller.abort();
+		else {
+			abortHandler = () => controller.abort();
+			externalSignal.addEventListener("abort", abortHandler);
+		}
+		function resetTimeout() {
+			if (timeoutId) clearTimeout(timeoutId);
+			timeoutId = setTimeout(() => controller.abort(), idleTimeoutMs);
+		}
+		function cleanup() {
+			if (timeoutId) clearTimeout(timeoutId);
+			if (abortHandler && externalSignal) externalSignal.removeEventListener("abort", abortHandler);
+		}
+		return new ReadableStream({
+			start() {
+				resetTimeout();
+			},
+			async pull(streamController) {
+				try {
+					const result = await Promise.race([reader.read(), new Promise((_, reject) => {
+						if (controller.signal.aborted) reject(new DOMException("Stream idle timeout", "AbortError"));
+						controller.signal.addEventListener("abort", () => {
+							reject(new DOMException("Stream idle timeout", "AbortError"));
+						});
+					})]);
+					if (result.done) {
+						cleanup();
+						streamController.close();
+						return;
+					}
+					resetTimeout();
+					streamController.enqueue(result.value);
+				} catch (error) {
+					cleanup();
+					reader.cancel().catch(() => {});
+					if (error instanceof DOMException && error.name === "AbortError") streamController.error(new DOMException("Stream idle timeout", "AbortError"));
+					else streamController.error(error);
+				}
+			},
+			cancel(reason) {
+				cleanup();
+				reader.cancel(reason).catch(() => {});
+			}
+		});
+	}
+	async function request$50(method, path, body, options) {
+		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
 		try {
-			const response$41 = await fetch(buildUrl(path), {
+			const response$52 = await fetch(buildUrl(path), {
 				method,
-				headers: buildHeaders(),
+				headers: buildHeaders(body ? { hasBody: true } : void 0),
 				body: body ? JSON.stringify(body) : void 0,
 				signal,
 				credentials: getCredentials()
 			});
-			if (!response$41.ok) {
-				let errorBody;
-				try {
-					errorBody = await response$41.json();
-				} catch {
-					errorBody = void 0;
-				}
-				return {
-					ok: false,
-					error: createHttpError(response$41.status, response$41.statusText, errorBody)
-				};
-			}
+			if (!response$52.ok) return handleHttpError(response$52);
 			return {
 				ok: true,
-				data: await response$41.json()
+				data: await response$52.json()
 			};
 		} catch (error) {
-			if (error instanceof Error && error.name === "AbortError") return {
-				ok: false,
-				error: createAbortError()
-			};
+			if (error instanceof Error && error.name === "AbortError") {
+				if (isTimeout()) return {
+					ok: false,
+					error: createTimeoutError()
+				};
+				return {
+					ok: false,
+					error: createAbortError()
+				};
+			}
 			return {
 				ok: false,
 				error: createNetworkError(error)
@@ -1820,35 +2083,30 @@ function createFetcher(config) {
 		}
 	}
 	async function requestBlob(path, options) {
-		const { signal, cleanup } = createTimeoutSignal(options?.signal);
+		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
 		try {
-			const response$41 = await fetch(buildUrl(path), {
+			const response$52 = await fetch(buildUrl(path), {
 				method: "GET",
 				headers: buildHeaders(),
 				signal,
 				credentials: getCredentials()
 			});
-			if (!response$41.ok) {
-				let errorBody;
-				try {
-					errorBody = await response$41.json();
-				} catch {
-					errorBody = void 0;
-				}
-				return {
-					ok: false,
-					error: createHttpError(response$41.status, response$41.statusText, errorBody)
-				};
-			}
+			if (!response$52.ok) return handleHttpError(response$52);
 			return {
 				ok: true,
-				data: await response$41.blob()
+				data: await response$52.blob()
 			};
 		} catch (error) {
-			if (error instanceof Error && error.name === "AbortError") return {
-				ok: false,
-				error: createAbortError()
-			};
+			if (error instanceof Error && error.name === "AbortError") {
+				if (isTimeout()) return {
+					ok: false,
+					error: createTimeoutError()
+				};
+				return {
+					ok: false,
+					error: createAbortError()
+				};
+			}
 			return {
 				ok: false,
 				error: createNetworkError(error)
@@ -1858,28 +2116,19 @@ function createFetcher(config) {
 		}
 	}
 	async function requestStream(path, options) {
-		const { signal, cleanup } = createTimeoutSignal(options?.signal);
+		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
 		try {
-			const response$41 = await fetch(buildUrl(path), {
+			const response$52 = await fetch(buildUrl(path), {
 				method: "GET",
 				headers: buildHeaders(),
 				signal,
 				credentials: getCredentials()
 			});
-			if (!response$41.ok) {
-				let errorBody;
-				try {
-					errorBody = await response$41.json();
-				} catch {
-					errorBody = void 0;
-				}
+			if (!response$52.ok) {
 				cleanup();
-				return {
-					ok: false,
-					error: createHttpError(response$41.status, response$41.statusText, errorBody)
-				};
+				return handleHttpError(response$52);
 			}
-			if (!response$41.body) {
+			if (!response$52.body) {
 				cleanup();
 				return {
 					ok: false,
@@ -1887,16 +2136,23 @@ function createFetcher(config) {
 				};
 			}
 			cleanup();
+			const idleTimeout = options?.streamIdleTimeout ?? timeout;
 			return {
 				ok: true,
-				data: response$41.body
+				data: wrapStreamWithIdleTimeout(response$52.body, idleTimeout, options?.signal)
 			};
 		} catch (error) {
 			cleanup();
-			if (error instanceof Error && error.name === "AbortError") return {
-				ok: false,
-				error: createAbortError()
-			};
+			if (error instanceof Error && error.name === "AbortError") {
+				if (isTimeout()) return {
+					ok: false,
+					error: createTimeoutError()
+				};
+				return {
+					ok: false,
+					error: createAbortError()
+				};
+			}
 			return {
 				ok: false,
 				error: createNetworkError(error)
@@ -1904,35 +2160,30 @@ function createFetcher(config) {
 		}
 	}
 	async function requestNoContent(method, path, options) {
-		const { signal, cleanup } = createTimeoutSignal(options?.signal);
+		const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
 		try {
-			const response$41 = await fetch(buildUrl(path), {
+			const response$52 = await fetch(buildUrl(path), {
 				method,
 				headers: buildHeaders(),
 				signal,
 				credentials: getCredentials()
 			});
-			if (!response$41.ok) {
-				let errorBody;
-				try {
-					errorBody = await response$41.json();
-				} catch {
-					errorBody = void 0;
-				}
-				return {
-					ok: false,
-					error: createHttpError(response$41.status, response$41.statusText, errorBody)
-				};
-			}
+			if (!response$52.ok) return handleHttpError(response$52);
 			return {
 				ok: true,
 				data: void 0
 			};
 		} catch (error) {
-			if (error instanceof Error && error.name === "AbortError") return {
-				ok: false,
-				error: createAbortError()
-			};
+			if (error instanceof Error && error.name === "AbortError") {
+				if (isTimeout()) return {
+					ok: false,
+					error: createTimeoutError()
+				};
+				return {
+					ok: false,
+					error: createAbortError()
+				};
+			}
 			return {
 				ok: false,
 				error: createNetworkError(error)
@@ -1942,10 +2193,10 @@ function createFetcher(config) {
 		}
 	}
 	return {
-		get: (path, options) => request$39("GET", path, void 0, options),
-		post: (path, body, options) => request$39("POST", path, body, options),
-		put: (path, body, options) => request$39("PUT", path, body, options),
-		delete: (path, options) => request$39("DELETE", path, void 0, options),
+		get: (path, options) => request$50("GET", path, void 0, options),
+		post: (path, body, options) => request$50("POST", path, body, options),
+		put: (path, body, options) => request$50("PUT", path, body, options),
+		delete: (path, options) => request$50("DELETE", path, void 0, options),
 		deleteNoContent: (path, options) => requestNoContent("DELETE", path, options),
 		getBlob: (path, options) => requestBlob(path, options),
 		getStream: (path, options) => requestStream(path, options)
@@ -1953,14 +2204,16 @@ function createFetcher(config) {
 }
 
 //#endregion
-//#region src/client.ts
+//#region src/client-public.ts
 function createApiClient(config) {
 	const fetcher = createFetcher(config);
 	return {
+		apiKeys: createApiKeysApi(fetcher),
 		applications: createApplicationsApi(fetcher),
 		env: createEnvApi(fetcher),
 		jobs: createJobsApi(fetcher),
-		experts: createExpertsApi(fetcher)
+		experts: createExpertsApi(fetcher),
+		providerSettings: createProviderSettingsApi(fetcher)
 	};
 }
 
@@ -1998,14 +2251,11 @@ function stringifyApiKeyPermissions(permissions) {
 
 //#endregion
 //#region src/lib/auth.ts
-/**
-* Build authentication headers from AuthOptions.
-*/
 function buildAuthHeaders(auth) {
 	if (auth.type === "apiKey") return { Authorization: `Bearer ${auth.apiKey}` };
 	return { Cookie: auth.cookie };
 }
 
 //#endregion
-export { buildAuthHeaders, createAbortError, createApiClient, createFetcher, createHttpError, createNetworkError, createValidationError, matchExperts, matchOperations, matchWildcard, parseApiKeyPermissions, parseSSE, stringifyApiKeyPermissions };
-//# sourceMappingURL=index.mjs.map
+export { buildAuthHeaders, buildQueryString, createAbortError, createApiClient, createFetcher, createHttpError, createNetworkError, createTimeoutError, createValidationError, handleHttpError, isAbortError, isClientError, isHttpError, isNetworkError, isTimeoutError, isValidationError, matchExperts, matchOperations, matchWildcard, parseApiKeyPermissions, parseSSE, stringifyApiKeyPermissions };
+//# sourceMappingURL=bundle.mjs.map