perstack 0.0.86 → 0.0.88

package/dist/chunk-HNOP6GUQ.js

@@ -0,0 +1,1571 @@
+import { external_exports, usageSchema, activityOrGroupSchema, toolResultSchema, toolCallSchema, messageSchema, instructionMessageSchema, userMessageSchema, toolMessageSchema } from './chunk-FVVK5V2C.js';
+
+// ../../node_modules/.pnpm/@perstack+api-client@0.0.55_@perstack+core@packages+core_zod@4.3.6/node_modules/@perstack/api-client/dist/index.mjs
+function createValidationError(error) {
+  return {
+    errorType: "validation",
+    code: 400,
+    message: `Validation failed: ${error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`,
+    reason: error.issues
+  };
+}
+function createAbortError() {
+  return {
+    errorType: "abort",
+    code: 0,
+    message: "Request aborted",
+    aborted: true
+  };
+}
+function createTimeoutError() {
+  return {
+    errorType: "timeout",
+    code: 0,
+    message: "Request timed out"
+  };
+}
+function createNetworkError(error) {
+  return {
+    errorType: "network",
+    code: 0,
+    message: error instanceof Error ? error.message : "Network error",
+    reason: error,
+    cause: error instanceof Error ? error : void 0
+  };
+}
+async function handleHttpError(response2) {
+  let errorBody;
+  try {
+    errorBody = await response2.json();
+  } catch {
+    errorBody = void 0;
+  }
+  return {
+    ok: false,
+    error: createHttpError(response2.status, response2.statusText, errorBody)
+  };
+}
+function createHttpError(status, statusText, body) {
+  if (typeof body === "object" && body !== null) {
+    const hasReason = "reason" in body;
+    if ("error" in body && typeof body.error === "string") return {
+      errorType: "http",
+      code: status,
+      message: body.error,
+      reason: hasReason ? body.reason : void 0
+    };
+    if (hasReason) return {
+      errorType: "http",
+      code: status,
+      message: statusText,
+      reason: body.reason
+    };
+  }
+  return {
+    errorType: "http",
+    code: status,
+    message: statusText
+  };
+}
+var DEFAULT_BASE_URL = "https://api.perstack.ai";
+var DEFAULT_TIMEOUT = 3e4;
+function createFetcher(config) {
+  const baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
+  const timeout = config.timeout ?? DEFAULT_TIMEOUT;
+  const useCredentials = "credentials" in config && config.credentials === "include";
+  const apiKey = "apiKey" in config ? config.apiKey : void 0;
+  function buildUrl(path) {
+    return `${baseUrl}${path}`;
+  }
+  function buildHeaders(options) {
+    const headers = {};
+    if (options?.hasBody) headers["Content-Type"] = "application/json";
+    if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+    return headers;
+  }
+  function getCredentials() {
+    return useCredentials ? "include" : void 0;
+  }
+  function createTimeoutSignal(externalSignal) {
+    const controller = new AbortController();
+    let timedOut = false;
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeout);
+    let abortHandler;
+    if (externalSignal) if (externalSignal.aborted) controller.abort();
+    else {
+      abortHandler = () => controller.abort();
+      externalSignal.addEventListener("abort", abortHandler);
+    }
+    return {
+      signal: controller.signal,
+      cleanup: () => {
+        clearTimeout(timeoutId);
+        if (abortHandler && externalSignal) externalSignal.removeEventListener("abort", abortHandler);
+      },
+      isTimeout: () => timedOut
+    };
+  }
+  function wrapStreamWithIdleTimeout(stream, idleTimeoutMs, externalSignal) {
+    const reader = stream.getReader();
+    const controller = new AbortController();
+    let timeoutId;
+    let abortHandler;
+    if (externalSignal) if (externalSignal.aborted) controller.abort();
+    else {
+      abortHandler = () => controller.abort();
+      externalSignal.addEventListener("abort", abortHandler);
+    }
+    function resetTimeout() {
+      if (timeoutId) clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => controller.abort(), idleTimeoutMs);
+    }
+    function cleanup() {
+      if (timeoutId) clearTimeout(timeoutId);
+      if (abortHandler && externalSignal) externalSignal.removeEventListener("abort", abortHandler);
+    }
+    return new ReadableStream({
+      start() {
+        resetTimeout();
+      },
+      async pull(streamController) {
+        try {
+          const result = await Promise.race([reader.read(), new Promise((_, reject) => {
+            if (controller.signal.aborted) reject(new DOMException("Stream idle timeout", "AbortError"));
+            controller.signal.addEventListener("abort", () => {
+              reject(new DOMException("Stream idle timeout", "AbortError"));
+            });
+          })]);
+          if (result.done) {
+            cleanup();
+            streamController.close();
+            return;
+          }
+          resetTimeout();
+          streamController.enqueue(result.value);
+        } catch (error) {
+          cleanup();
+          reader.cancel().catch(() => {
+          });
+          if (error instanceof DOMException && error.name === "AbortError") streamController.error(new DOMException("Stream idle timeout", "AbortError"));
+          else streamController.error(error);
+        }
+      },
+      cancel(reason) {
+        cleanup();
+        reader.cancel(reason).catch(() => {
+        });
+      }
+    });
+  }
+  async function request2(method, path, body, options) {
+    const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
+    try {
+      const response2 = await fetch(buildUrl(path), {
+        method,
+        headers: buildHeaders(body ? { hasBody: true } : void 0),
+        body: body ? JSON.stringify(body) : void 0,
+        signal,
+        credentials: getCredentials()
+      });
+      if (!response2.ok) return handleHttpError(response2);
+      return {
+        ok: true,
+        data: await response2.json()
+      };
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        if (isTimeout()) return {
+          ok: false,
+          error: createTimeoutError()
+        };
+        return {
+          ok: false,
+          error: createAbortError()
+        };
+      }
+      return {
+        ok: false,
+        error: createNetworkError(error)
+      };
+    } finally {
+      cleanup();
+    }
+  }
+  async function requestBlob(path, options) {
+    const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
+    try {
+      const response2 = await fetch(buildUrl(path), {
+        method: "GET",
+        headers: buildHeaders(),
+        signal,
+        credentials: getCredentials()
+      });
+      if (!response2.ok) return handleHttpError(response2);
+      return {
+        ok: true,
+        data: await response2.blob()
+      };
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        if (isTimeout()) return {
+          ok: false,
+          error: createTimeoutError()
+        };
+        return {
+          ok: false,
+          error: createAbortError()
+        };
+      }
+      return {
+        ok: false,
+        error: createNetworkError(error)
+      };
+    } finally {
+      cleanup();
+    }
+  }
+  async function requestStream(path, options) {
+    const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
+    try {
+      const response2 = await fetch(buildUrl(path), {
+        method: "GET",
+        headers: buildHeaders(),
+        signal,
+        credentials: getCredentials()
+      });
+      if (!response2.ok) {
+        cleanup();
+        return handleHttpError(response2);
+      }
+      if (!response2.body) {
+        cleanup();
+        return {
+          ok: false,
+          error: createNetworkError(/* @__PURE__ */ new Error("Response body is null"))
+        };
+      }
+      cleanup();
+      const idleTimeout = options?.streamIdleTimeout ?? timeout;
+      return {
+        ok: true,
+        data: wrapStreamWithIdleTimeout(response2.body, idleTimeout, options?.signal)
+      };
+    } catch (error) {
+      cleanup();
+      if (error instanceof Error && error.name === "AbortError") {
+        if (isTimeout()) return {
+          ok: false,
+          error: createTimeoutError()
+        };
+        return {
+          ok: false,
+          error: createAbortError()
+        };
+      }
+      return {
+        ok: false,
+        error: createNetworkError(error)
+      };
+    }
+  }
+  async function requestNoContent(method, path, options) {
+    const { signal, cleanup, isTimeout } = createTimeoutSignal(options?.signal);
+    try {
+      const response2 = await fetch(buildUrl(path), {
+        method,
+        headers: buildHeaders(),
+        signal,
+        credentials: getCredentials()
+      });
+      if (!response2.ok) return handleHttpError(response2);
+      return {
+        ok: true,
+        data: void 0
+      };
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        if (isTimeout()) return {
+          ok: false,
+          error: createTimeoutError()
+        };
+        return {
+          ok: false,
+          error: createAbortError()
+        };
+      }
+      return {
+        ok: false,
+        error: createNetworkError(error)
+      };
+    } finally {
+      cleanup();
+    }
+  }
+  return {
+    get: (path, options) => request2("GET", path, void 0, options),
+    post: (path, body, options) => request2("POST", path, body, options),
+    put: (path, body, options) => request2("PUT", path, body, options),
+    delete: (path, options) => request2("DELETE", path, void 0, options),
+    deleteNoContent: (path, options) => requestNoContent("DELETE", path, options),
+    getBlob: (path, options) => requestBlob(path, options),
+    getStream: (path, options) => requestStream(path, options)
+  };
+}
+function buildQueryString(params) {
+  if (!params) return "";
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) if (value !== void 0) searchParams.set(key, String(value));
+  const queryString = searchParams.toString();
+  return queryString ? `?${queryString}` : "";
+}
+async function* parseSSEEvents(reader) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const events = buffer.split("\n\n");
+    buffer = events.pop() || "";
+    for (const event of events) {
+      if (event.trim() === "") continue;
+      const lines = event.split("\n");
+      const eventType = lines.find((line) => line.startsWith("event:"))?.slice(6).trim();
+      const data = lines.find((line) => line.startsWith("data:"))?.slice(5).trim();
+      if (!eventType || !data) continue;
+      if (eventType !== "message" && eventType !== "error" && eventType !== "complete") continue;
+      try {
+        yield {
+          event: eventType,
+          data: JSON.parse(data)
+        };
+      } catch {
+      }
+    }
+  }
+}
+var organizationNameRegex = /^[a-z0-9][a-z0-9_.-]*$/;
+var maxOrganizationNameLength = 128;
+var applicationNameRegex = /^[a-z0-9][a-z0-9_.-]*$/;
+var maxApplicationNameLength = 255;
+var maxVariableValueLength = 65536;
+var maxSecretValueLength = 65536;
+var expertKeyRegex = /^((?:@[a-z0-9][a-z0-9_.-]*\/)?[a-z0-9][a-z0-9_.-]*)(?:@((?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?)|@([a-z0-9][a-z0-9_.-]*))?$/;
+var expertNameRegex = /^(@[a-z0-9][a-z0-9_-]*\/)?[a-z0-9][a-z0-9_-]*$/;
+var scopeNameRegex = /^[a-z0-9][a-z0-9_-]*$/;
+var scopeNameRefRegex = /^[a-z0-9][a-z0-9_-]*(?:@(?:(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?|[a-z0-9][a-z0-9_-]*))?$/;
+var expertVersionRegex = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?$/;
+var tagNameRegex = /^[a-z0-9][a-z0-9_-]*$/;
+var maxExpertNameLength = 255;
+var maxExpertVersionTagLength = 255;
+var maxExpertKeyLength = 511;
+var maxExpertDescriptionLength = 1024 * 2;
+var maxExpertInstructionLength = 1024 * 20;
+var maxExpertDelegateItems = 255;
+var maxExpertTagItems = 8;
+var maxExpertJobQueryLength = 1024 * 20;
+var packageWithVersionRegex = /^(?:@[a-z0-9][a-z0-9_.-]*\/)?[a-z0-9][a-z0-9_.-]*(?:@(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\w.-]+)?(?:\+[\w.-]+)?|@[a-z0-9][a-z0-9_.-]*)?$/;
+var urlSafeRegex = /^[a-z0-9][a-z0-9_-]*$/;
+var maxSkillNameLength = 255;
+var maxSkillDescriptionLength = 1024 * 2;
+var maxSkillRuleLength = 1024 * 2;
+var maxSkillPickOmitItems = 255;
+var maxSkillRequiredEnvItems = 255;
+var maxSkillToolNameLength = 255;
+var maxSkillEndpointLength = 1024 * 2;
+var maxSkillInputJsonSchemaLength = 1024 * 20;
+var maxCheckpointToolCallIdLength = 255;
+var envNameRegex = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+var maxEnvNameLength = 255;
+var maxProviderBaseUrlLength = 2048;
+var maxProviderHeaderKeyLength = 255;
+var maxProviderHeaderValueLength = 2048;
+var maxProviderHeadersCount = 50;
+var cuidSchema = external_exports.string().cuid2();
+external_exports.string().min(24).cuid2();
+var runtimeVersionSchema = external_exports.enum(["v1.0"]);
+var providerSchema = external_exports.enum([
+  "anthropic",
+  "google",
+  "openai",
+  "deepseek",
+  "azure-openai",
+  "amazon-bedrock",
+  "google-vertex"
+]);
+var datetimeSchema = external_exports.string().datetime({ offset: true });
+var expertKeyFieldSchema = external_exports.string().min(1).max(maxExpertKeyLength).regex(expertKeyRegex);
+var expertNameFieldSchema = external_exports.string().min(1).max(maxExpertNameLength).regex(expertNameRegex);
+var expertVersionFieldSchema = external_exports.string().min(1).max(maxExpertVersionTagLength).regex(expertVersionRegex);
+var expertTagFieldSchema = external_exports.string().min(1).max(maxExpertVersionTagLength).regex(tagNameRegex);
+var expertCategoryFieldSchema = external_exports.enum([
+  "general",
+  "coding",
+  "research",
+  "writing",
+  "data",
+  "automation"
+]);
+var scopeNameSchema = external_exports.string().min(1).max(maxExpertNameLength).regex(scopeNameRegex);
+external_exports.string().min(1).max(maxExpertNameLength + maxExpertVersionTagLength + 1).regex(scopeNameRefRegex);
+external_exports.string().min(1).max(30);
+var organizationStatusSchema = external_exports.enum([
+  "active",
+  "inactive",
+  "deleted"
+]);
+var organizationTypeSchema = external_exports.enum([
+  "personal",
+  "personalPlus",
+  "team",
+  "serviceAdmin"
+]);
+var organizationSchema = external_exports.object({
+  type: external_exports.literal("organization"),
+  id: cuidSchema,
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema,
+  name: external_exports.string().min(1).max(maxOrganizationNameLength).regex(organizationNameRegex).optional(),
+  nameChangedAt: datetimeSchema.optional(),
+  status: organizationStatusSchema,
+  organizationType: organizationTypeSchema,
+  maxApplications: external_exports.number().int().min(0),
+  maxApiKeys: external_exports.number().int().min(0),
+  maxExperts: external_exports.number().int().min(0)
+});
+function dedent(templ, ...values) {
+  let strings = Array.from(typeof templ === "string" ? [templ] : templ);
+  const lastIndex = strings.length - 1;
+  strings[lastIndex] = (strings[lastIndex] ?? "").replace(/\r?\n([\t ]*)$/, "");
+  const indentLengths = strings.reduce((arr, str) => {
+    const matches = str.match(/\n([\t ]+|(?!\s).)/g);
+    if (matches) return arr.concat(matches.map((match) => match.match(/[\t ]/g)?.length ?? 0));
+    return arr;
+  }, []);
+  if (indentLengths.length) {
+    const pattern = new RegExp(`
+[	 ]{${Math.min(...indentLengths)}}`, "g");
+    strings = strings.map((str) => str.replace(pattern, "\n"));
+  }
+  strings[0] = (strings[0] ?? "").replace(/^\r?\n/, "");
+  let string = strings[0] ?? "";
+  values.forEach((value, i) => {
+    const endentation = string.match(/(?:^|\n)( *)$/)?.[1] ?? "";
+    let indentedValue = value;
+    if (typeof value === "string" && value.includes("\n")) indentedValue = String(value).split("\n").map((str, j) => {
+      return j === 0 ? str : `${endentation}${str}`;
+    }).join("\n");
+    string += String(indentedValue) + (strings[i + 1] ?? "");
+  });
+  return string;
+}
+external_exports.object({
+  code: external_exports.literal(400),
+  error: external_exports.literal("Bad Request"),
+  reason: external_exports.string()
+}).describe("Bad Request");
+external_exports.object({
+  code: external_exports.literal(401),
+  error: external_exports.literal("Unauthorized"),
+  reason: external_exports.literal("Failed to authenticate")
+}).describe(dedent`
+    Authentication failed. Possible reasons:
+    - Authorization header is not provided
+    - Invalid API key
+    - Session expired
+  `);
+external_exports.object({
+  code: external_exports.literal(403),
+  error: external_exports.literal("Forbidden"),
+  reason: external_exports.string()
+}).describe("Access denied. The authenticated user does not have permission to perform this action.");
+external_exports.object({
+  code: external_exports.literal(403),
+  error: external_exports.literal("Forbidden"),
+  reason: external_exports.string(),
+  details: external_exports.object({
+    minutesUsed: external_exports.number(),
+    limitMinutes: external_exports.number(),
+    upgradeUrl: external_exports.string()
+  })
+}).describe("Usage limit exceeded. Upgrade your plan to continue.");
+external_exports.object({
+  code: external_exports.literal(404),
+  error: external_exports.literal("Not Found"),
+  reason: external_exports.string()
+}).describe("Resource not found.");
+external_exports.object({
+  code: external_exports.literal(409),
+  error: external_exports.literal("Conflict"),
+  reason: external_exports.string()
+}).describe("Request conflicts with current state of the resource.");
+external_exports.object({
+  code: external_exports.literal(503),
+  error: external_exports.literal("Service Unavailable"),
+  reason: external_exports.string()
+}).describe("Service temporarily unavailable. Retry with exponential backoff.");
+external_exports.object({
+  code: external_exports.literal(422),
+  error: external_exports.literal("Validation Failed"),
+  reason: external_exports.unknown()
+}).describe("Request validation failed. Check the request body, query parameters, or path parameters.");
+var paginationMeta = external_exports.object({
+  total: external_exports.number().int().min(0),
+  take: external_exports.number().int().min(1),
+  skip: external_exports.number().int().min(0)
+});
+external_exports.object({
+  code: external_exports.literal(401),
+  error: external_exports.literal("Unauthorized"),
+  reason: external_exports.string()
+}).describe("Unauthorized");
+var applicationNameSchema = external_exports.string().min(1).max(maxApplicationNameLength).regex(applicationNameRegex);
+var applicationStatusSchema = external_exports.enum([
+  "active",
+  "inactive",
+  "deleted"
+]);
+var applicationSchema = external_exports.object({
+  type: external_exports.literal("application"),
+  id: cuidSchema,
+  organizationId: cuidSchema,
+  organization: organizationSchema,
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema,
+  name: applicationNameSchema,
+  status: applicationStatusSchema,
+  expertCount: external_exports.number().describe("Number of expert draft scopes associated with this application").optional(),
+  providers: external_exports.array(providerSchema).describe("List of configured providers for this application").optional(),
+  totalJobs: external_exports.number().describe("Total number of jobs executed for this application").optional(),
+  lastJobExecutionAt: external_exports.string().datetime({ offset: true }).nullable().describe("Timestamp of the most recent job execution").optional()
+});
+var request$17 = { body: external_exports.object({
+  name: applicationNameSchema,
+  applicationGroupId: cuidSchema.optional()
+}) };
+external_exports.object({ data: external_exports.object({ application: applicationSchema }) });
+var request$16 = { query: external_exports.object({
+  name: external_exports.preprocess((val) => Array.isArray(val) ? val.join(",") : val, external_exports.string().optional()),
+  sort: external_exports.enum([
+    "name",
+    "createdAt",
+    "updatedAt"
+  ]).optional(),
+  order: external_exports.enum(["asc", "desc"]).optional(),
+  take: external_exports.coerce.number().min(1).max(100).default(20),
+  skip: external_exports.coerce.number().min(0).default(0)
+}) };
+external_exports.object({
+  data: external_exports.object({ applications: external_exports.array(applicationSchema) }),
+  meta: paginationMeta
+});
+var request$15 = {
+  params: external_exports.object({ applicationId: cuidSchema }),
+  body: external_exports.object({
+    name: applicationNameSchema.optional(),
+    status: applicationStatusSchema.exclude(["deleted"]).optional()
+  }).refine((data) => data.name !== void 0 || data.status !== void 0, { message: "At least one field must be provided" })
+};
+external_exports.object({ data: external_exports.object({ application: applicationSchema }) });
+var secretNameSchema = external_exports.string().min(1, "Secret name is required").max(255, "Secret name must be 255 characters or less").regex(/^[A-Z][A-Z0-9_]*$/, "Secret name must start with uppercase letter and contain only uppercase letters, numbers, and underscores");
+var secretValueSchema = external_exports.string().min(1, "Secret value is required").max(maxSecretValueLength);
+var secretMetadataSchema = external_exports.object({
+  name: external_exports.string(),
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema
+});
+external_exports.object({
+  type: external_exports.literal("secret"),
+  id: cuidSchema,
+  name: secretNameSchema,
+  applicationId: cuidSchema,
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema
+});
+var request$14 = { body: external_exports.object({
+  applicationId: cuidSchema,
+  name: secretNameSchema,
+  value: secretValueSchema
+}) };
+external_exports.object({ data: external_exports.object({ secret: secretMetadataSchema }) });
+var request$13 = { query: external_exports.object({ applicationId: cuidSchema.optional() }) };
+external_exports.object({ data: external_exports.object({ secrets: external_exports.array(secretMetadataSchema) }) });
+var request$12 = {
+  params: external_exports.object({ name: external_exports.string().min(1) }),
+  body: external_exports.object({
+    applicationId: cuidSchema,
+    value: secretValueSchema
+  })
+};
+external_exports.object({ data: external_exports.object({ secret: secretMetadataSchema }) });
+var variableNameSchema = external_exports.string().min(1).max(255).regex(/^[A-Z][A-Z0-9_]*$/, "Variable name must start with uppercase letter and contain only uppercase letters, digits, and underscores");
+var variableValueSchema = external_exports.string().max(maxVariableValueLength);
+external_exports.object({
+  type: external_exports.literal("variable"),
+  id: cuidSchema,
+  applicationId: cuidSchema,
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema,
+  name: variableNameSchema,
+  value: variableValueSchema
+});
+var variableResponseSchema = external_exports.object({
+  name: variableNameSchema,
+  value: variableValueSchema,
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema
+});
+var request$11 = { body: external_exports.object({
+  applicationId: cuidSchema,
+  name: variableNameSchema,
+  value: variableValueSchema
+}) };
+external_exports.object({ data: external_exports.object({ variable: variableResponseSchema }) });
+var request$10 = { query: external_exports.object({ applicationId: cuidSchema }) };
+external_exports.object({ data: external_exports.object({ variables: external_exports.array(variableResponseSchema) }) });
+var request$9 = {
+  params: external_exports.object({ name: external_exports.string().min(1) }),
+  body: external_exports.object({
+    applicationId: cuidSchema,
+    value: variableValueSchema
+  })
+};
+external_exports.object({ data: external_exports.object({ variable: variableResponseSchema }) });
+var expertScopeSchema = external_exports.object({
+  id: cuidSchema,
+  name: scopeNameSchema,
+  organizationId: cuidSchema,
+  expertDraftScopeId: cuidSchema,
+  published: external_exports.boolean(),
+  publishedAt: datetimeSchema.nullable(),
+  category: expertCategoryFieldSchema,
+  totalRuns: external_exports.number().int().min(0),
+  totalJobs: external_exports.number().int().min(0),
+  totalStars: external_exports.number().int().min(0),
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema,
+  createdBy: cuidSchema,
+  updatedBy: cuidSchema
+});
+var expertVersionSchema = external_exports.object({
+  id: cuidSchema,
+  expertScopeId: cuidSchema,
+  version: expertVersionFieldSchema,
+  public: external_exports.boolean(),
+  yanked: external_exports.boolean(),
+  totalRuns: external_exports.number().int().min(0),
+  totalJobs: external_exports.number().int().min(0),
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema,
+  createdBy: cuidSchema,
+  updatedBy: cuidSchema,
+  tags: external_exports.array(expertTagFieldSchema),
+  readmeUrl: external_exports.string().optional()
+});
+expertScopeSchema.extend({ versions: external_exports.array(expertVersionSchema) });
+function isPrivateOrLocalIP(hostname) {
+  if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "0.0.0.0") return true;
+  const ipv4Match = hostname.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+  if (ipv4Match) {
+    const a = Number(ipv4Match[1]);
+    const b = Number(ipv4Match[2]);
+    if (a === 10) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 192 && b === 168) return true;
+    if (a === 169 && b === 254) return true;
+    if (a === 127) return true;
+  }
+  if (hostname.includes(":")) {
+    if (hostname.startsWith("fe80:") || hostname.startsWith("fc") || hostname.startsWith("fd")) return true;
+  }
+  if (hostname.startsWith("::ffff:")) {
+    if (isPrivateOrLocalIP(hostname.slice(7))) return true;
+  }
+  return false;
+}
+var sseEndpointSchema = external_exports.string().max(maxSkillEndpointLength).url().refine((url) => {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:") return false;
+    if (isPrivateOrLocalIP(parsed.hostname)) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}, { message: "Endpoint must be a public HTTPS URL" });
+var skillNameSchema = external_exports.string().min(1).max(maxSkillNameLength).regex(packageWithVersionRegex);
+var mcpStdioSkillCommandSchema = external_exports.enum(["npx", "uvx"]);
+var mcpStdioSkillSchema = external_exports.object({
+  type: external_exports.literal("mcpStdioSkill"),
+  name: external_exports.string().min(1),
+  description: external_exports.string().min(1).max(maxSkillDescriptionLength),
+  rule: external_exports.string().min(1).max(maxSkillRuleLength).optional(),
+  pick: external_exports.array(external_exports.string().min(1).max(maxSkillToolNameLength)).max(maxSkillPickOmitItems).optional().default([]),
+  omit: external_exports.array(external_exports.string().min(1).max(maxSkillToolNameLength)).max(maxSkillPickOmitItems).optional().default([]),
+  command: mcpStdioSkillCommandSchema,
+  packageName: external_exports.string().min(1).max(maxSkillNameLength).regex(packageWithVersionRegex),
+  requiredEnv: external_exports.array(external_exports.string().min(1).max(maxEnvNameLength).regex(envNameRegex)).max(maxSkillRequiredEnvItems).optional().default([])
+});
+var mcpSseSkillSchema = external_exports.object({
+  type: external_exports.literal("mcpSseSkill"),
+  name: external_exports.string().min(1),
+  description: external_exports.string().min(1).max(maxSkillDescriptionLength),
+  rule: external_exports.string().min(1).max(maxSkillRuleLength).optional(),
+  pick: external_exports.array(external_exports.string().min(1).max(maxSkillToolNameLength)).max(maxSkillPickOmitItems).optional().default([]),
+  omit: external_exports.array(external_exports.string().min(1).max(maxSkillToolNameLength)).max(maxSkillPickOmitItems).optional().default([]),
+  endpoint: sseEndpointSchema
+});
+var interactiveSkillSchema = external_exports.object({
+  type: external_exports.literal("interactiveSkill"),
+  name: external_exports.string().min(1),
+  description: external_exports.string().min(1).max(maxSkillDescriptionLength),
+  rule: external_exports.string().min(1).max(maxSkillRuleLength).optional(),
+  tools: external_exports.record(external_exports.string().min(1).max(maxSkillToolNameLength).regex(urlSafeRegex), external_exports.object({
+    description: external_exports.string().min(1).max(maxSkillDescriptionLength),
+    inputJsonSchema: external_exports.string().min(1).max(maxSkillInputJsonSchemaLength)
+  }))
+});
+var skillSchema = external_exports.discriminatedUnion("type", [
+  mcpStdioSkillSchema,
+  mcpSseSkillSchema,
+  interactiveSkillSchema
+]);
+var expertSchema = external_exports.object({
+  key: expertKeyFieldSchema,
+  name: expertNameFieldSchema,
+  version: expertVersionFieldSchema,
+  description: external_exports.string().max(maxExpertDescriptionLength).optional(),
+  instruction: external_exports.string().min(1).max(maxExpertInstructionLength),
+  skills: external_exports.record(skillNameSchema, skillSchema).optional().default({}),
+  delegates: external_exports.array(expertKeyFieldSchema).min(0).max(maxExpertDelegateItems).optional().default([]),
+  tags: external_exports.array(expertTagFieldSchema).min(0).max(maxExpertTagItems).optional().default([]),
+  minRuntimeVersion: runtimeVersionSchema.optional()
+});
+external_exports.object({
+  scope: expertScopeSchema,
+  version: expertVersionSchema
+});
+var expertWithMetadataSchema = expertSchema.extend({
+  scope: expertScopeSchema,
+  version: expertVersionSchema
+});
+var request$8 = { query: external_exports.object({
+  filter: external_exports.string().describe("Filter by scope name (partial match)").optional(),
+  category: external_exports.enum([
+    "general",
+    "coding",
+    "research",
+    "writing",
+    "data",
+    "automation"
+  ]).describe("Filter by category").optional(),
+  includeDrafts: external_exports.coerce.boolean().default(false).describe("Include unpublished scopes (owner only)").optional(),
+  take: external_exports.coerce.number().min(1).max(100).default(20),
+  skip: external_exports.coerce.number().min(0).default(0)
+}) };
+external_exports.object({
+  data: external_exports.object({ experts: external_exports.array(expertScopeSchema.extend({ currentVersion: expertVersionSchema.nullable() })) }),
+  meta: paginationMeta
+});
+var anthropicSupportModels = [
+  {
+    modelId: "claude-opus-4-5",
+    default: false,
+    provider: "anthropic",
+    contextWindow: 2e5
+  },
+  {
+    modelId: "claude-opus-4-1",
+    default: false,
+    provider: "anthropic",
+    contextWindow: 2e5
+  },
+  {
+    modelId: "claude-opus-4-20250514",
+    default: false,
+    provider: "anthropic",
+    contextWindow: 2e5
+  },
+  {
+    modelId: "claude-sonnet-4-5",
+    default: true,
+    provider: "anthropic",
+    contextWindow: 2e5
+  },
+  {
+    modelId: "claude-sonnet-4-20250514",
+    default: false,
+    provider: "anthropic",
+    contextWindow: 2e5
+  },
+  {
+    modelId: "claude-3-7-sonnet-20250219",
+    default: false,
+    provider: "anthropic",
+    contextWindow: 2e5
+  },
+  {
+    modelId: "claude-haiku-4-5",
+    default: false,
+    provider: "anthropic",
+    contextWindow: 2e5
+  },
+  {
+    modelId: "claude-3-5-haiku-latest",
+    default: false,
+    provider: "anthropic",
+    contextWindow: 2e5
+  }
+];
+var googleSupportModels = [
+  {
+    modelId: "gemini-3-pro-preview",
+    default: false,
+    provider: "google",
+    contextWindow: 1e6
+  },
+  {
+    modelId: "gemini-2.5-pro",
+    default: true,
+    provider: "google",
+    contextWindow: 1e6
+  },
+  {
+    modelId: "gemini-2.5-flash",
+    default: false,
+    provider: "google",
+    contextWindow: 1e6
+  },
+  {
+    modelId: "gemini-2.5-flash-lite",
+    default: false,
+    provider: "google",
+    contextWindow: 1e6
+  }
+];
+var openAiSupportModels = [
+  {
+    modelId: "gpt-5",
+    default: true,
+    provider: "openai",
+    contextWindow: 4e5
+  },
+  {
+    modelId: "gpt-5-mini",
+    default: false,
+    provider: "openai",
+    contextWindow: 4e5
+  },
+  {
+    modelId: "gpt-5-nano",
+    default: false,
+    provider: "openai",
+    contextWindow: 4e5
+  },
+  {
+    modelId: "gpt-5-chat-latest",
+    default: false,
+    provider: "openai",
+    contextWindow: 128e3
+  },
+  {
+    modelId: "o4-mini",
+    default: false,
+    provider: "openai",
+    contextWindow: 2e5
+  },
+  {
+    modelId: "o3",
+    default: false,
+    provider: "openai",
+    contextWindow: 2e5
+  },
+  {
+    modelId: "o3-mini",
+    default: false,
+    provider: "openai",
+    contextWindow: 2e5
+  },
+  {
+    modelId: "gpt-4.1",
+    default: false,
+    provider: "openai",
+    contextWindow: 1e6
+  }
+];
+var deepseekSupportModels = [{
+  modelId: "deepseek-chat",
+  default: true,
+  provider: "deepseek",
+  contextWindow: 128e3
+}, {
+  modelId: "deepseek-reasoner",
+  default: false,
+  provider: "deepseek",
+  contextWindow: 128e3
+}];
+var allSupportModels = [
+  ...anthropicSupportModels,
+  ...googleSupportModels,
+  ...openAiSupportModels,
+  ...deepseekSupportModels
+];
+var supportModels = Object.fromEntries(allSupportModels.map((model) => [model.modelId, model]));
+function getSupportModelNames() {
+  return Object.keys(supportModels);
+}
+var reasoningBudgetSchema = external_exports.union([external_exports.enum([
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high"
+]), external_exports.number().int().min(0)]);
+var jobStatusSchema = external_exports.enum([
+  "queued",
+  "processing",
+  "completed",
+  "requestInteractiveToolResult",
+  "requestDelegateResult",
+  "exceededMaxSteps",
+  "failed",
+  "canceling",
+  "canceled",
+  "expired"
+]);
+var modelNames = getSupportModelNames();
+var firstModel = modelNames[0];
+if (firstModel === void 0) throw new Error("No support models available");
+var jobModelSchema = external_exports.enum([firstModel, ...modelNames.slice(1)]);
+var jobBaseSchema = external_exports.object({
+  type: external_exports.literal("job"),
+  id: cuidSchema,
+  organizationId: cuidSchema,
+  applicationId: cuidSchema,
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema,
+  status: jobStatusSchema,
+  currentExecutionId: cuidSchema.optional(),
+  coordinatorExpertKey: expertKeyFieldSchema,
+  query: external_exports.string().min(1).max(maxExpertJobQueryLength).optional(),
+  expert: expertWithMetadataSchema,
+  provider: providerSchema,
+  model: jobModelSchema,
+  reasoningBudget: reasoningBudgetSchema,
+  runtimeVersion: runtimeVersionSchema,
+  maxSteps: external_exports.number().int().min(1),
+  maxRetries: external_exports.number().int().min(0),
+  currentStep: external_exports.number().int().min(0),
+  totalSteps: external_exports.number().int().min(0),
+  totalDuration: external_exports.number().int().min(0),
+  usage: usageSchema,
+  lastActivity: activityOrGroupSchema.nullable().optional()
+});
+var publishedJobSchema = jobBaseSchema.extend({
+  expertVersionId: cuidSchema,
+  expertDraftRefId: external_exports.undefined()
+});
+var draftJobSchema = jobBaseSchema.extend({
+  expertVersionId: external_exports.undefined(),
+  expertDraftRefId: cuidSchema
+});
+var jobSchema = external_exports.union([publishedJobSchema, draftJobSchema]);
+var request$7 = {
+  params: external_exports.object({ jobId: cuidSchema }),
+  body: external_exports.object({
+    query: external_exports.string().min(1).max(maxExpertJobQueryLength),
+    provider: providerSchema.optional(),
+    model: jobModelSchema.optional(),
+    reasoningBudget: reasoningBudgetSchema.optional(),
+    maxSteps: external_exports.coerce.number().optional(),
+    maxRetries: external_exports.coerce.number().optional()
+  })
+};
+external_exports.object({ data: external_exports.object({ job: jobSchema }) });
+var baseBodySchema = external_exports.object({
+  applicationId: cuidSchema.describe("Application ID to create the job in"),
+  query: external_exports.string().min(1).max(maxExpertJobQueryLength),
+  provider: providerSchema,
+  model: jobModelSchema.optional(),
+  reasoningBudget: reasoningBudgetSchema.optional(),
+  maxSteps: external_exports.coerce.number().optional(),
+  maxRetries: external_exports.coerce.number().optional()
+});
+var request$6 = { body: baseBodySchema.extend({
+  expertKey: expertKeyFieldSchema.optional(),
+  draftRefId: cuidSchema.describe("Draft ref ID to run the job with").optional()
+}).refine((data) => {
+  const hasExpertKey = data.expertKey !== void 0;
+  const hasDraftRefId = data.draftRefId !== void 0;
+  return hasExpertKey && !hasDraftRefId || !hasExpertKey && hasDraftRefId;
+}, { message: "Either expertKey or draftRefId must be provided, but not both" }) };
+external_exports.object({ data: external_exports.object({ job: jobSchema }) });
+var request$5 = { query: external_exports.object({
+  sort: external_exports.enum(["createdAt", "updatedAt"]).optional(),
+  order: external_exports.enum(["asc", "desc"]).optional(),
+  take: external_exports.coerce.number().min(1).max(100).default(20),
+  skip: external_exports.coerce.number().min(0).default(0),
+  expertScopeId: cuidSchema.optional(),
+  expertDraftScopeId: cuidSchema.optional(),
+  applicationId: cuidSchema.optional(),
+  statuses: external_exports.preprocess((val) => typeof val === "string" ? val.split(",") : val, external_exports.array(jobStatusSchema).optional()),
+  expertKeyFilter: external_exports.string().max(100).optional()
+}) };
+external_exports.object({
+  data: external_exports.object({ jobs: external_exports.array(jobSchema) }),
+  meta: paginationMeta
+});
+var delegationTargetSchema = external_exports.object({
+  expert: expertSchema,
+  toolCallId: external_exports.string().min(1).max(maxCheckpointToolCallIdLength),
+  toolName: external_exports.string().min(1).max(maxSkillToolNameLength),
+  query: external_exports.string().min(1)
+});
+var apiCheckpointSchema = external_exports.object({
+  type: external_exports.literal("checkpoint"),
+  id: cuidSchema,
+  jobId: cuidSchema,
+  runId: cuidSchema,
+  activities: external_exports.array(activityOrGroupSchema),
+  stepNumber: external_exports.number().int().min(1),
+  status: external_exports.enum([
+    "init",
+    "proceeding",
+    "completed",
+    "stoppedByInteractiveTool",
+    "stoppedByDelegate",
+    "stoppedByExceededMaxSteps",
+    "stoppedByError"
+  ]),
+  expert: expertSchema,
+  delegateTo: external_exports.array(delegationTargetSchema).optional(),
+  delegatedBy: external_exports.object({
+    expert: expertSchema,
+    toolCallId: external_exports.string().min(1).max(maxCheckpointToolCallIdLength),
+    toolName: external_exports.string().min(1).max(maxSkillToolNameLength),
+    checkpointId: cuidSchema,
+    runId: cuidSchema
+  }).optional(),
+  inputMessages: external_exports.array(external_exports.union([
+    instructionMessageSchema,
+    userMessageSchema,
+    toolMessageSchema
+  ])).optional(),
+  messages: external_exports.array(messageSchema),
+  newMessages: external_exports.array(messageSchema),
+  toolCalls: external_exports.array(toolCallSchema).optional(),
+  toolResults: external_exports.array(toolResultSchema).optional(),
+  pendingToolCalls: external_exports.array(toolCallSchema).optional(),
+  partialToolResults: external_exports.array(toolResultSchema).optional(),
+  usage: usageSchema,
+  contextWindow: external_exports.number().int().min(0).optional(),
+  contextWindowUsage: external_exports.number().int().min(0).optional(),
+  error: external_exports.object({
+    name: external_exports.string().min(1),
+    message: external_exports.string().min(1),
+    statusCode: external_exports.number().int().min(100).max(599).optional(),
+    isRetryable: external_exports.boolean()
+  }).optional(),
+  retryCount: external_exports.number().int().min(0).optional(),
+  startedAt: datetimeSchema,
+  finishedAt: datetimeSchema.optional()
+});
+var request$4 = {
+  params: external_exports.object({
+    jobId: cuidSchema,
+    runId: cuidSchema
+  }),
+  query: external_exports.object({
+    filter: external_exports.string().min(1).max(256).optional(),
+    sort: external_exports.enum(["createdAt", "updatedAt"]).optional(),
+    order: external_exports.enum(["asc", "desc"]).optional(),
+    take: external_exports.coerce.number().min(1).max(100).default(20),
+    skip: external_exports.coerce.number().min(0).default(0)
+  })
+};
+external_exports.object({
+  data: external_exports.object({ checkpoints: external_exports.array(apiCheckpointSchema) }),
+  meta: paginationMeta
+});
+var runStatusSchema = external_exports.enum([
+  "queued",
+  "processing",
+  "completed",
+  "stoppedByInteractiveTool",
+  "stoppedByDelegate",
+  "stoppedByExceededMaxSteps",
+  "stoppedByError"
+]);
+var runSchema = external_exports.object({
+  type: external_exports.literal("run"),
+  id: cuidSchema,
+  jobId: cuidSchema,
+  executionId: cuidSchema.optional(),
+  parentRunId: cuidSchema.optional(),
+  organizationId: cuidSchema,
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema,
+  status: runStatusSchema,
+  expertKey: expertKeyFieldSchema,
+  expert: expertWithMetadataSchema,
+  stepNumber: external_exports.number().int().min(0),
+  usage: usageSchema
+});
+var request$3 = {
+  params: external_exports.object({ jobId: cuidSchema }),
+  query: external_exports.object({
+    sort: external_exports.enum(["createdAt", "updatedAt"]).optional(),
+    order: external_exports.enum(["asc", "desc"]).optional(),
+    take: external_exports.coerce.number().min(1).max(100).default(20),
+    skip: external_exports.coerce.number().min(0).default(0)
+  })
+};
+external_exports.object({
+  data: external_exports.object({ runs: external_exports.array(runSchema) }),
+  meta: paginationMeta
+});
+var baseUrlSchema = external_exports.string().url().max(maxProviderBaseUrlLength).optional();
+var headersSchema = external_exports.record(external_exports.string().min(1).max(maxProviderHeaderKeyLength), external_exports.string().max(maxProviderHeaderValueLength)).refine((headers) => Object.keys(headers).length <= maxProviderHeadersCount, { message: `Headers must have at most ${maxProviderHeadersCount} entries` }).optional();
+var anthropicProviderSettingsSchema = external_exports.object({
+  baseUrl: baseUrlSchema,
+  headers: headersSchema
+});
+var googleProviderSettingsSchema = external_exports.object({
+  baseUrl: baseUrlSchema,
+  headers: headersSchema
+});
+var openaiProviderSettingsSchema = external_exports.object({
+  baseUrl: baseUrlSchema,
+  headers: headersSchema,
+  organization: external_exports.string().min(1).optional(),
+  project: external_exports.string().min(1).optional(),
+  name: external_exports.string().min(1).optional()
+});
+var deepseekProviderSettingsSchema = external_exports.object({
+  baseUrl: baseUrlSchema,
+  headers: headersSchema
+});
+var azureOpenaiProviderSettingsSchema = external_exports.object({
+  baseUrl: baseUrlSchema,
+  headers: headersSchema,
+  resourceName: external_exports.string().min(1).optional(),
+  apiVersion: external_exports.string().min(1).optional(),
+  useDeploymentBasedUrls: external_exports.boolean().optional()
+});
+var amazonBedrockProviderSettingsSchema = external_exports.object({ region: external_exports.string().min(1).optional() });
+var googleVertexProviderSettingsSchema = external_exports.object({
+  baseUrl: baseUrlSchema,
+  headers: headersSchema,
+  project: external_exports.string().min(1).optional(),
+  location: external_exports.string().min(1).optional()
+});
+var providerSettingsSchema = external_exports.union([
+  anthropicProviderSettingsSchema,
+  googleProviderSettingsSchema,
+  openaiProviderSettingsSchema,
+  deepseekProviderSettingsSchema,
+  azureOpenaiProviderSettingsSchema,
+  amazonBedrockProviderSettingsSchema,
+  googleVertexProviderSettingsSchema
+]);
+external_exports.object({
+  type: external_exports.literal("providerSetting"),
+  id: cuidSchema,
+  applicationId: cuidSchema,
+  provider: providerSchema,
+  settings: providerSettingsSchema.optional(),
+  application: applicationSchema,
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema
+});
+var providerSettingResponseSchema = external_exports.object({
+  type: external_exports.literal("providerSetting"),
+  id: cuidSchema,
+  provider: providerSchema,
+  settings: providerSettingsSchema.optional(),
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema
+});
+var providerApiKeyMetadataSchema = external_exports.object({
+  id: cuidSchema,
+  name: external_exports.string(),
+  createdAt: datetimeSchema,
+  updatedAt: datetimeSchema,
+  lastUsedAt: datetimeSchema.nullable(),
+  expiresAt: datetimeSchema.nullable()
+});
+var request$2 = {
+  params: external_exports.object({
+    applicationId: cuidSchema,
+    provider: providerSchema
+  }),
+  body: external_exports.object({
+    name: external_exports.string().min(1).max(255),
+    value: external_exports.string().min(1)
+  })
+};
+external_exports.object({ data: external_exports.object({ apiKey: providerApiKeyMetadataSchema }) });
+var request$1 = {
+  params: external_exports.object({ applicationId: cuidSchema }),
+  body: external_exports.object({
+    provider: providerSchema,
+    settings: providerSettingsSchema.optional()
+  })
+};
+external_exports.object({ data: external_exports.object({ providerSetting: providerSettingResponseSchema }) });
+var request = {
+  params: external_exports.object({
+    applicationId: cuidSchema,
+    provider: providerSchema
+  }),
+  body: external_exports.object({ settings: providerSettingsSchema.optional() })
+};
+external_exports.object({ data: external_exports.object({ providerSetting: providerSettingResponseSchema }) });
+function createRunCheckpointsApi(fetcher, basePath) {
+  return {
+    async list(jobId, runId, params, options) {
+      if (params) {
+        const result = request$4.query.safeParse(params);
+        if (!result.success) return {
+          ok: false,
+          error: createValidationError(result.error)
+        };
+      }
+      const queryString = buildQueryString(params);
+      return fetcher.get(`${basePath}/${jobId}/runs/${runId}/checkpoints${queryString}`, options);
+    },
+    async get(jobId, runId, checkpointId, options) {
+      return fetcher.get(`${basePath}/${jobId}/runs/${runId}/checkpoints/${checkpointId}`, options);
+    }
+  };
+}
+function createRunsApi(fetcher, basePath) {
+  return {
+    async list(jobId, params, options) {
+      if (params) {
+        const result = request$3.query.safeParse(params);
+        if (!result.success) return {
+          ok: false,
+          error: createValidationError(result.error)
+        };
+      }
+      const queryString = buildQueryString(params);
+      return fetcher.get(`${basePath}/${jobId}/runs${queryString}`, options);
+    },
+    async get(jobId, runId, options) {
+      return fetcher.get(`${basePath}/${jobId}/runs/${runId}`, options);
+    },
+    checkpoints: createRunCheckpointsApi(fetcher, basePath)
+  };
+}
+var BASE_PATH$5 = "/api/v1/jobs";
+var StreamError = class extends Error {
+  constructor(type, jobId, message) {
+    super(message ?? `Stream error: ${type}`);
+    this.type = type;
+    this.jobId = jobId;
+    this.name = "StreamError";
+  }
+};
+var StreamConnectionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StreamConnectionError";
+  }
+};
+function isErrorEventData(data) {
+  return typeof data === "object" && data !== null && "type" in data && typeof data.type === "string" && "jobId" in data && typeof data.jobId === "string";
+}
+function isCompleteEventData(data) {
+  return typeof data === "object" && data !== null && "status" in data && typeof data.status === "string" && "jobId" in data && typeof data.jobId === "string";
+}
+function createJobsApi(fetcher) {
+  return {
+    async list(params, options) {
+      if (params) {
+        const result = request$5.query.safeParse(params);
+        if (!result.success) return {
+          ok: false,
+          error: createValidationError(result.error)
+        };
+      }
+      const queryString = buildQueryString(params);
+      return fetcher.get(`${BASE_PATH$5}${queryString}`, options);
+    },
+    async get(id, options) {
+      return fetcher.get(`${BASE_PATH$5}/${id}`, options);
+    },
+    async start(input, options) {
+      const result = request$6.body.safeParse(input);
+      if (!result.success) return {
+        ok: false,
+        error: createValidationError(result.error)
+      };
+      return fetcher.post(BASE_PATH$5, input, options);
+    },
+    async continue(id, input, options) {
+      const result = request$7.body.safeParse(input);
+      if (!result.success) return {
+        ok: false,
+        error: createValidationError(result.error)
+      };
+      return fetcher.post(`${BASE_PATH$5}/${id}/continue`, input, options);
+    },
+    async cancel(id, options) {
+      return fetcher.post(`${BASE_PATH$5}/${id}/cancel`, {}, options);
+    },
+    async *stream(id, options) {
+      const result = await fetcher.getStream(`${BASE_PATH$5}/${id}/stream`, options);
+      if (!result.ok) throw new StreamConnectionError(result.error.message);
+      const reader = result.data.getReader();
+      try {
+        for await (const sseEvent of parseSSEEvents(reader)) if (sseEvent.event === "message") yield sseEvent.data;
+        else if (sseEvent.event === "error" && isErrorEventData(sseEvent.data)) throw new StreamError(sseEvent.data.type, sseEvent.data.jobId, sseEvent.data.message);
+        else if (sseEvent.event === "complete" && isCompleteEventData(sseEvent.data)) return;
+      } catch (error) {
+        if (error instanceof StreamError || error instanceof StreamConnectionError) throw error;
+        if (error instanceof DOMException && error.name === "AbortError") throw error;
+        throw new StreamConnectionError(error instanceof Error ? error.message : "Stream read error");
+      }
+    },
+    runs: createRunsApi(fetcher, BASE_PATH$5)
+  };
+}
+var BASE_PATH$4 = "/api/v1/applications";
+function createApplicationsApi(fetcher) {
+  return {
+    async list(params, options) {
+      if (params) {
+        const result = request$16.query.safeParse(params);
+        if (!result.success) return {
+          ok: false,
+          error: createValidationError(result.error)
+        };
+      }
+      const queryString = buildQueryString(params);
+      return fetcher.get(`${BASE_PATH$4}${queryString}`, options);
+    },
+    async get(id, options) {
+      return fetcher.get(`${BASE_PATH$4}/${id}`, options);
+    },
+    async create(input, options) {
+      const result = request$17.body.safeParse(input);
+      if (!result.success) return {
+        ok: false,
+        error: createValidationError(result.error)
+      };
+      return fetcher.post(BASE_PATH$4, input, options);
+    },
+    async update(id, input, options) {
+      const result = request$15.body.safeParse(input);
+      if (!result.success) return {
+        ok: false,
+        error: createValidationError(result.error)
+      };
+      return fetcher.post(`${BASE_PATH$4}/${id}`, input, options);
+    },
+    async delete(id, options) {
+      return fetcher.delete(`${BASE_PATH$4}/${id}`, options);
+    }
+  };
+}
+var BASE_PATH$3 = "/api/v1/env/secrets";
+function createSecretsApi(fetcher) {
+  return {
+    async list(params, options) {
+      if (params) {
+        const result = request$13.query.safeParse(params);
+        if (!result.success) return {
+          ok: false,
+          error: createValidationError(result.error)
+        };
+      }
+      const queryString = buildQueryString(params);
+      return fetcher.get(`${BASE_PATH$3}${queryString}`, options);
+    },
+    async get(name, options) {
+      const encodedName = encodeURIComponent(name);
+      return fetcher.get(`${BASE_PATH$3}/${encodedName}`, options);
+    },
+    async create(input, options) {
+      const result = request$14.body.safeParse(input);
+      if (!result.success) return {
+        ok: false,
+        error: createValidationError(result.error)
+      };
+      return fetcher.post(BASE_PATH$3, input, options);
+    },
+    async update(name, input, options) {
+      const result = request$12.body.safeParse(input);
+      if (!result.success) return {
+        ok: false,
+        error: createValidationError(result.error)
+      };
+      const encodedName = encodeURIComponent(name);
+      return fetcher.put(`${BASE_PATH$3}/${encodedName}`, input, options);
+    },
+    async delete(name, options) {
+      const encodedName = encodeURIComponent(name);
+      return fetcher.deleteNoContent(`${BASE_PATH$3}/${encodedName}`, options);
+    }
+  };
+}
+var BASE_PATH$2 = "/api/v1/env/variables";
+function createVariablesApi(fetcher) {
+  return {
+    async list(params, options) {
+      const result = request$10.query.safeParse(params);
+      if (!result.success) return {
+        ok: false,
+        error: createValidationError(result.error)
+      };
+      const queryString = buildQueryString(params);
+      return fetcher.get(`${BASE_PATH$2}${queryString}`, options);
+    },
+    async get(name, options) {
+      const encodedName = encodeURIComponent(name);
+      return fetcher.get(`${BASE_PATH$2}/${encodedName}`, options);
+    },
+    async create(input, options) {
+      const result = request$11.body.safeParse(input);
+      if (!result.success) return {
+        ok: false,
+        error: createValidationError(result.error)
+      };
+      return fetcher.post(BASE_PATH$2, input, options);
+    },
+    async update(name, input, options) {
+      const result = request$9.body.safeParse(input);
+      if (!result.success) return {
+        ok: false,
+        error: createValidationError(result.error)
+      };
+      const encodedName = encodeURIComponent(name);
+      return fetcher.put(`${BASE_PATH$2}/${encodedName}`, input, options);
+    },
+    async delete(name, options) {
+      const encodedName = encodeURIComponent(name);
+      return fetcher.deleteNoContent(`${BASE_PATH$2}/${encodedName}`, options);
+    }
+  };
+}
+function createEnvApi(fetcher) {
+  return {
+    secrets: createSecretsApi(fetcher),
+    variables: createVariablesApi(fetcher)
+  };
+}
+function createVersionsApi(fetcher, basePath) {
+  return { async list(scopeName, options) {
+    const encodedScopeName = encodeURIComponent(scopeName);
+    return fetcher.get(`${basePath}/${encodedScopeName}/versions`, options);
+  } };
+}
+var BASE_PATH$1 = "/api/v1/experts";
+function createExpertsApi(fetcher) {
+  return {
+    async list(params, options) {
+      if (params) {
+        const result = request$8.query.safeParse(params);
+        if (!result.success) return {
+          ok: false,
+          error: createValidationError(result.error)
+        };
+      }
+      const queryString = buildQueryString(params);
+      return fetcher.get(`${BASE_PATH$1}${queryString}`, options);
+    },
+    async get(key, options) {
+      const encodedKey = encodeURIComponent(key);
+      return fetcher.get(`${BASE_PATH$1}/${encodedKey}`, options);
+    },
+    async getFeatured(options) {
+      return fetcher.get(`${BASE_PATH$1}/featured`, options);
+    },
+    async getMeta(key, options) {
+      const encodedKey = encodeURIComponent(key);
+      return fetcher.get(`${BASE_PATH$1}/${encodedKey}/meta`, options);
+    },
+    async publish(scopeName, options) {
+      const encodedScopeName = encodeURIComponent(scopeName);
+      return fetcher.post(`${BASE_PATH$1}/${encodedScopeName}/publish`, {}, options);
+    },
+    async unpublish(scopeName, options) {
+      const encodedScopeName = encodeURIComponent(scopeName);
+      return fetcher.post(`${BASE_PATH$1}/${encodedScopeName}/unpublish`, {}, options);
+    },
+    async yank(key, options) {
+      const encodedKey = encodeURIComponent(key);
+      return fetcher.delete(`${BASE_PATH$1}/${encodedKey}`, options);
+    },
+    versions: createVersionsApi(fetcher, BASE_PATH$1)
+  };
+}
+var BASE_PATH = "/api/v1/applications";
+function createProviderSettingsApi(fetcher) {
+  return {
+    async list(applicationId, options) {
+      return fetcher.get(`${BASE_PATH}/${applicationId}/provider_settings`, options);
+    },
+    async get(applicationId, provider, options) {
+      const encodedProvider = encodeURIComponent(provider);
+      return fetcher.get(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}`, options);
+    },
+    async create(applicationId, input, options) {
+      const result = request$1.body.safeParse(input);
+      if (!result.success) return {
+        ok: false,
+        error: createValidationError(result.error)
+      };
+      return fetcher.post(`${BASE_PATH}/${applicationId}/provider_settings`, input, options);
+    },
+    async update(applicationId, provider, input, options) {
+      const result = request.body.safeParse(input);
+      if (!result.success) return {
+        ok: false,
+        error: createValidationError(result.error)
+      };
+      const encodedProvider = encodeURIComponent(provider);
+      return fetcher.post(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}`, input, options);
+    },
+    async delete(applicationId, provider, options) {
+      const encodedProvider = encodeURIComponent(provider);
+      return fetcher.deleteNoContent(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}`, options);
+    },
+    async listApiKeys(applicationId, provider, options) {
+      const encodedProvider = encodeURIComponent(provider);
+      return fetcher.get(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}/api_keys`, options);
+    },
+    async createApiKey(applicationId, provider, input, options) {
+      const result = request$2.body.safeParse(input);
+      if (!result.success) return {
+        ok: false,
+        error: createValidationError(result.error)
+      };
+      const encodedProvider = encodeURIComponent(provider);
+      return fetcher.post(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}/api_keys`, input, options);
+    },
+    async deleteApiKey(applicationId, provider, apiKeyId, options) {
+      const encodedProvider = encodeURIComponent(provider);
+      const encodedApiKeyId = encodeURIComponent(apiKeyId);
+      return fetcher.deleteNoContent(`${BASE_PATH}/${applicationId}/provider_settings/${encodedProvider}/api_keys/${encodedApiKeyId}`, options);
+    }
+  };
+}
+function createApiClient(config) {
+  const fetcher = createFetcher(config);
+  return {
+    applications: createApplicationsApi(fetcher),
+    env: createEnvApi(fetcher),
+    jobs: createJobsApi(fetcher),
+    experts: createExpertsApi(fetcher),
+    providerSettings: createProviderSettingsApi(fetcher)
+  };
+}
+
+export { createApiClient };
+//# sourceMappingURL=chunk-HNOP6GUQ.js.map
+//# sourceMappingURL=chunk-HNOP6GUQ.js.map