@perstack/api-client 0.0.45 → 0.0.47

package/dist/index.js

@@ -1,967 +0,0 @@
-import { z } from 'zod';
-
-// src/fetcher.ts
-var DEFAULT_BASE_URL = "https://api.perstack.ai";
-var DEFAULT_TIMEOUT = 3e4;
-function createAbortError() {
-  return {
-    code: 0,
-    message: "Request aborted",
-    aborted: true
-  };
-}
-function createNetworkError(error) {
-  return {
-    code: 0,
-    message: error instanceof Error ? error.message : "Network error",
-    reason: error
-  };
-}
-function createHttpError(status, statusText, body) {
-  if (typeof body === "object" && body !== null) {
-    const hasReason = "reason" in body;
-    if ("error" in body && typeof body.error === "string") {
-      const errorMessage = body.error;
-      return {
-        code: status,
-        message: errorMessage,
-        reason: hasReason ? body.reason : void 0
-      };
-    }
-    if (hasReason) {
-      return {
-        code: status,
-        message: statusText,
-        reason: body.reason
-      };
-    }
-  }
-  return {
-    code: status,
-    message: statusText
-  };
-}
-function createValidationError(error) {
-  return {
-    code: 0,
-    message: "Response validation failed",
-    reason: error
-  };
-}
-function createFetcher(config) {
-  const baseUrl = config?.baseUrl ?? DEFAULT_BASE_URL;
-  const timeout = config?.timeout ?? DEFAULT_TIMEOUT;
-  const apiKey = config?.apiKey;
-  function buildUrl(path) {
-    return `${baseUrl}${path}`;
-  }
-  function buildHeaders(additionalHeaders) {
-    const headers = {
-      "Content-Type": "application/json",
-      ...additionalHeaders
-    };
-    if (apiKey) {
-      headers.Authorization = `Bearer ${apiKey}`;
-    }
-    return headers;
-  }
-  function createTimeoutSignal(externalSignal) {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    if (externalSignal) {
-      if (externalSignal.aborted) {
-        controller.abort();
-      } else {
-        externalSignal.addEventListener("abort", () => controller.abort());
-      }
-    }
-    return {
-      signal: controller.signal,
-      cleanup: () => clearTimeout(timeoutId)
-    };
-  }
-  async function request(method, path, schema, body, options) {
-    const { signal, cleanup } = createTimeoutSignal(options?.signal);
-    try {
-      const response = await fetch(buildUrl(path), {
-        method,
-        headers: buildHeaders(),
-        body: body ? JSON.stringify(body) : void 0,
-        signal
-      });
-      if (!response.ok) {
-        let errorBody;
-        try {
-          errorBody = await response.json();
-        } catch {
-          errorBody = void 0;
-        }
-        return {
-          ok: false,
-          error: createHttpError(response.status, response.statusText, errorBody)
-        };
-      }
-      const json = await response.json();
-      const parsed = schema.safeParse(json);
-      if (!parsed.success) {
-        return { ok: false, error: createValidationError(parsed.error) };
-      }
-      return { ok: true, data: parsed.data };
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        return { ok: false, error: createAbortError() };
-      }
-      return { ok: false, error: createNetworkError(error) };
-    } finally {
-      cleanup();
-    }
-  }
-  async function requestBlob(path, options) {
-    const { signal, cleanup } = createTimeoutSignal(options?.signal);
-    try {
-      const response = await fetch(buildUrl(path), {
-        method: "GET",
-        headers: buildHeaders(),
-        signal
-      });
-      if (!response.ok) {
-        let errorBody;
-        try {
-          errorBody = await response.json();
-        } catch {
-          errorBody = void 0;
-        }
-        return {
-          ok: false,
-          error: createHttpError(response.status, response.statusText, errorBody)
-        };
-      }
-      const blob = await response.blob();
-      return { ok: true, data: blob };
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        return { ok: false, error: createAbortError() };
-      }
-      return { ok: false, error: createNetworkError(error) };
-    } finally {
-      cleanup();
-    }
-  }
-  return {
-    get: (path, schema, options) => request("GET", path, schema, void 0, options),
-    post: (path, body, schema, options) => request("POST", path, schema, body, options),
-    delete: (path, schema, options) => request("DELETE", path, schema, void 0, options),
-    getBlob: (path, options) => requestBlob(path, options)
-  };
-}
-var registryExpertStatusSchema = z.enum(["available", "deprecated", "disabled"]);
-var ownerSchema = z.object({
-  name: z.string().optional(),
-  organizationId: z.string(),
-  createdAt: z.string().transform((s) => new Date(s))
-});
-var registryExpertSchema = z.object({
-  type: z.literal("registryExpert"),
-  id: z.string(),
-  key: z.string(),
-  name: z.string(),
-  minRuntimeVersion: z.literal("v1.0"),
-  description: z.string(),
-  owner: ownerSchema,
-  createdAt: z.string().transform((s) => new Date(s)),
-  updatedAt: z.string().transform((s) => new Date(s)),
-  version: z.string(),
-  status: registryExpertStatusSchema,
-  instruction: z.string(),
-  skills: z.record(z.string(), z.unknown()).transform((s) => s),
-  delegates: z.array(z.string()),
-  tags: z.array(z.string())
-});
-var expertDigestSchema = z.object({
-  type: z.literal("expertDigest"),
-  id: z.string(),
-  key: z.string(),
-  name: z.string(),
-  minRuntimeVersion: z.literal("v1.0"),
-  description: z.string(),
-  owner: ownerSchema,
-  createdAt: z.string().transform((s) => new Date(s)),
-  updatedAt: z.string().transform((s) => new Date(s)),
-  version: z.string().optional(),
-  tags: z.array(z.string())
-});
-var getExpertResponseSchema = z.object({
-  data: z.object({
-    expert: registryExpertSchema
-  })
-});
-var listExpertsResponseSchema = z.object({
-  data: z.object({
-    experts: z.array(registryExpertSchema)
-  }),
-  meta: z.object({
-    total: z.number(),
-    take: z.number(),
-    skip: z.number()
-  })
-});
-var createExpertResponseSchema = z.object({
-  data: z.object({
-    expert: registryExpertSchema
-  })
-});
-var updateExpertResponseSchema = z.object({
-  data: z.object({
-    expert: registryExpertSchema
-  })
-});
-var deleteExpertResponseSchema = z.object({});
-var getExpertVersionsResponseSchema = z.object({
-  data: z.object({
-    versions: z.array(expertDigestSchema),
-    latest: z.string()
-  }),
-  meta: z.object({
-    total: z.number()
-  })
-});
-
-// src/registry/experts.ts
-function createRegistryExpertsApi(fetcher) {
-  return {
-    async get(key, options) {
-      const result = await fetcher.get(
-        `/api/registry/v1/experts/${encodeURIComponent(key)}`,
-        getExpertResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.expert };
-    },
-    async list(params, options) {
-      const searchParams = new URLSearchParams();
-      if (params?.organizationId) searchParams.set("organizationId", params.organizationId);
-      if (params?.filter) searchParams.set("filter", params.filter);
-      if (params?.sort) searchParams.set("sort", params.sort);
-      if (params?.order) searchParams.set("order", params.order);
-      if (params?.take !== void 0) searchParams.set("take", params.take.toString());
-      if (params?.skip !== void 0) searchParams.set("skip", params.skip.toString());
-      const query = searchParams.toString();
-      const path = `/api/registry/v1/experts/${query ? `?${query}` : ""}`;
-      const result = await fetcher.get(path, listExpertsResponseSchema, options);
-      if (!result.ok) return result;
-      return {
-        ok: true,
-        data: {
-          data: result.data.data.experts,
-          meta: result.data.meta
-        }
-      };
-    },
-    async create(input, options) {
-      const result = await fetcher.post(
-        "/api/registry/v1/experts/",
-        input,
-        createExpertResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.expert };
-    },
-    async update(key, input, options) {
-      const result = await fetcher.post(
-        `/api/registry/v1/experts/${encodeURIComponent(key)}`,
-        input,
-        updateExpertResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.expert };
-    },
-    async delete(key, options) {
-      const result = await fetcher.delete(
-        `/api/registry/v1/experts/${encodeURIComponent(key)}`,
-        deleteExpertResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: void 0 };
-    },
-    async getVersions(key, options) {
-      const result = await fetcher.get(
-        `/api/registry/v1/experts/${encodeURIComponent(key)}/versions`,
-        getExpertVersionsResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return {
-        ok: true,
-        data: {
-          versions: result.data.data.versions,
-          latest: result.data.data.latest,
-          total: result.data.meta.total
-        }
-      };
-    }
-  };
-}
-
-// src/utils.ts
-async function blobToBase64(blob) {
-  const buffer = await blob.arrayBuffer();
-  const bytes = new Uint8Array(buffer);
-  let binary = "";
-  for (let i = 0; i < bytes.byteLength; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  return btoa(binary);
-}
-var applicationSchema = z.object({
-  id: z.string(),
-  name: z.string()
-});
-var ownerSchema2 = z.object({
-  name: z.string().optional(),
-  organizationId: z.string(),
-  createdAt: z.string().transform((s) => new Date(s))
-});
-var studioExpertSchema = z.object({
-  type: z.literal("studioExpert"),
-  id: z.string(),
-  key: z.string(),
-  name: z.string(),
-  minRuntimeVersion: z.literal("v1.0"),
-  description: z.string(),
-  owner: ownerSchema2,
-  createdAt: z.string().transform((s) => new Date(s)),
-  updatedAt: z.string().transform((s) => new Date(s)),
-  instruction: z.string(),
-  skills: z.record(z.string(), z.unknown()).transform((s) => s),
-  delegates: z.array(z.string()),
-  forkFrom: z.string().optional(),
-  application: applicationSchema
-});
-var expertDigestSchema2 = z.object({
-  type: z.literal("expertDigest"),
-  id: z.string(),
-  key: z.string(),
-  name: z.string(),
-  minRuntimeVersion: z.literal("v1.0"),
-  description: z.string(),
-  owner: ownerSchema2,
-  createdAt: z.string().transform((s) => new Date(s)),
-  updatedAt: z.string().transform((s) => new Date(s)),
-  version: z.string().optional(),
-  tags: z.array(z.string())
-});
-var getStudioExpertResponseSchema = z.object({
-  data: z.object({
-    expert: studioExpertSchema
-  })
-});
-var listStudioExpertsResponseSchema = z.object({
-  data: z.object({
-    experts: z.array(expertDigestSchema2)
-  }),
-  meta: z.object({
-    total: z.number(),
-    take: z.number(),
-    skip: z.number()
-  })
-});
-var createStudioExpertResponseSchema = z.object({
-  data: z.object({
-    expert: studioExpertSchema
-  })
-});
-var updateStudioExpertResponseSchema = z.object({
-  data: z.object({
-    expert: studioExpertSchema
-  })
-});
-var deleteStudioExpertResponseSchema = z.object({});
-var expertJobStatusSchema = z.enum([
-  "queued",
-  "processing",
-  "completed",
-  "requestInteractiveToolResult",
-  "requestDelegateResult",
-  "exceededMaxSteps",
-  "failed",
-  "canceling",
-  "canceled",
-  "expired"
-]);
-var expertJobSchema = z.object({
-  id: z.string(),
-  expertKey: z.string(),
-  status: expertJobStatusSchema,
-  query: z.string().optional(),
-  createdAt: z.string().transform((s) => new Date(s)),
-  updatedAt: z.string().transform((s) => new Date(s)),
-  startedAt: z.string().transform((s) => new Date(s)).optional(),
-  completedAt: z.string().transform((s) => new Date(s)).optional()
-});
-var getExpertJobResponseSchema = z.object({
-  data: z.object({
-    expertJob: expertJobSchema
-  })
-});
-var listExpertJobsResponseSchema = z.object({
-  data: z.object({
-    expertJobs: z.array(expertJobSchema)
-  }),
-  meta: z.object({
-    total: z.number(),
-    take: z.number(),
-    skip: z.number()
-  })
-});
-var startExpertJobResponseSchema = z.object({
-  data: z.object({
-    expertJob: expertJobSchema
-  })
-});
-var continueExpertJobResponseSchema = z.object({
-  data: z.object({
-    expertJob: expertJobSchema
-  })
-});
-var updateExpertJobResponseSchema = z.object({
-  data: z.object({
-    expertJob: expertJobSchema
-  })
-});
-var checkpointSchema = z.object({
-  id: z.string(),
-  expertJobId: z.string(),
-  sequence: z.number(),
-  createdAt: z.string().transform((s) => new Date(s))
-});
-var getCheckpointResponseSchema = z.object({
-  data: z.object({
-    checkpoint: checkpointSchema
-  })
-});
-var listCheckpointsResponseSchema = z.object({
-  data: z.object({
-    checkpoints: z.array(checkpointSchema)
-  }),
-  meta: z.object({
-    total: z.number(),
-    take: z.number(),
-    skip: z.number()
-  })
-});
-var createCheckpointResponseSchema = z.object({
-  data: z.object({
-    checkpoint: checkpointSchema
-  })
-});
-var workspaceInstanceSchema = z.object({
-  id: z.string(),
-  expertJobId: z.string(),
-  createdAt: z.string().transform((s) => new Date(s))
-});
-var getWorkspaceInstanceResponseSchema = z.object({
-  data: z.object({
-    workspaceInstance: workspaceInstanceSchema
-  })
-});
-var workspaceItemSchema = z.object({
-  id: z.string(),
-  path: z.string(),
-  type: z.enum(["file", "directory"]),
-  size: z.number().optional(),
-  createdAt: z.string().transform((s) => new Date(s)),
-  updatedAt: z.string().transform((s) => new Date(s))
-});
-var getWorkspaceItemResponseSchema = z.object({
-  data: z.object({
-    item: workspaceItemSchema
-  })
-});
-var listWorkspaceItemsResponseSchema = z.object({
-  data: z.object({
-    workspaceItems: z.array(workspaceItemSchema)
-  }),
-  meta: z.object({
-    total: z.number(),
-    take: z.number(),
-    skip: z.number()
-  })
-});
-var createWorkspaceItemResponseSchema = z.object({
-  data: z.object({
-    item: workspaceItemSchema
-  })
-});
-var updateWorkspaceItemResponseSchema = z.object({
-  data: z.object({
-    item: workspaceItemSchema
-  })
-});
-var deleteWorkspaceItemResponseSchema = z.object({});
-var findWorkspaceItemsResponseSchema = z.object({
-  data: z.object({
-    workspaceItems: z.array(workspaceItemSchema)
-  })
-});
-var workspaceSchema = z.object({
-  id: z.string(),
-  applicationId: z.string(),
-  createdAt: z.string().transform((s) => new Date(s)),
-  updatedAt: z.string().transform((s) => new Date(s))
-});
-var getWorkspaceResponseSchema = z.object({
-  data: z.object({
-    workspace: workspaceSchema
-  })
-});
-var workspaceVariableSchema = z.object({
-  name: z.string(),
-  value: z.string()
-});
-var workspaceSecretSchema = z.object({
-  name: z.string()
-});
-var createWorkspaceVariableResponseSchema = z.object({
-  data: z.object({
-    variable: workspaceVariableSchema
-  })
-});
-var updateWorkspaceVariableResponseSchema = z.object({
-  data: z.object({
-    variable: workspaceVariableSchema
-  })
-});
-var deleteWorkspaceVariableResponseSchema = z.object({});
-var createWorkspaceSecretResponseSchema = z.object({
-  data: z.object({
-    secret: workspaceSecretSchema
-  })
-});
-var deleteWorkspaceSecretResponseSchema = z.object({});
-
-// src/studio/expert-jobs.ts
-function createStudioExpertJobsApi(fetcher) {
-  return {
-    async get(id, options) {
-      const result = await fetcher.get(
-        `/api/studio/v1/expert_jobs/${encodeURIComponent(id)}`,
-        getExpertJobResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.expertJob };
-    },
-    async list(params, options) {
-      const searchParams = new URLSearchParams();
-      searchParams.set("applicationId", params.applicationId);
-      if (params.filter) searchParams.set("filter", params.filter);
-      if (params.sort) searchParams.set("sort", params.sort);
-      if (params.order) searchParams.set("order", params.order);
-      if (params.take !== void 0) searchParams.set("take", params.take.toString());
-      if (params.skip !== void 0) searchParams.set("skip", params.skip.toString());
-      const path = `/api/studio/v1/expert_jobs/?${searchParams.toString()}`;
-      const result = await fetcher.get(path, listExpertJobsResponseSchema, options);
-      if (!result.ok) return result;
-      return {
-        ok: true,
-        data: {
-          data: result.data.data.expertJobs,
-          meta: result.data.meta
-        }
-      };
-    },
-    async start(input, options) {
-      const result = await fetcher.post(
-        "/api/studio/v1/expert_jobs/",
-        input,
-        startExpertJobResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.expertJob };
-    },
-    async continue(id, input, options) {
-      const result = await fetcher.post(
-        `/api/studio/v1/expert_jobs/${encodeURIComponent(id)}/continue`,
-        input,
-        continueExpertJobResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.expertJob };
-    },
-    async update(id, input, options) {
-      const result = await fetcher.post(
-        `/api/studio/v1/expert_jobs/${encodeURIComponent(id)}`,
-        input,
-        updateExpertJobResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.expertJob };
-    },
-    checkpoints: createCheckpointsApi(fetcher),
-    workspaceInstance: createWorkspaceInstanceApi(fetcher)
-  };
-}
-function createCheckpointsApi(fetcher) {
-  return {
-    async get(jobId, checkpointId, options) {
-      const result = await fetcher.get(
-        `/api/studio/v1/expert_jobs/${encodeURIComponent(jobId)}/checkpoints/${encodeURIComponent(checkpointId)}`,
-        getCheckpointResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.checkpoint };
-    },
-    async list(jobId, params, options) {
-      const searchParams = new URLSearchParams();
-      if (params?.take !== void 0) searchParams.set("take", params.take.toString());
-      if (params?.skip !== void 0) searchParams.set("skip", params.skip.toString());
-      if (params?.sort) searchParams.set("sort", params.sort);
-      if (params?.order) searchParams.set("order", params.order);
-      const query = searchParams.toString();
-      const path = `/api/studio/v1/expert_jobs/${encodeURIComponent(jobId)}/checkpoints/${query ? `?${query}` : ""}`;
-      const result = await fetcher.get(path, listCheckpointsResponseSchema, options);
-      if (!result.ok) return result;
-      return {
-        ok: true,
-        data: {
-          data: result.data.data.checkpoints,
-          meta: result.data.meta
-        }
-      };
-    },
-    async create(jobId, options) {
-      const result = await fetcher.post(
-        `/api/studio/v1/expert_jobs/${encodeURIComponent(jobId)}/checkpoints/`,
-        {},
-        createCheckpointResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.checkpoint };
-    }
-  };
-}
-function createWorkspaceInstanceApi(fetcher) {
-  return {
-    async get(jobId, options) {
-      const result = await fetcher.get(
-        `/api/studio/v1/expert_jobs/${encodeURIComponent(jobId)}/workspace_instance/`,
-        getWorkspaceInstanceResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.workspaceInstance };
-    },
-    items: createWorkspaceInstanceItemsApi(fetcher)
-  };
-}
-function createWorkspaceInstanceItemsApi(fetcher) {
-  return {
-    async get(jobId, itemId, options) {
-      const result = await fetcher.get(
-        `/api/studio/v1/expert_jobs/${encodeURIComponent(jobId)}/workspace_instance/items/${encodeURIComponent(itemId)}`,
-        getWorkspaceItemResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.item };
-    },
-    async list(jobId, params, options) {
-      const searchParams = new URLSearchParams();
-      if (params?.take !== void 0) searchParams.set("take", params.take.toString());
-      if (params?.skip !== void 0) searchParams.set("skip", params.skip.toString());
-      if (params?.path) searchParams.set("path", params.path);
-      const query = searchParams.toString();
-      const path = `/api/studio/v1/expert_jobs/${encodeURIComponent(jobId)}/workspace_instance/items/${query ? `?${query}` : ""}`;
-      const result = await fetcher.get(path, listWorkspaceItemsResponseSchema, options);
-      if (!result.ok) return result;
-      return {
-        ok: true,
-        data: {
-          data: result.data.data.workspaceItems,
-          meta: result.data.meta
-        }
-      };
-    },
-    async create(jobId, itemPath, content, options) {
-      const result = await fetcher.post(
-        `/api/studio/v1/expert_jobs/${encodeURIComponent(jobId)}/workspace_instance/items/`,
-        { path: itemPath, content: await blobToBase64(content) },
-        createWorkspaceItemResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.item };
-    },
-    async update(jobId, itemId, content, options) {
-      const result = await fetcher.post(
-        `/api/studio/v1/expert_jobs/${encodeURIComponent(jobId)}/workspace_instance/items/${encodeURIComponent(itemId)}`,
-        { content: await blobToBase64(content) },
-        updateWorkspaceItemResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.item };
-    },
-    async delete(jobId, itemId, options) {
-      const result = await fetcher.delete(
-        `/api/studio/v1/expert_jobs/${encodeURIComponent(jobId)}/workspace_instance/items/${encodeURIComponent(itemId)}`,
-        deleteWorkspaceItemResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: void 0 };
-    },
-    async download(jobId, itemId, options) {
-      return fetcher.getBlob(
-        `/api/studio/v1/expert_jobs/${encodeURIComponent(jobId)}/workspace_instance/items/${encodeURIComponent(itemId)}/download`,
-        options
-      );
-    },
-    async find(jobId, pathPattern, options) {
-      const searchParams = new URLSearchParams();
-      searchParams.set("path", pathPattern);
-      const path = `/api/studio/v1/expert_jobs/${encodeURIComponent(jobId)}/workspace_instance/items/find?${searchParams.toString()}`;
-      const result = await fetcher.get(path, findWorkspaceItemsResponseSchema, options);
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.workspaceItems };
-    }
-  };
-}
-
-// src/studio/experts.ts
-function createStudioExpertsApi(fetcher) {
-  return {
-    async get(key, options) {
-      const result = await fetcher.get(
-        `/api/studio/v1/experts/${encodeURIComponent(key)}`,
-        getStudioExpertResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.expert };
-    },
-    async list(params, options) {
-      const searchParams = new URLSearchParams();
-      searchParams.set("applicationId", params.applicationId);
-      if (params.filter) searchParams.set("filter", params.filter);
-      if (params.sort) searchParams.set("sort", params.sort);
-      if (params.order) searchParams.set("order", params.order);
-      if (params.take !== void 0) searchParams.set("take", params.take.toString());
-      if (params.skip !== void 0) searchParams.set("skip", params.skip.toString());
-      const path = `/api/studio/v1/experts/?${searchParams.toString()}`;
-      const result = await fetcher.get(path, listStudioExpertsResponseSchema, options);
-      if (!result.ok) return result;
-      return {
-        ok: true,
-        data: {
-          data: result.data.data.experts,
-          meta: result.data.meta
-        }
-      };
-    },
-    async create(input, options) {
-      const result = await fetcher.post(
-        "/api/studio/v1/experts/",
-        input,
-        createStudioExpertResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.expert };
-    },
-    async update(key, input, options) {
-      const result = await fetcher.post(
-        `/api/studio/v1/experts/${encodeURIComponent(key)}`,
-        input,
-        updateStudioExpertResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.expert };
-    },
-    async delete(key, options) {
-      const result = await fetcher.delete(
-        `/api/studio/v1/experts/${encodeURIComponent(key)}`,
-        deleteStudioExpertResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: void 0 };
-    }
-  };
-}
-
-// src/studio/workspace.ts
-function createStudioWorkspaceApi(fetcher) {
-  return {
-    async get(options) {
-      const result = await fetcher.get(
-        "/api/studio/v1/workspace/",
-        getWorkspaceResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.workspace };
-    },
-    items: createWorkspaceItemsApi(fetcher),
-    variables: createWorkspaceVariablesApi(fetcher),
-    secrets: createWorkspaceSecretsApi(fetcher)
-  };
-}
-function createWorkspaceItemsApi(fetcher) {
-  return {
-    async get(itemId, options) {
-      const result = await fetcher.get(
-        `/api/studio/v1/workspace/items/${encodeURIComponent(itemId)}`,
-        getWorkspaceItemResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.item };
-    },
-    async list(params, options) {
-      const searchParams = new URLSearchParams();
-      if (params?.take !== void 0) searchParams.set("take", params.take.toString());
-      if (params?.skip !== void 0) searchParams.set("skip", params.skip.toString());
-      if (params?.path) searchParams.set("path", params.path);
-      const query = searchParams.toString();
-      const path = `/api/studio/v1/workspace/items/${query ? `?${query}` : ""}`;
-      const result = await fetcher.get(path, listWorkspaceItemsResponseSchema, options);
-      if (!result.ok) return result;
-      return {
-        ok: true,
-        data: {
-          data: result.data.data.workspaceItems,
-          meta: result.data.meta
-        }
-      };
-    },
-    async create(itemPath, content, options) {
-      const result = await fetcher.post(
-        "/api/studio/v1/workspace/items/",
-        { path: itemPath, content: await blobToBase64(content) },
-        createWorkspaceItemResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.item };
-    },
-    async update(itemId, content, options) {
-      const result = await fetcher.post(
-        `/api/studio/v1/workspace/items/${encodeURIComponent(itemId)}`,
-        { content: await blobToBase64(content) },
-        updateWorkspaceItemResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.item };
-    },
-    async delete(itemId, options) {
-      const result = await fetcher.delete(
-        `/api/studio/v1/workspace/items/${encodeURIComponent(itemId)}`,
-        deleteWorkspaceItemResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: void 0 };
-    },
-    async download(itemId, options) {
-      return fetcher.getBlob(
-        `/api/studio/v1/workspace/items/${encodeURIComponent(itemId)}/download`,
-        options
-      );
-    },
-    async find(pathPattern, options) {
-      const searchParams = new URLSearchParams();
-      searchParams.set("path", pathPattern);
-      const path = `/api/studio/v1/workspace/items/find?${searchParams.toString()}`;
-      const result = await fetcher.get(path, findWorkspaceItemsResponseSchema, options);
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.workspaceItems };
-    }
-  };
-}
-function createWorkspaceVariablesApi(fetcher) {
-  return {
-    async create(input, options) {
-      const result = await fetcher.post(
-        "/api/studio/v1/workspace/variables/",
-        input,
-        createWorkspaceVariableResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.variable };
-    },
-    async update(name, input, options) {
-      const result = await fetcher.post(
-        `/api/studio/v1/workspace/variables/${encodeURIComponent(name)}`,
-        input,
-        updateWorkspaceVariableResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.variable };
-    },
-    async delete(name, options) {
-      const result = await fetcher.delete(
-        `/api/studio/v1/workspace/variables/${encodeURIComponent(name)}`,
-        deleteWorkspaceVariableResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: void 0 };
-    }
-  };
-}
-function createWorkspaceSecretsApi(fetcher) {
-  return {
-    async create(input, options) {
-      const result = await fetcher.post(
-        "/api/studio/v1/workspace/secrets/",
-        input,
-        createWorkspaceSecretResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: result.data.data.secret };
-    },
-    async delete(name, options) {
-      const result = await fetcher.delete(
-        `/api/studio/v1/workspace/secrets/${encodeURIComponent(name)}`,
-        deleteWorkspaceSecretResponseSchema,
-        options
-      );
-      if (!result.ok) return result;
-      return { ok: true, data: void 0 };
-    }
-  };
-}
-
-// src/client.ts
-function createApiClient(config) {
-  const fetcher = createFetcher(config);
-  return {
-    registry: {
-      experts: createRegistryExpertsApi(fetcher)
-    },
-    studio: {
-      experts: createStudioExpertsApi(fetcher),
-      expertJobs: createStudioExpertJobsApi(fetcher),
-      workspace: createStudioWorkspaceApi(fetcher)
-    }
-  };
-}
-
-export { createApiClient, createFetcher, createRegistryExpertsApi, createStudioExpertJobsApi, createStudioExpertsApi, createStudioWorkspaceApi };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map