@perstack/api-client 0.0.1

package/dist/v1/index.ts.js

@@ -0,0 +1,1618 @@
+import { z } from 'zod';
+import { maxOrganizationNameLength, organizationNameRegex, maxSkillNameLength, packageWithVersionRegex, maxEnvNameLength, envNameRegex, maxSkillToolNameLength, maxSkillRuleLength, maxSkillDescriptionLength, maxSkillEndpointLength, urlSafeRegex, maxSkillInputJsonSchemaLength, maxExpertVersionTagLength, tagNameRegex, expertVersionRegex, maxExpertDescriptionLength, maxExpertNameLength, expertNameRegex, maxExpertKeyLength, expertKeyRegex, maxExpertInstructionLength, messagePartSchema, usageSchema, toolResultSchema, toolCallSchema, messageSchema, instructionMessageSchema, userMessageSchema, toolMessageSchema, maxCheckpointToolCallIdLength } from '@perstack/core';
+
+// v1/api-error.ts
+var ApiError = class extends Error {
+  constructor(responseText) {
+    let payload = null;
+    try {
+      payload = JSON.parse(responseText);
+    } catch {
+    }
+    const code = payload?.code ?? 500;
+    const error = payload?.error ?? "Unknown error";
+    const reason = payload?.reason ?? responseText;
+    super(`${code} ${error}: ${reason}`);
+    this.name = new.target.name;
+    this.code = code;
+    this.error = error;
+    this.reason = reason;
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, new.target);
+    }
+  }
+  code;
+  error;
+  reason;
+};
+var apiOrganizationStatusSchema = z.union([
+  z.literal("active"),
+  z.literal("inactive"),
+  z.literal("deleted")
+]);
+var apiOrganizationTypeSchema = z.union([
+  z.literal("personal"),
+  z.literal("personalPlus"),
+  z.literal("team"),
+  z.literal("serviceAdmin")
+]);
+var apiOrganizationSchema = z.object({
+  type: z.literal("organization"),
+  id: z.cuid2(),
+  createdAt: z.iso.datetime().transform((date) => new Date(date)),
+  updatedAt: z.iso.datetime().transform((date) => new Date(date)),
+  name: z.string().min(1, "Name is required.").max(maxOrganizationNameLength, "Name is too long.").regex(organizationNameRegex, "Invalid name format. (e.g. my-organization)").optional(),
+  nameChangedAt: z.date().optional(),
+  status: apiOrganizationStatusSchema,
+  organizationType: apiOrganizationTypeSchema,
+  maxApplications: z.number().min(0),
+  maxApiKeys: z.number().min(0),
+  maxStudioExperts: z.number().min(0)
+});
+
+// v1/schemas/application.ts
+var apiApplicationStatusSchema = z.union([
+  z.literal("active"),
+  z.literal("inactive"),
+  z.literal("deleted")
+]);
+var apiApplicationSchema = z.object({
+  type: z.literal("application"),
+  id: z.cuid2(),
+  organizationId: z.cuid2(),
+  organization: apiOrganizationSchema,
+  createdAt: z.iso.datetime().transform((date) => new Date(date)),
+  updatedAt: z.iso.datetime().transform((date) => new Date(date)),
+  name: z.string().min(1).max(255),
+  status: apiApplicationStatusSchema
+});
+var apiRuntimeVersionSchema = z.enum(["v1.0"]);
+var apiSkillNameSchema = z.string().min(1, "Skill name is required.").max(maxSkillNameLength, "Skill name is too long.").regex(packageWithVersionRegex, "Invalid package name or version.");
+var apiMcpStdioSkillCommandSchema = z.enum(["npx", "uvx"]);
+var apiMcpStdioSkillSchema = z.object({
+  type: z.literal("mcpStdioSkill"),
+  description: z.string().min(1, "Description is required.").max(maxSkillDescriptionLength, "Description is too long"),
+  rule: z.string().max(maxSkillRuleLength, "Rule is too long").optional(),
+  pick: z.array(z.string().max(maxSkillToolNameLength, "Tool name is too long")).optional(),
+  omit: z.array(z.string().max(maxSkillToolNameLength, "Tool name is too long")).optional(),
+  command: apiMcpStdioSkillCommandSchema,
+  packageName: z.string().min(1, "Package name is required.").max(maxSkillNameLength, "Package name is too long.").regex(packageWithVersionRegex, "Invalid package name or version."),
+  requiredEnv: z.array(
+    z.string().max(maxEnvNameLength, "Environment variable name is too long").regex(envNameRegex, "Invalid environment variable name.")
+  ).optional()
+});
+var apiMcpSseSkillSchema = z.object({
+  type: z.literal("mcpSseSkill"),
+  description: z.string().min(1, "Description is required.").max(maxSkillDescriptionLength, "Description is too long"),
+  rule: z.string().max(maxSkillRuleLength, "Rule is too long").optional(),
+  pick: z.array(z.string().max(maxSkillToolNameLength, "Tool name is too long")).optional(),
+  omit: z.array(z.string().max(maxSkillToolNameLength, "Tool name is too long")).optional(),
+  endpoint: z.string().min(1, "Endpoint is required.").max(maxSkillEndpointLength, "Endpoint is too long")
+});
+var apiInteractiveSkillSchema = z.object({
+  type: z.literal("interactiveSkill"),
+  description: z.string().min(1, "Description is required.").max(maxSkillDescriptionLength, "Description is too long"),
+  rule: z.string().max(maxSkillRuleLength, "Rule is too long").optional(),
+  tools: z.record(
+    z.string().min(1, "Tool name is required.").max(maxSkillToolNameLength, "Tool name is too long").regex(urlSafeRegex, "Invalid tool name."),
+    z.object({
+      description: z.string().min(1, "Description is required.").max(maxSkillDescriptionLength, "Description is too long"),
+      inputJsonSchema: z.string().min(1, "Input JSON schema is required.").max(maxSkillInputJsonSchemaLength, "Input JSON schema is too long")
+    })
+  )
+});
+var apiSkillSchema = z.discriminatedUnion("type", [
+  apiMcpStdioSkillSchema,
+  apiMcpSseSkillSchema,
+  apiInteractiveSkillSchema
+]);
+
+// v1/schemas/expert.ts
+var apiTagNameSchema = z.string().pipe(z.string().min(1, "Tag is required.")).pipe(z.string().max(maxExpertVersionTagLength, "Tag is too long.")).pipe(z.string().regex(tagNameRegex, "Invalid tag format. (e.g. latest)"));
+var apiExpertVersionSchema = z.string().pipe(z.string().min(1, "Version is required.")).pipe(z.string().max(maxExpertVersionTagLength, "Version is too long.")).pipe(z.string().regex(expertVersionRegex, "Invalid version format. (e.g. 1.0.0)"));
+var apiBaseExpertSchema = z.object({
+  id: z.cuid2(),
+  key: z.string().pipe(z.string().min(1, "Key is required.")).pipe(z.string().max(maxExpertKeyLength, "Key is too long.")).pipe(z.string().regex(expertKeyRegex, "Invalid key format. (e.g. my-expert)")),
+  name: z.string().pipe(z.string().min(1, "Name is required.")).pipe(z.string().max(maxExpertNameLength, "Name is too long.")).pipe(z.string().regex(expertNameRegex, "Invalid name format. (e.g. my-expert)")),
+  minRuntimeVersion: apiRuntimeVersionSchema,
+  description: z.string().min(1, "Description is required").max(maxExpertDescriptionLength, "Description must be less than 2048 characters"),
+  owner: z.object({
+    name: apiOrganizationSchema.shape.name,
+    organizationId: z.cuid2(),
+    createdAt: z.iso.datetime().transform((date) => new Date(date))
+  }),
+  createdAt: z.iso.datetime().transform((date) => new Date(date)),
+  updatedAt: z.iso.datetime().transform((date) => new Date(date))
+});
+var apiRegistryExpertSchema = apiBaseExpertSchema.extend({
+  type: z.literal("registryExpert"),
+  version: apiExpertVersionSchema,
+  status: z.union([z.literal("available"), z.literal("deprecated"), z.literal("disabled")]),
+  instruction: z.string().min(1, "Instruction is required").max(maxExpertInstructionLength, "Instruction must be less than 20480 characters"),
+  skills: z.record(apiSkillNameSchema, apiSkillSchema),
+  delegates: z.array(apiBaseExpertSchema.shape.key),
+  tags: z.array(apiTagNameSchema)
+});
+var apiStudioExpertSchema = apiBaseExpertSchema.extend({
+  type: z.literal("studioExpert"),
+  instruction: z.string().min(1, "Instruction is required").max(maxExpertInstructionLength, "Instruction must be less than 20480 characters"),
+  skills: z.record(apiSkillNameSchema, apiSkillSchema),
+  delegates: z.array(apiBaseExpertSchema.shape.key),
+  forkFrom: apiBaseExpertSchema.shape.key.optional(),
+  application: apiApplicationSchema
+});
+var apiExpertDigestSchema = apiBaseExpertSchema.extend({
+  type: z.literal("expertDigest"),
+  version: apiExpertVersionSchema.optional(),
+  tags: z.array(apiTagNameSchema)
+});
+var apiExpertSchema = z.discriminatedUnion("type", [
+  apiExpertDigestSchema,
+  apiRegistryExpertSchema,
+  apiStudioExpertSchema
+]);
+
+// v1/registry/experts.ts
+var createRegistryExpertInput = z.object({
+  name: apiRegistryExpertSchema.shape.name,
+  version: apiRegistryExpertSchema.shape.version,
+  minRuntimeVersion: apiRegistryExpertSchema.shape.minRuntimeVersion,
+  description: apiRegistryExpertSchema.shape.description,
+  instruction: apiRegistryExpertSchema.shape.instruction,
+  skills: apiRegistryExpertSchema.shape.skills,
+  delegates: apiRegistryExpertSchema.shape.delegates,
+  tags: apiRegistryExpertSchema.shape.tags
+});
+var createRegistryExpertResponseSchema = z.object({
+  data: z.object({
+    expert: apiRegistryExpertSchema
+  })
+});
+async function createRegistryExpert(input, client) {
+  const { name, version, minRuntimeVersion, description, instruction, skills, delegates, tags } = createRegistryExpertInput.parse(input);
+  const endpoint = "/api/registry/v1/experts";
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      name,
+      version,
+      minRuntimeVersion,
+      description,
+      instruction,
+      skills,
+      delegates,
+      tags
+    })
+  });
+  const { data } = createRegistryExpertResponseSchema.parse(json);
+  return {
+    expert: data.expert
+  };
+}
+var getRegistryExpertInput = z.object({
+  expertKey: apiRegistryExpertSchema.shape.key
+});
+var getRegistryExpertResponseSchema = z.object({
+  data: z.object({
+    expert: apiRegistryExpertSchema
+  })
+});
+async function getRegistryExpert(input, client) {
+  const { expertKey } = getRegistryExpertInput.parse(input);
+  const endpoint = `/api/registry/v1/experts/${encodeURIComponent(expertKey)}`;
+  const json = await client.request(endpoint, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data } = getRegistryExpertResponseSchema.parse(json);
+  return {
+    expert: data.expert
+  };
+}
+var getRegistryExpertsInput = z.object({
+  take: z.union([z.number(), z.string().transform((value) => Number.parseInt(value))]).optional(),
+  skip: z.union([z.number(), z.string().transform((value) => Number.parseInt(value))]).optional(),
+  sort: z.string().optional(),
+  order: z.string().optional(),
+  filter: z.string().optional(),
+  organizationId: z.string().optional()
+});
+var getRegistryExpertsResponseSchema = z.object({
+  data: z.object({
+    experts: z.array(apiRegistryExpertSchema)
+  }),
+  meta: z.object({
+    total: z.number(),
+    take: z.number(),
+    skip: z.number()
+  })
+});
+async function getRegistryExperts(input, client) {
+  const {
+    sort,
+    order,
+    take: takeParam,
+    skip: skipParam,
+    filter,
+    organizationId
+  } = getRegistryExpertsInput.parse(input);
+  const url = new URL("/api/registry/v1/experts", client.baseUrl);
+  if (takeParam) url.searchParams.set("take", takeParam.toString());
+  if (skipParam) url.searchParams.set("skip", skipParam.toString());
+  if (sort) url.searchParams.set("sort", sort);
+  if (order) url.searchParams.set("order", order);
+  if (filter) url.searchParams.set("filter", filter);
+  if (organizationId) url.searchParams.set("organizationId", organizationId);
+  const endpoint = url.toString();
+  const json = await client.request(endpoint, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data, meta } = getRegistryExpertsResponseSchema.parse(json);
+  return {
+    experts: data.experts,
+    total: meta.total,
+    take: meta.take,
+    skip: meta.skip
+  };
+}
+var getRegistryExpertVersionsInput = z.object({
+  expertKey: apiRegistryExpertSchema.shape.key
+});
+var getRegistryExpertVersionsResponseSchema = z.object({
+  data: z.object({
+    versions: z.array(apiExpertDigestSchema),
+    latest: z.string()
+  }),
+  meta: z.object({
+    total: z.number()
+  })
+});
+async function getRegistryExpertVersions(input, client) {
+  const { expertKey } = getRegistryExpertVersionsInput.parse(input);
+  const endpoint = `/api/registry/v1/experts/${encodeURIComponent(expertKey)}/versions`;
+  const json = await client.request(endpoint, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data, meta } = getRegistryExpertVersionsResponseSchema.parse(json);
+  return {
+    versions: data.versions,
+    latest: data.latest,
+    total: meta.total
+  };
+}
+var deleteRegistryExpertInput = z.object({
+  expertKey: apiRegistryExpertSchema.shape.key
+});
+async function deleteRegistryExpert(input, client) {
+  const { expertKey } = deleteRegistryExpertInput.parse(input);
+  const endpoint = `/api/registry/v1/experts/${encodeURIComponent(expertKey)}`;
+  await client.requestAuthenticated(endpoint, {
+    method: "DELETE",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+var apiWorkspaceItemOwnerSchema = z.union([z.literal("user"), z.literal("expert")]);
+var apiWorkspaceItemLifecycleSchema = z.union([
+  z.literal("application"),
+  z.literal("expertJob")
+]);
+var apiWorkspaceItemPermissionSchema = z.union([
+  z.literal("readOnly"),
+  z.literal("readWrite")
+]);
+var apiBaseWorkspaceItemSchema = z.object({
+  id: z.cuid2(),
+  owner: apiWorkspaceItemOwnerSchema,
+  lifecycle: apiWorkspaceItemLifecycleSchema,
+  permission: apiWorkspaceItemPermissionSchema,
+  path: z.string().min(1).max(1024),
+  createdAt: z.iso.datetime().transform((date) => new Date(date)),
+  updatedAt: z.iso.datetime().transform((date) => new Date(date))
+});
+var apiWorkspaceItemDirectorySchema = apiBaseWorkspaceItemSchema.extend({
+  type: z.literal("workspaceItemDirectory")
+});
+var apiWorkspaceItemFileSchema = apiBaseWorkspaceItemSchema.extend({
+  type: z.literal("workspaceItemFile"),
+  key: z.string().min(1).max(1024),
+  mimeType: z.string().max(256),
+  size: z.number().min(0)
+});
+var apiWorkspaceItemSchema = z.discriminatedUnion("type", [
+  apiWorkspaceItemDirectorySchema,
+  apiWorkspaceItemFileSchema
+]);
+
+// v1/schemas/checkpoint.ts
+var apiCheckpointStatusSchema = z.union([
+  z.literal("init"),
+  z.literal("proceeding"),
+  z.literal("completed"),
+  z.literal("stoppedByInteractiveTool"),
+  z.literal("stoppedByDelegate"),
+  z.literal("stoppedByExceededMaxSteps"),
+  z.literal("stoppedByError")
+]);
+var apiBaseCheckpointActionSchema = z.object({
+  error: z.string().optional()
+});
+var apiCheckpointActionRetrySchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("retry"),
+  error: z.string(),
+  message: z.string()
+});
+var apiCheckpointActionAttemptCompletionSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("attemptCompletion"),
+  result: z.string()
+});
+var apiCheckpointActionThinkSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("think"),
+  thought: z.string()
+});
+var apiCheckpointActionTodoSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("todo"),
+  newTodos: z.array(z.string()),
+  completedTodos: z.array(z.number()),
+  todos: z.array(
+    z.object({
+      id: z.number(),
+      title: z.string(),
+      completed: z.boolean()
+    })
+  )
+});
+var apiCheckpointActionReadImageFileSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("readImageFile"),
+  path: z.string(),
+  mimeType: z.string().optional(),
+  size: z.number().optional()
+});
+var apiCheckpointActionReadPdfFileSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("readPdfFile"),
+  path: z.string(),
+  mimeType: z.string().optional(),
+  size: z.number().optional()
+});
+var apiCheckpointActionReadTextFileSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("readTextFile"),
+  path: z.string(),
+  content: z.string(),
+  from: z.number().optional(),
+  to: z.number().optional()
+});
+var apiCheckpointActionEditTextFileSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("editTextFile"),
+  path: z.string(),
+  newText: z.string().optional(),
+  oldText: z.string().optional()
+});
+var apiCheckpointActionAppendTextFileSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("appendTextFile"),
+  path: z.string(),
+  text: z.string()
+});
+var apiCheckpointActionDeleteFileSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("deleteFile"),
+  path: z.string()
+});
+var apiCheckpointActionMoveFileSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("moveFile"),
+  source: z.string(),
+  destination: z.string()
+});
+var apiCheckpointActionGetFileInfoSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("getFileInfo"),
+  path: z.string(),
+  exists: z.boolean(),
+  absolutePath: z.string(),
+  name: z.string(),
+  directory: z.string(),
+  extension: z.string().optional(),
+  mimeType: z.string().optional(),
+  size: z.number(),
+  sizeFormatted: z.string(),
+  created: z.date(),
+  modified: z.date(),
+  accessed: z.date(),
+  permissions: z.object({
+    readable: z.boolean(),
+    writable: z.boolean(),
+    executable: z.boolean()
+  }),
+  workspaceItem: apiWorkspaceItemSchema.optional()
+});
+var apiCheckpointActionWriteTextFileSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("writeTextFile"),
+  path: z.string(),
+  text: z.string()
+});
+var apiCheckpointActionCreateDirectorySchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("createDirectory"),
+  path: z.string()
+});
+var apiCheckpointActionListDirectorySchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("listDirectory"),
+  path: z.string(),
+  items: z.array(
+    z.object({
+      name: z.string(),
+      path: z.string(),
+      type: z.union([z.literal("directory"), z.literal("file")]),
+      size: z.number(),
+      modified: z.date()
+    })
+  )
+});
+var apiCheckpointActionTestUrlSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("testUrl"),
+  results: z.array(
+    z.object({
+      url: z.string(),
+      status: z.number(),
+      title: z.string(),
+      description: z.string()
+    })
+  )
+});
+var apiCheckpointActionDelegateSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("delegate"),
+  delegateTo: apiExpertDigestSchema,
+  query: z.string()
+});
+var apiCheckpointActionGeneralToolSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("generalTool"),
+  skillName: z.string().min(1).max(256),
+  toolName: z.string().min(1).max(256),
+  args: z.record(z.string().min(1).max(256), z.unknown()),
+  result: z.array(messagePartSchema)
+});
+var apiCheckpointActionErrorSchema = apiBaseCheckpointActionSchema.extend({
+  type: z.literal("error")
+});
+var apiCheckpointActionSchema = z.discriminatedUnion("type", [
+  apiCheckpointActionRetrySchema,
+  apiCheckpointActionAttemptCompletionSchema,
+  apiCheckpointActionThinkSchema,
+  apiCheckpointActionTodoSchema,
+  apiCheckpointActionReadImageFileSchema,
+  apiCheckpointActionReadPdfFileSchema,
+  apiCheckpointActionReadTextFileSchema,
+  apiCheckpointActionEditTextFileSchema,
+  apiCheckpointActionAppendTextFileSchema,
+  apiCheckpointActionDeleteFileSchema,
+  apiCheckpointActionMoveFileSchema,
+  apiCheckpointActionGetFileInfoSchema,
+  apiCheckpointActionWriteTextFileSchema,
+  apiCheckpointActionCreateDirectorySchema,
+  apiCheckpointActionListDirectorySchema,
+  apiCheckpointActionTestUrlSchema,
+  apiCheckpointActionDelegateSchema,
+  apiCheckpointActionGeneralToolSchema,
+  apiCheckpointActionErrorSchema
+]);
+var apiCheckpointSchema = z.object({
+  type: z.literal("checkpoint"),
+  id: z.cuid2(),
+  action: apiCheckpointActionSchema,
+  expertJobId: z.cuid2(),
+  stepNumber: z.number().min(0),
+  status: apiCheckpointStatusSchema,
+  expert: apiExpertDigestSchema,
+  skillName: z.string().min(1).max(maxSkillNameLength).optional(),
+  toolName: z.string().min(1).max(maxSkillToolNameLength).optional(),
+  delegateTo: z.object({
+    expert: apiExpertDigestSchema,
+    toolCallId: z.string().min(1).max(maxCheckpointToolCallIdLength),
+    toolName: z.string().min(1).max(maxSkillToolNameLength)
+  }).optional(),
+  delegatedBy: z.object({
+    expert: apiExpertDigestSchema,
+    toolCallId: z.string().min(1).max(maxCheckpointToolCallIdLength),
+    toolName: z.string().min(1).max(maxSkillToolNameLength),
+    checkpointId: z.cuid2()
+  }).optional(),
+  inputMessages: z.array(z.union([instructionMessageSchema, userMessageSchema, toolMessageSchema])).optional(),
+  messages: z.array(messageSchema),
+  newMessages: z.array(messageSchema),
+  toolCall: toolCallSchema.optional(),
+  toolResult: toolResultSchema.optional(),
+  usage: usageSchema,
+  contextWindow: z.number().min(0),
+  contextWindowUsage: z.number().min(0),
+  startedAt: z.iso.datetime().transform((date) => new Date(date)),
+  finishedAt: z.iso.datetime().transform((date) => new Date(date)).optional()
+});
+var apiExpertJobStatusSchema = z.union([
+  z.literal("queued"),
+  z.literal("processing"),
+  z.literal("completed"),
+  z.literal("requestInteractiveToolResult"),
+  z.literal("requestDelegateResult"),
+  z.literal("exceededMaxSteps"),
+  z.literal("failed"),
+  z.literal("canceling"),
+  z.literal("canceled"),
+  z.literal("expired")
+]);
+var apiExpertJobSchema = z.object({
+  type: z.literal("expertJob"),
+  id: z.cuid2(),
+  status: apiExpertJobStatusSchema,
+  runtimeVersion: apiRuntimeVersionSchema,
+  expertKey: apiBaseExpertSchema.shape.key,
+  query: z.string().min(1).max(1024 * 20).optional(),
+  files: z.array(
+    z.string().min(1).max(1024 * 20)
+  ).optional(),
+  expert: apiExpertSchema,
+  model: z.string().min(1).max(256),
+  temperature: z.number().min(0).max(1).optional(),
+  maxSteps: z.number().min(1).optional(),
+  maxRetries: z.number().min(0).optional(),
+  currentStep: z.number().min(0).optional(),
+  totalSteps: z.number().min(0).optional(),
+  totalDuration: z.number().min(0).optional(),
+  usage: usageSchema,
+  createdAt: z.iso.datetime().transform((date) => new Date(date)),
+  updatedAt: z.iso.datetime().transform((date) => new Date(date)),
+  applicationId: z.cuid2()
+});
+
+// v1/studio/expert-jobs.ts
+var startExpertJobInput = z.object({
+  expertKey: apiBaseExpertSchema.shape.key,
+  query: apiExpertJobSchema.shape.query,
+  files: apiExpertJobSchema.shape.files,
+  model: apiExpertJobSchema.shape.model,
+  temperature: apiExpertJobSchema.shape.temperature,
+  maxSteps: apiExpertJobSchema.shape.maxSteps,
+  maxRetries: apiExpertJobSchema.shape.maxRetries
+});
+var startExpertJobResponseSchema = z.object({
+  data: z.object({
+    expertJob: apiExpertJobSchema
+  })
+});
+async function startExpertJob(input, client) {
+  const { expertKey, query, files, model, temperature, maxSteps, maxRetries } = startExpertJobInput.parse(input);
+  if ((!query || query === "") && (!files || files.length === 0)) {
+    throw new Error("Either query or files must be provided");
+  }
+  const endpoint = "/api/studio/v1/expert_jobs";
+  const formData = new FormData();
+  formData.append("expertKey", expertKey);
+  if (query) formData.append("query", query);
+  if (temperature) formData.append("temperature", temperature.toString());
+  if (maxSteps) formData.append("maxSteps", maxSteps.toString());
+  if (maxRetries) formData.append("maxRetries", maxRetries.toString());
+  if (model) formData.append("model", model);
+  if (files && files.length > 0) {
+    for (const file of files) {
+      formData.append("files", file);
+    }
+  }
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    body: formData
+  });
+  const { data } = startExpertJobResponseSchema.parse(json);
+  return {
+    expertJob: data.expertJob
+  };
+}
+var continueExpertJobInput = z.object({
+  expertJobId: apiExpertJobSchema.shape.id,
+  query: apiExpertJobSchema.shape.query,
+  files: apiExpertJobSchema.shape.files,
+  model: apiExpertJobSchema.shape.model,
+  temperature: apiExpertJobSchema.shape.temperature,
+  maxSteps: apiExpertJobSchema.shape.maxSteps,
+  maxRetries: apiExpertJobSchema.shape.maxRetries
+});
+var continueExpertJobResponseSchema = z.object({
+  data: z.object({
+    expertJob: apiExpertJobSchema
+  })
+});
+async function continueExpertJob(input, client) {
+  const { expertJobId, query, files, model, temperature, maxSteps, maxRetries } = continueExpertJobInput.parse(input);
+  if ((!query || query === "") && (!files || files.length === 0)) {
+    throw new Error("Either query or files must be provided");
+  }
+  const endpoint = `/api/studio/v1/expert_jobs/${expertJobId}/continue`;
+  const formData = new FormData();
+  if (query) formData.append("query", query);
+  if (model) formData.append("model", model);
+  if (temperature) formData.append("temperature", temperature.toString());
+  if (maxSteps) formData.append("maxSteps", maxSteps.toString());
+  if (maxRetries) formData.append("maxRetries", maxRetries.toString());
+  if (files) {
+    for (const file of files) {
+      formData.append("files", file);
+    }
+  }
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    body: formData
+  });
+  const { data } = continueExpertJobResponseSchema.parse(json);
+  return {
+    expertJob: data.expertJob
+  };
+}
+var resumeExpertJobFromCheckpointInput = z.object({
+  expertJobId: apiExpertJobSchema.shape.id,
+  checkpointId: apiCheckpointSchema.shape.id,
+  query: apiExpertJobSchema.shape.query,
+  files: apiExpertJobSchema.shape.files,
+  model: apiExpertJobSchema.shape.model,
+  temperature: apiExpertJobSchema.shape.temperature,
+  maxSteps: apiExpertJobSchema.shape.maxSteps,
+  maxRetries: apiExpertJobSchema.shape.maxRetries
+});
+var resumeExpertJobFromCheckpointResponseSchema = z.object({
+  data: z.object({
+    expertJob: apiExpertJobSchema
+  })
+});
+async function resumeExpertJobFromCheckpoint(input, client) {
+  const { expertJobId, checkpointId, query, files, model, temperature, maxSteps, maxRetries } = resumeExpertJobFromCheckpointInput.parse(input);
+  if ((!query || query === "") && (!files || files.length === 0)) {
+    throw new Error("Either query or files must be provided");
+  }
+  const endpoint = `/api/studio/v1/expert_jobs/${expertJobId}/resume_from`;
+  const formData = new FormData();
+  formData.append("checkpointId", checkpointId);
+  if (query) formData.append("query", query);
+  if (model) formData.append("model", model);
+  if (temperature) formData.append("temperature", temperature.toString());
+  if (maxSteps) formData.append("maxSteps", maxSteps.toString());
+  if (maxRetries) formData.append("maxRetries", maxRetries.toString());
+  if (files) {
+    for (const file of files) {
+      formData.append("files", file);
+    }
+  }
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    body: formData
+  });
+  const { data } = resumeExpertJobFromCheckpointResponseSchema.parse(json);
+  return {
+    expertJob: data.expertJob
+  };
+}
+var getExpertJobInput = z.object({
+  expertJobId: apiExpertJobSchema.shape.id
+});
+var getExpertJobResponseSchema = z.object({
+  data: z.object({
+    expertJob: apiExpertJobSchema
+  })
+});
+async function getExpertJob(input, client) {
+  const { expertJobId } = getExpertJobInput.parse(input);
+  const endpoint = `/api/studio/v1/expert_jobs/${expertJobId}`;
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data } = getExpertJobResponseSchema.parse(json);
+  return {
+    expertJob: data.expertJob
+  };
+}
+var getExpertJobsInput = z.object({
+  take: z.union([z.number(), z.string().transform((value) => Number.parseInt(value))]).optional(),
+  skip: z.union([z.number(), z.string().transform((value) => Number.parseInt(value))]).optional(),
+  sort: z.string().optional(),
+  order: z.string().optional(),
+  filter: z.string().optional()
+});
+var getExpertJobsResponseSchema = z.object({
+  data: z.object({
+    expertJobs: apiExpertJobSchema.array()
+  }),
+  meta: z.object({
+    total: z.number(),
+    take: z.number(),
+    skip: z.number()
+  })
+});
+async function getExpertJobs(input, client) {
+  const { sort, order, take, skip, filter } = getExpertJobsInput.parse(input);
+  const url = new URL("/api/studio/v1/expert_jobs", client.baseUrl);
+  const searchParams = url.searchParams;
+  if (sort) searchParams.set("sort", sort);
+  if (order) searchParams.set("order", order);
+  if (take) searchParams.set("take", take.toString());
+  if (skip) searchParams.set("skip", skip.toString());
+  if (filter) searchParams.set("filter", filter);
+  const endpoint = url.toString();
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data, meta } = getExpertJobsResponseSchema.parse(json);
+  return {
+    expertJobs: data.expertJobs,
+    total: meta.total,
+    take: meta.take,
+    skip: meta.skip
+  };
+}
+var updateExpertJobInput = z.object({
+  expertJobId: apiExpertJobSchema.shape.id,
+  status: apiExpertJobSchema.shape.status
+});
+var updateExpertJobResponseSchema = z.object({
+  data: z.object({
+    expertJob: apiExpertJobSchema
+  })
+});
+async function updateExpertJob(input, client) {
+  const { expertJobId, status } = updateExpertJobInput.parse(input);
+  const endpoint = `/api/studio/v1/expert_jobs/${expertJobId}`;
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      status
+    })
+  });
+  const { data } = updateExpertJobResponseSchema.parse(json);
+  return {
+    expertJob: data.expertJob
+  };
+}
+var createCheckpointInput = z.object({
+  expertJobId: apiExpertJobSchema.shape.id,
+  checkpoint: apiCheckpointSchema,
+  step: z.object({
+    stepNumber: z.number(),
+    inputMessages: z.optional(
+      z.array(z.union([instructionMessageSchema, userMessageSchema, toolMessageSchema]))
+    ),
+    newMessages: z.array(messageSchema),
+    toolCall: z.optional(toolCallSchema),
+    toolResult: z.optional(toolResultSchema),
+    usage: usageSchema,
+    startedAt: z.date(),
+    finishedAt: z.optional(z.date())
+  })
+});
+var createCheckpointResponseSchema = z.object({
+  data: z.object({
+    checkpoint: apiCheckpointSchema
+  })
+});
+async function createCheckpoint(input, client) {
+  const { expertJobId, checkpoint, step } = createCheckpointInput.parse(input);
+  const endpoint = `/api/studio/v1/expert_jobs/${expertJobId}/checkpoints`;
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    body: JSON.stringify({
+      checkpoint,
+      step
+    })
+  });
+  const { data } = createCheckpointResponseSchema.parse(json);
+  return {
+    checkpoint: data.checkpoint
+  };
+}
+var getCheckpointInput = z.object({
+  expertJobId: apiExpertJobSchema.shape.id,
+  checkpointId: apiCheckpointSchema.shape.id
+});
+var getCheckpointResponseSchema = z.object({
+  data: z.object({
+    checkpoint: apiCheckpointSchema
+  })
+});
+async function getCheckpoint(input, client) {
+  const { expertJobId, checkpointId } = getCheckpointInput.parse(input);
+  const endpoint = `/api/studio/v1/expert_jobs/${expertJobId}/checkpoints/${checkpointId}`;
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data } = getCheckpointResponseSchema.parse(json);
+  return {
+    checkpoint: data.checkpoint
+  };
+}
+var getCheckpointsInput = z.object({
+  expertJobId: apiExpertJobSchema.shape.id,
+  take: z.union([z.number(), z.string().transform((value) => Number.parseInt(value))]).optional(),
+  skip: z.union([z.number(), z.string().transform((value) => Number.parseInt(value))]).optional(),
+  sort: z.string().optional(),
+  order: z.string().optional(),
+  filter: z.string().optional()
+});
+var getCheckpointsResponseSchema = z.object({
+  data: z.object({
+    checkpoints: apiCheckpointSchema.array()
+  }),
+  meta: z.object({
+    total: z.number(),
+    take: z.number(),
+    skip: z.number()
+  })
+});
+async function getCheckpoints(input, client) {
+  const { expertJobId, sort, order, take, skip, filter } = getCheckpointsInput.parse(input);
+  const url = new URL(`/api/studio/v1/expert_jobs/${expertJobId}/checkpoints`);
+  const searchParams = url.searchParams;
+  if (sort) searchParams.set("sort", sort);
+  if (order) searchParams.set("order", order);
+  if (take) searchParams.set("take", take.toString());
+  if (skip) searchParams.set("skip", skip.toString());
+  if (filter) searchParams.set("filter", filter);
+  const endpoint = url.toString();
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data, meta } = getCheckpointsResponseSchema.parse(json);
+  return {
+    checkpoints: data.checkpoints,
+    total: meta.total,
+    take: meta.take,
+    skip: meta.skip
+  };
+}
+var createStudioExpertInput = z.object({
+  name: apiStudioExpertSchema.shape.name,
+  minRuntimeVersion: apiStudioExpertSchema.shape.minRuntimeVersion,
+  description: apiStudioExpertSchema.shape.description,
+  instruction: apiStudioExpertSchema.shape.instruction,
+  delegates: apiStudioExpertSchema.shape.delegates,
+  skills: apiStudioExpertSchema.shape.skills,
+  forkFrom: apiStudioExpertSchema.shape.forkFrom
+});
+var createStudioExpertResponseSchema = z.object({
+  data: z.object({
+    expert: apiStudioExpertSchema
+  })
+});
+async function createStudioExpert(input, client) {
+  const { name, minRuntimeVersion, description, instruction, skills, delegates, forkFrom } = createStudioExpertInput.parse(input);
+  const endpoint = "/api/studio/v1/experts";
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      name,
+      minRuntimeVersion,
+      description,
+      instruction,
+      skills,
+      delegates,
+      forkFrom
+    })
+  });
+  const { data } = createStudioExpertResponseSchema.parse(json);
+  return {
+    expert: data.expert
+  };
+}
+var getStudioExpertInput = z.object({
+  expertKey: apiStudioExpertSchema.shape.key
+});
+var getStudioExpertResponseSchema = z.object({
+  data: z.object({
+    expert: apiStudioExpertSchema
+  })
+});
+async function getStudioExpert(input, client) {
+  const { expertKey } = getStudioExpertInput.parse(input);
+  const endpoint = `/api/studio/v1/experts/${encodeURIComponent(expertKey)}`;
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data } = getStudioExpertResponseSchema.parse(json);
+  return {
+    expert: data.expert
+  };
+}
+var getStudioExpertsInput = z.object({
+  take: z.union([z.number(), z.string().transform((value) => Number.parseInt(value))]).optional(),
+  skip: z.union([z.number(), z.string().transform((value) => Number.parseInt(value))]).optional(),
+  sort: z.string().optional(),
+  order: z.string().optional(),
+  filter: z.string().optional()
+});
+var getStudioExpertsResponseSchema = z.object({
+  data: z.object({
+    experts: z.array(apiStudioExpertSchema)
+  }),
+  meta: z.object({
+    total: z.number(),
+    take: z.number(),
+    skip: z.number()
+  })
+});
+async function getStudioExperts(input, client) {
+  const { sort, order, take, skip, filter } = getStudioExpertsInput.parse(input);
+  const url = new URL("/api/studio/v1/experts", client.baseUrl);
+  if (take) url.searchParams.set("take", take.toString());
+  if (skip) url.searchParams.set("skip", skip.toString());
+  if (sort) url.searchParams.set("sort", sort);
+  if (order) url.searchParams.set("order", order);
+  if (filter) url.searchParams.set("filter", filter);
+  const endpoint = url.toString();
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "GET",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data, meta } = getStudioExpertsResponseSchema.parse(json);
+  return {
+    experts: data.experts,
+    total: meta.total,
+    take: meta.take,
+    skip: meta.skip
+  };
+}
+var updateStudioExpertInput = z.object({
+  expertKey: apiStudioExpertSchema.shape.key,
+  minRuntimeVersion: apiStudioExpertSchema.shape.minRuntimeVersion,
+  description: apiStudioExpertSchema.shape.description,
+  instruction: apiStudioExpertSchema.shape.instruction,
+  delegates: apiStudioExpertSchema.shape.delegates,
+  skills: apiStudioExpertSchema.shape.skills,
+  forkFrom: apiStudioExpertSchema.shape.forkFrom
+});
+var updateStudioExpertResponseSchema = z.object({
+  data: z.object({
+    expert: apiStudioExpertSchema
+  })
+});
+async function updateStudioExpert(input, client) {
+  const { expertKey, minRuntimeVersion, description, instruction, skills, delegates, forkFrom } = updateStudioExpertInput.parse(input);
+  const endpoint = `/api/studio/v1/experts/${encodeURIComponent(expertKey)}`;
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      minRuntimeVersion,
+      description,
+      instruction,
+      skills,
+      delegates,
+      forkFrom
+    })
+  });
+  const { data } = updateStudioExpertResponseSchema.parse(json);
+  return {
+    expert: data.expert
+  };
+}
+var deleteStudioExpertInput = z.object({
+  expertKey: apiStudioExpertSchema.shape.key
+});
+async function deleteStudioExpert(input, client) {
+  const { expertKey } = deleteStudioExpertInput.parse(input);
+  const endpoint = `/api/studio/v1/experts/${encodeURIComponent(expertKey)}`;
+  await client.requestAuthenticated(endpoint, {
+    method: "DELETE",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+var apiWorkspaceInstanceSchema = z.object({
+  type: z.literal("workspaceInstance"),
+  id: z.cuid2(),
+  applicationId: z.cuid2(),
+  application: apiApplicationSchema,
+  expertJob: apiExpertJobSchema,
+  createdAt: z.iso.datetime().transform((date) => new Date(date)),
+  updatedAt: z.iso.datetime().transform((date) => new Date(date)),
+  items: z.array(apiWorkspaceItemSchema),
+  countItems: z.number(),
+  envVariables: z.array(z.string()),
+  envSecrets: z.array(z.string())
+});
+
+// v1/studio/workspace-instance.ts
+var getWorkspaceInstanceInput = z.object({
+  expertJobId: z.string()
+});
+var getWorkspaceInstanceResponseSchema = z.object({
+  data: z.object({
+    workspaceInstance: apiWorkspaceInstanceSchema
+  })
+});
+async function getWorkspaceInstance(input, client) {
+  const { expertJobId } = getWorkspaceInstanceInput.parse(input);
+  const endpoint = `/api/studio/v1/expert_jobs/${expertJobId}/workspace_instance`;
+  const json = await client.requestAuthenticated(endpoint, {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data } = getWorkspaceInstanceResponseSchema.parse(json);
+  return {
+    workspaceInstance: data.workspaceInstance
+  };
+}
+var createWorkspaceInstanceItemInput = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("workspaceItemDirectory"),
+    expertJobId: apiExpertJobSchema.shape.id,
+    permission: apiWorkspaceItemPermissionSchema,
+    path: apiBaseWorkspaceItemSchema.shape.path
+  }),
+  z.object({
+    type: z.literal("workspaceItemFile"),
+    expertJobId: apiExpertJobSchema.shape.id,
+    permission: apiWorkspaceItemPermissionSchema,
+    path: apiBaseWorkspaceItemSchema.shape.path,
+    file: z.instanceof(File)
+  })
+]);
+var createWorkspaceInstanceItemResponseSchema = z.object({
+  data: z.object({
+    workspaceItem: apiWorkspaceItemSchema
+  })
+});
+async function createWorkspaceInstanceItem(input, client) {
+  const validatedInput = createWorkspaceInstanceItemInput.parse(input);
+  const endpoint = `/api/studio/v1/expert_jobs/${validatedInput.expertJobId}/workspace_instance/items`;
+  const formData = new FormData();
+  formData.append("type", validatedInput.type);
+  formData.append("path", validatedInput.path);
+  formData.append("permission", validatedInput.permission);
+  if (validatedInput.type === "workspaceItemFile") {
+    formData.append("file", validatedInput.file);
+  }
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    body: formData
+  });
+  const { data } = createWorkspaceInstanceItemResponseSchema.parse(json);
+  return {
+    workspaceItem: data.workspaceItem
+  };
+}
+var getWorkspaceInstanceItemInput = z.object({
+  expertJobId: z.string(),
+  itemId: z.string()
+});
+var getWorkspaceInstanceItemResponseSchema = z.object({
+  data: z.object({
+    workspaceItem: apiWorkspaceItemSchema
+  })
+});
+async function getWorkspaceInstanceItem(input, client) {
+  const { expertJobId, itemId } = getWorkspaceInstanceItemInput.parse(input);
+  const endpoint = `/api/studio/v1/expert_jobs/${expertJobId}/workspace_instance/items/${itemId}`;
+  const json = await client.requestAuthenticated(endpoint, {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data } = getWorkspaceInstanceItemResponseSchema.parse(json);
+  return {
+    workspaceItem: data.workspaceItem
+  };
+}
+var getWorkspaceInstanceItemsInput = z.object({
+  expertJobId: z.string(),
+  take: z.union([z.number(), z.string().transform((value) => Number.parseInt(value))]).optional(),
+  skip: z.union([z.number(), z.string().transform((value) => Number.parseInt(value))]).optional()
+});
+var getWorkspaceInstanceItemsResponseSchema = z.object({
+  data: z.object({
+    workspaceItems: z.array(apiWorkspaceItemSchema)
+  }),
+  meta: z.object({
+    total: z.number(),
+    take: z.number(),
+    skip: z.number()
+  })
+});
+async function getWorkspaceInstanceItems(input, client) {
+  const { expertJobId, take, skip } = getWorkspaceInstanceItemsInput.parse(input);
+  const url = new URL(`/api/studio/v1/expert_jobs/${expertJobId}/workspace_instance/items`);
+  if (take) url.searchParams.set("take", take.toString());
+  if (skip) url.searchParams.set("skip", skip.toString());
+  const endpoint = url.toString();
+  const json = await client.requestAuthenticated(endpoint, {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data, meta } = getWorkspaceInstanceItemsResponseSchema.parse(json);
+  return {
+    workspaceItems: data.workspaceItems,
+    total: meta.total,
+    take: meta.take,
+    skip: meta.skip
+  };
+}
+var downloadWorkspaceInstanceItemInput = z.object({
+  expertJobId: z.string(),
+  itemId: z.string()
+});
+z.object({
+  data: z.object({
+    workspaceItem: apiWorkspaceItemSchema
+  })
+});
+async function downloadWorkspaceInstanceItem(input, client) {
+  const { expertJobId, itemId } = downloadWorkspaceInstanceItemInput.parse(input);
+  const endpoint = `/api/studio/v1/expert_jobs/${expertJobId}/workspace_instance/items/${itemId}/download`;
+  const blob = await client.requestBlobAuthenticated(endpoint, {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  return blob;
+}
+var updateWorkspaceInstanceItemInput = z.object({
+  expertJobId: apiExpertJobSchema.shape.id,
+  itemId: z.string(),
+  permission: apiWorkspaceItemPermissionSchema.optional(),
+  path: apiBaseWorkspaceItemSchema.shape.path.optional(),
+  lifecycle: apiWorkspaceItemLifecycleSchema.optional()
+});
+var updateWorkspaceInstanceItemResponseSchema = z.object({
+  data: z.object({
+    workspaceItem: apiWorkspaceItemSchema
+  })
+});
+async function updateWorkspaceInstanceItem(input, client) {
+  const { expertJobId, itemId, permission, path, lifecycle } = updateWorkspaceInstanceItemInput.parse(input);
+  const endpoint = `/api/studio/v1/expert_jobs/${expertJobId}/workspace_instance/items/${itemId}`;
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ permission, path, lifecycle })
+  });
+  const { data } = updateWorkspaceInstanceItemResponseSchema.parse(json);
+  return {
+    workspaceItem: data.workspaceItem
+  };
+}
+var deleteWorkspaceInstanceItemInput = z.object({
+  expertJobId: apiExpertJobSchema.shape.id,
+  itemId: z.string()
+});
+async function deleteWorkspaceInstanceItem(input, client) {
+  const { expertJobId, itemId } = deleteWorkspaceInstanceItemInput.parse(input);
+  const endpoint = `/api/studio/v1/expert_jobs/${expertJobId}/workspace_instance/items/${itemId}`;
+  await client.requestAuthenticated(endpoint, {
+    method: "DELETE",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+var apiWorkspaceSchema = z.object({
+  type: z.literal("workspace"),
+  id: z.cuid2(),
+  applicationId: z.cuid2(),
+  application: apiApplicationSchema,
+  createdAt: z.iso.datetime().transform((date) => new Date(date)),
+  updatedAt: z.iso.datetime().transform((date) => new Date(date)),
+  items: z.array(apiWorkspaceItemSchema),
+  countItems: z.number(),
+  envVariables: z.array(z.string()),
+  envSecrets: z.array(z.string()),
+  countWorkspaceInstances: z.number()
+});
+
+// v1/studio/workspace.ts
+var getWorkspaceResponseSchema = z.object({
+  data: z.object({
+    workspace: apiWorkspaceSchema
+  })
+});
+async function getWorkspace(client) {
+  const endpoint = "/api/studio/v1/workspace";
+  const json = await client.requestAuthenticated(endpoint, {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data } = getWorkspaceResponseSchema.parse(json);
+  return {
+    workspace: data.workspace
+  };
+}
+var createWorkspaceItemInput = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("workspaceItemDirectory"),
+    permission: apiWorkspaceItemPermissionSchema,
+    path: z.string()
+  }),
+  z.object({
+    type: z.literal("workspaceItemFile"),
+    permission: apiWorkspaceItemPermissionSchema,
+    path: z.string(),
+    file: z.instanceof(File)
+  })
+]);
+var createWorkspaceItemResponseSchema = z.object({
+  data: z.object({
+    workspaceItem: apiWorkspaceItemSchema
+  })
+});
+async function createWorkspaceItem(input, client) {
+  const validatedInput = createWorkspaceItemInput.parse(input);
+  const endpoint = "/api/studio/v1/workspace/items";
+  const formData = new FormData();
+  formData.append("type", validatedInput.type);
+  formData.append("permission", validatedInput.permission);
+  formData.append("path", validatedInput.path);
+  if (validatedInput.type === "workspaceItemFile") {
+    formData.append("file", validatedInput.file);
+  }
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    body: formData
+  });
+  const { data } = createWorkspaceItemResponseSchema.parse(json);
+  return {
+    workspaceItem: data.workspaceItem
+  };
+}
+var getWorkspaceItemInput = z.object({
+  itemId: z.string()
+});
+var getWorkspaceItemResponseSchema = z.object({
+  data: z.object({
+    workspaceItem: apiWorkspaceItemSchema
+  })
+});
+async function getWorkspaceItem(input, client) {
+  const { itemId } = getWorkspaceItemInput.parse(input);
+  const endpoint = `/api/studio/v1/workspace/items/${itemId}`;
+  const json = await client.requestAuthenticated(endpoint, {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data } = getWorkspaceItemResponseSchema.parse(json);
+  return {
+    workspaceItem: data.workspaceItem
+  };
+}
+var getWorkspaceItemsInput = z.object({
+  take: z.union([z.number(), z.string().transform((value) => Number.parseInt(value))]).optional(),
+  skip: z.union([z.number(), z.string().transform((value) => Number.parseInt(value))]).optional()
+});
+var getWorkspaceItemsResponseSchema = z.object({
+  data: z.object({
+    workspaceItems: z.array(apiWorkspaceItemSchema)
+  }),
+  meta: z.object({
+    total: z.number(),
+    take: z.number(),
+    skip: z.number()
+  })
+});
+async function getWorkspaceItems(input, client) {
+  const { take, skip } = getWorkspaceItemsInput.parse(input);
+  const url = new URL("/api/studio/v1/workspace/items", client.baseUrl);
+  if (take) url.searchParams.set("take", take.toString());
+  if (skip) url.searchParams.set("skip", skip.toString());
+  const endpoint = url.toString();
+  const json = await client.requestAuthenticated(endpoint, {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const { data, meta } = getWorkspaceItemsResponseSchema.parse(json);
+  return {
+    workspaceItems: data.workspaceItems,
+    total: meta.total,
+    take: meta.take,
+    skip: meta.skip
+  };
+}
+var downloadWorkspaceItemInput = z.object({
+  itemId: z.string()
+});
+async function downloadWorkspaceItem(input, client) {
+  const { itemId } = downloadWorkspaceItemInput.parse(input);
+  const endpoint = `/api/studio/v1/workspace/items/${itemId}/download`;
+  const blob = await client.requestBlobAuthenticated(endpoint, {
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  return blob;
+}
+var updateWorkspaceItemInput = z.object({
+  itemId: z.string(),
+  permission: apiWorkspaceItemPermissionSchema.optional(),
+  path: z.string().min(1).max(1024).optional(),
+  lifecycle: apiWorkspaceItemLifecycleSchema.optional()
+});
+var updateWorkspaceItemResponseSchema = z.object({
+  data: z.object({
+    workspaceItem: apiWorkspaceItemSchema
+  })
+});
+async function updateWorkspaceItem(input, client) {
+  const { itemId, permission, path, lifecycle } = updateWorkspaceItemInput.parse(input);
+  const endpoint = `/api/studio/v1/workspace/items/${itemId}`;
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ permission, path, lifecycle })
+  });
+  const { data } = updateWorkspaceItemResponseSchema.parse(json);
+  return {
+    workspaceItem: data.workspaceItem
+  };
+}
+var deleteWorkspaceItemInput = z.object({
+  itemId: z.string()
+});
+async function deleteWorkspaceItem(input, client) {
+  const { itemId } = deleteWorkspaceItemInput.parse(input);
+  const endpoint = `/api/studio/v1/workspace/items/${itemId}`;
+  await client.requestAuthenticated(endpoint, {
+    method: "DELETE",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+var createWorkspaceVariableInput = z.object({
+  name: z.string(),
+  value: z.string()
+});
+var createWorkspaceVariableResponseSchema = z.object({
+  data: z.object({
+    workspace: apiWorkspaceSchema
+  })
+});
+async function createWorkspaceVariable(input, client) {
+  const { name, value } = createWorkspaceVariableInput.parse(input);
+  const endpoint = "/api/studio/v1/workspace/variables";
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ name, value })
+  });
+  const { data } = createWorkspaceVariableResponseSchema.parse(json);
+  return {
+    workspace: data.workspace
+  };
+}
+var updateWorkspaceVariableInput = z.object({
+  name: z.string(),
+  value: z.string()
+});
+var updateWorkspaceVariableResponseSchema = z.object({
+  data: z.object({
+    workspace: apiWorkspaceSchema
+  })
+});
+async function updateWorkspaceVariable(input, client) {
+  const { name, value } = updateWorkspaceVariableInput.parse(input);
+  const endpoint = `/api/studio/v1/workspace/variables/${name}`;
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ name, value })
+  });
+  const { data } = updateWorkspaceVariableResponseSchema.parse(json);
+  return {
+    workspace: data.workspace
+  };
+}
+var deleteWorkspaceVariableInput = z.object({
+  name: z.string()
+});
+async function deleteWorkspaceVariable(input, client) {
+  const { name } = deleteWorkspaceVariableInput.parse(input);
+  const endpoint = `/api/studio/v1/workspace/variables/${name}`;
+  await client.requestAuthenticated(endpoint, {
+    method: "DELETE",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+var createWorkspaceSecretInput = z.object({
+  name: z.string(),
+  value: z.string()
+});
+var createWorkspaceSecretResponseSchema = z.object({
+  data: z.object({
+    workspace: apiWorkspaceSchema
+  })
+});
+async function createWorkspaceSecret(input, client) {
+  const { name, value } = createWorkspaceSecretInput.parse(input);
+  const endpoint = "/api/studio/v1/workspace/secrets";
+  const json = await client.requestAuthenticated(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ name, value })
+  });
+  const { data } = createWorkspaceSecretResponseSchema.parse(json);
+  return {
+    workspace: data.workspace
+  };
+}
+var deleteWorkspaceSecretInput = z.object({
+  name: z.string()
+});
+async function deleteWorkspaceSecret(input, client) {
+  const { name } = deleteWorkspaceSecretInput.parse(input);
+  const endpoint = `/api/studio/v1/workspace/secrets/${name}`;
+  await client.requestAuthenticated(endpoint, {
+    method: "DELETE",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+
+// v1/client.ts
+var ApiV1Client = class {
+  baseUrl;
+  apiKey;
+  constructor(config) {
+    this.baseUrl = config?.baseUrl ? config.baseUrl : "https://api.perstack.ai";
+    this.apiKey = config?.apiKey;
+  }
+  async request(endpoint, init) {
+    const url = new URL(endpoint, this.baseUrl);
+    const response = await fetch(url.toString(), init);
+    if (!response.ok) {
+      throw new Error(`Failed to request ${url.toString()}: ${response.statusText}`);
+    }
+    return await response.json();
+  }
+  async requestAuthenticated(endpoint, init) {
+    if (!this.apiKey) {
+      throw new Error("API key is not set");
+    }
+    return this.request(endpoint, {
+      ...init,
+      headers: {
+        ...init?.headers,
+        Authorization: `Bearer ${this.apiKey}`
+        // Override
+      }
+    });
+  }
+  async requestBlob(endpoint, init) {
+    const url = new URL(endpoint, this.baseUrl);
+    const response = await fetch(url.toString(), init);
+    if (!response.ok) {
+      throw new Error(`Failed to request ${url.toString()}: ${response.statusText}`);
+    }
+    return await response.blob();
+  }
+  async requestBlobAuthenticated(endpoint, init) {
+    if (!this.apiKey) {
+      throw new Error("API key is not set");
+    }
+    return this.requestBlob(endpoint, {
+      ...init,
+      headers: {
+        ...init?.headers,
+        Authorization: `Bearer ${this.apiKey}`
+        // Override
+      }
+    });
+  }
+  registry = {
+    experts: {
+      create: (input) => createRegistryExpert(input, this),
+      get: (input) => getRegistryExpert(input, this),
+      getMany: (input) => getRegistryExperts(input, this),
+      getVersions: (input) => getRegistryExpertVersions(input, this),
+      delete: (input) => deleteRegistryExpert(input, this)
+    }
+  };
+  studio = {
+    experts: {
+      create: (input) => createStudioExpert(input, this),
+      get: (input) => getStudioExpert(input, this),
+      getMany: (input) => getStudioExperts(input, this),
+      update: (input) => updateStudioExpert(input, this),
+      delete: (input) => deleteStudioExpert(input, this)
+    },
+    expertJobs: {
+      start: (input) => startExpertJob(input, this),
+      continue: (input) => continueExpertJob(input, this),
+      resumeFromCheckpoint: (input) => resumeExpertJobFromCheckpoint(input, this),
+      get: (input) => getExpertJob(input, this),
+      getMany: (input) => getExpertJobs(input, this),
+      update: (input) => updateExpertJob(input, this),
+      checkpoints: {
+        create: (input) => createCheckpoint(input, this),
+        get: (input) => getCheckpoint(input, this),
+        getMany: (input) => getCheckpoints(input, this)
+      },
+      workspaceInstance: {
+        get: (input) => getWorkspaceInstance(input, this),
+        items: {
+          create: (input) => createWorkspaceInstanceItem(input, this),
+          get: (input) => getWorkspaceInstanceItem(input, this),
+          getMany: (input) => getWorkspaceInstanceItems(input, this),
+          download: (input) => downloadWorkspaceInstanceItem(input, this),
+          update: (input) => updateWorkspaceInstanceItem(input, this),
+          delete: (input) => deleteWorkspaceInstanceItem(input, this)
+        }
+      }
+    },
+    workspace: {
+      get: () => getWorkspace(this),
+      items: {
+        create: (input) => createWorkspaceItem(input, this),
+        get: (input) => getWorkspaceItem(input, this),
+        getMany: (input) => getWorkspaceItems(input, this),
+        download: (input) => downloadWorkspaceItem(input, this),
+        update: (input) => updateWorkspaceItem(input, this),
+        delete: (input) => deleteWorkspaceItem(input, this)
+      },
+      variables: {
+        create: (input) => createWorkspaceVariable(input, this),
+        update: (input) => updateWorkspaceVariable(input, this),
+        delete: (input) => deleteWorkspaceVariable(input, this)
+      },
+      secrets: {
+        create: (input) => createWorkspaceSecret(input, this),
+        delete: (input) => deleteWorkspaceSecret(input, this)
+      }
+    }
+  };
+};
+
+export { ApiError, ApiV1Client, apiApplicationSchema, apiApplicationStatusSchema, apiBaseExpertSchema, apiBaseWorkspaceItemSchema, apiCheckpointActionAppendTextFileSchema, apiCheckpointActionAttemptCompletionSchema, apiCheckpointActionCreateDirectorySchema, apiCheckpointActionDelegateSchema, apiCheckpointActionDeleteFileSchema, apiCheckpointActionEditTextFileSchema, apiCheckpointActionErrorSchema, apiCheckpointActionGeneralToolSchema, apiCheckpointActionGetFileInfoSchema, apiCheckpointActionListDirectorySchema, apiCheckpointActionMoveFileSchema, apiCheckpointActionReadImageFileSchema, apiCheckpointActionReadPdfFileSchema, apiCheckpointActionReadTextFileSchema, apiCheckpointActionRetrySchema, apiCheckpointActionSchema, apiCheckpointActionTestUrlSchema, apiCheckpointActionThinkSchema, apiCheckpointActionTodoSchema, apiCheckpointActionWriteTextFileSchema, apiCheckpointSchema, apiCheckpointStatusSchema, apiExpertDigestSchema, apiExpertJobSchema, apiExpertJobStatusSchema, apiExpertSchema, apiInteractiveSkillSchema, apiMcpSseSkillSchema, apiMcpStdioSkillCommandSchema, apiMcpStdioSkillSchema, apiOrganizationSchema, apiOrganizationStatusSchema, apiOrganizationTypeSchema, apiRegistryExpertSchema, apiSkillNameSchema, apiSkillSchema, apiStudioExpertSchema, apiWorkspaceInstanceSchema, apiWorkspaceItemDirectorySchema, apiWorkspaceItemFileSchema, apiWorkspaceItemLifecycleSchema, apiWorkspaceItemOwnerSchema, apiWorkspaceItemPermissionSchema, apiWorkspaceItemSchema, apiWorkspaceSchema, continueExpertJob, createCheckpoint, createRegistryExpert, createStudioExpert, createWorkspaceInstanceItem, createWorkspaceItem, createWorkspaceSecret, createWorkspaceVariable, deleteRegistryExpert, deleteStudioExpert, deleteWorkspaceInstanceItem, deleteWorkspaceItem, deleteWorkspaceSecret, deleteWorkspaceVariable, downloadWorkspaceInstanceItem, downloadWorkspaceItem, getCheckpoint, getCheckpoints, getExpertJob, getExpertJobs, getRegistryExpert, getRegistryExpertVersions, getRegistryExperts, getStudioExpert, getStudioExperts, getWorkspace, getWorkspaceInstance, getWorkspaceInstanceItem, getWorkspaceInstanceItems, getWorkspaceItem, getWorkspaceItems, resumeExpertJobFromCheckpoint, startExpertJob, updateExpertJob, updateStudioExpert, updateWorkspaceInstanceItem, updateWorkspaceItem, updateWorkspaceVariable };
+//# sourceMappingURL=index.ts.js.map
+//# sourceMappingURL=index.ts.js.map