@perstack/api-client 0.0.35 → 0.0.36

package/dist/v1/index.js

@@ -1,1701 +0,0 @@
-import { z } from 'zod';
-import { maxOrganizationNameLength, organizationNameRegex, maxSkillNameLength, packageWithVersionRegex, mcpStdioSkillSchema, maxEnvNameLength, envNameRegex, maxSkillToolNameLength, maxSkillRuleLength, maxSkillDescriptionLength, mcpSseSkillSchema, maxSkillEndpointLength, interactiveSkillSchema, urlSafeRegex, maxSkillInputJsonSchemaLength, maxExpertVersionTagLength, tagNameRegex, expertVersionRegex, expertSchema, maxExpertDescriptionLength, maxExpertNameLength, expertNameRegex, maxExpertKeyLength, expertKeyRegex, maxExpertInstructionLength, messagePartSchema, checkpointSchema, usageSchema, toolResultSchema, toolCallSchema, messageSchema, instructionMessageSchema, userMessageSchema, toolMessageSchema, maxCheckpointToolCallIdLength, stepSchema } 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 = mcpStdioSkillSchema.omit({ name: true, command: true, args: true, packageName: true, lazyInit: true }).extend({
-  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 = mcpSseSkillSchema.omit({ name: true }).extend({
-  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 = interactiveSkillSchema.omit({ name: true, tools: true }).extend({
-  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 apiMetadataSchema = z.object({
-  id: z.cuid2(),
-  minRuntimeVersion: apiRuntimeVersionSchema,
-  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 apiBaseExpertSchema = expertSchema.omit({ skills: true, delegates: true, tags: true, instruction: true }).extend({
-  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)")),
-  description: z.string().min(1, "Description is required").max(maxExpertDescriptionLength, "Description must be less than 2048 characters")
-}).merge(apiMetadataSchema);
-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, 10))]).optional(),
-  skip: z.union([z.number(), z.string().transform((value) => Number.parseInt(value, 10))]).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 updateRegistryExpertInput = z.object({
-  expertKey: apiRegistryExpertSchema.shape.key,
-  status: apiRegistryExpertSchema.shape.status.optional(),
-  tags: apiRegistryExpertSchema.shape.tags.optional()
-});
-var updateRegistryExpertResponseSchema = z.object({
-  data: z.object({
-    expert: apiRegistryExpertSchema
-  })
-});
-async function updateRegistryExpert(input, client) {
-  const { expertKey, status, tags } = updateRegistryExpertInput.parse(input);
-  const endpoint = `/api/registry/v1/experts/${encodeURIComponent(expertKey)}`;
-  const json = await client.requestAuthenticated(endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      status,
-      tags
-    })
-  });
-  const { data } = updateRegistryExpertResponseSchema.parse(json);
-  return {
-    expert: data.expert
-  };
-}
-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 apiCheckpointActionInteractiveTool = apiBaseCheckpointActionSchema.extend({
-  type: z.literal("interactiveTool"),
-  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())
-});
-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,
-  apiCheckpointActionInteractiveTool,
-  apiCheckpointActionGeneralToolSchema,
-  apiCheckpointActionErrorSchema
-]);
-var apiCheckpointSchema = checkpointSchema.omit({ expert: true }).extend({
-  type: z.literal("checkpoint"),
-  id: z.cuid2(),
-  action: apiCheckpointActionSchema,
-  expertJobId: z.cuid2(),
-  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(),
-  interactiveToolCallResult: z.boolean().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,
-  interactiveToolCallResult: apiExpertJobSchema.shape.interactiveToolCallResult,
-  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,
-    interactiveToolCallResult,
-    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);
-    }
-  }
-  if (interactiveToolCallResult)
-    formData.append("interactiveToolCallResult", interactiveToolCallResult.toString());
-  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,
-  interactiveToolCallResult: apiExpertJobSchema.shape.interactiveToolCallResult,
-  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,
-    interactiveToolCallResult,
-    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);
-    }
-  }
-  if (interactiveToolCallResult)
-    formData.append("interactiveToolCallResult", interactiveToolCallResult.toString());
-  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, 10))]).optional(),
-  skip: z.union([z.number(), z.string().transform((value) => Number.parseInt(value, 10))]).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: checkpointSchema,
-  step: stepSchema
-});
-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",
-    headers: {
-      "Content-Type": "application/json"
-    },
-    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, 10))]).optional(),
-  skip: z.union([z.number(), z.string().transform((value) => Number.parseInt(value, 10))]).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, 10))]).optional(),
-  skip: z.union([z.number(), z.string().transform((value) => Number.parseInt(value, 10))]).optional(),
-  sort: z.string().optional(),
-  order: z.string().optional(),
-  filter: z.string().optional()
-});
-var getStudioExpertsResponseSchema = z.object({
-  data: z.object({
-    experts: z.array(apiExpertDigestSchema)
-  }),
-  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 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, 10))]).optional(),
-  skip: z.union([z.number(), z.string().transform((value) => Number.parseInt(value, 10))]).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"
-    }
-  });
-}
-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, 10))]).optional(),
-  skip: z.union([z.number(), z.string().transform((value) => Number.parseInt(value, 10))]).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 findWorkspaceInstanceItemsInput = z.object({
-  expertJobId: z.string(),
-  path: z.string()
-});
-var findWorkspaceInstanceItemsResponseSchema = z.object({
-  data: z.object({
-    workspaceItems: z.array(apiWorkspaceItemSchema)
-  })
-});
-async function findWorkspaceInstanceItems(input, client) {
-  const { expertJobId, path } = findWorkspaceInstanceItemsInput.parse(input);
-  const url = new URL(
-    `/api/studio/v1/expert_jobs/${expertJobId}/workspace_instance/items/find`,
-    client.baseUrl
-  );
-  url.searchParams.set("path", path);
-  const endpoint = url.toString();
-  const json = await client.requestAuthenticated(endpoint, {
-    headers: { "Content-Type": "application/json" }
-  });
-  const { data } = findWorkspaceInstanceItemsResponseSchema.parse(json);
-  return { workspaceItems: data.workspaceItems };
-}
-
-// v1/client.ts
-var ApiV1Client = class {
-  baseUrl;
-  apiKey;
-  constructor(config) {
-    if (config?.baseUrl && !config.baseUrl.startsWith("https://")) {
-      throw new Error("API baseUrl must use HTTPS");
-    }
-    this.baseUrl = config?.baseUrl ? config.baseUrl : "https://api.perstack.ai";
-    this.apiKey = config?.apiKey;
-  }
-  async request(endpoint, init, schema) {
-    if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
-      const endpointUrl = new URL(endpoint);
-      const baseUrlObj = new URL(this.baseUrl);
-      if (endpointUrl.origin !== baseUrlObj.origin) {
-        throw new Error("Endpoint must use the configured baseUrl");
-      }
-    }
-    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}`);
-    }
-    const data = await response.json();
-    if (schema) {
-      return schema.parse(data);
-    }
-    return data;
-  }
-  async requestAuthenticated(endpoint, init, schema) {
-    if (!this.apiKey) {
-      throw new Error("API key is not set");
-    }
-    return this.request(
-      endpoint,
-      {
-        ...init,
-        headers: {
-          ...init?.headers,
-          Authorization: `Bearer ${this.apiKey}`
-        }
-      },
-      schema
-    );
-  }
-  async requestBlob(endpoint, init) {
-    if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
-      const endpointUrl = new URL(endpoint);
-      const baseUrlObj = new URL(this.baseUrl);
-      if (endpointUrl.origin !== baseUrlObj.origin) {
-        throw new Error("Endpoint must use the configured baseUrl");
-      }
-    }
-    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),
-      update: (input) => updateRegistryExpert(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),
-          find: (input) => findWorkspaceInstanceItems(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, apiCheckpointActionInteractiveTool, 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, findWorkspaceInstanceItems, getCheckpoint, getCheckpoints, getExpertJob, getExpertJobs, getRegistryExpert, getRegistryExpertVersions, getRegistryExperts, getStudioExpert, getStudioExperts, getWorkspace, getWorkspaceInstance, getWorkspaceInstanceItem, getWorkspaceInstanceItems, getWorkspaceItem, getWorkspaceItems, resumeExpertJobFromCheckpoint, startExpertJob, updateExpertJob, updateRegistryExpert, updateStudioExpert, updateWorkspaceInstanceItem, updateWorkspaceItem, updateWorkspaceVariable };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map