@perstack/api-client 0.0.35 → 0.0.36

package/dist/index.js

@@ -0,0 +1,957 @@
+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 errorBody = body;
+    return {
+      code: status,
+      message: errorBody.error ?? statusText,
+      reason: errorBody.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