@slates/provider 1.0.0-rc.1 → 1.0.0-rc.10

package/dist/index.module.js

@@ -0,0 +1,1809 @@
+// src/action/action.ts
+var SlateAction = class {
+  constructor(type, _spec, _inputSchema, _outputSchema, _params) {
+    this.type = type;
+    this._spec = _spec;
+    this._inputSchema = _inputSchema;
+    this._outputSchema = _outputSchema;
+    this._params = _params;
+  }
+  type;
+  _spec;
+  _inputSchema;
+  _outputSchema;
+  _params;
+  get configSchema() {
+    return this._spec.configSchema;
+  }
+  get inputSchema() {
+    return this._inputSchema;
+  }
+  get outputSchema() {
+    return this._outputSchema;
+  }
+  get parameters() {
+    return this._params;
+  }
+  get key() {
+    return this._params.key;
+  }
+  get name() {
+    return this._params.name;
+  }
+  get description() {
+    return this._params.description;
+  }
+  get tags() {
+    return this._params.tags;
+  }
+  get instructions() {
+    return this._params.instructions;
+  }
+  get constraints() {
+    return this._params.constraints;
+  }
+  get metadata() {
+    return this._params.metadata;
+  }
+  get scopes() {
+    return this._params.scopes;
+  }
+};
+
+// src/error/axios.ts
+import { isAxiosError } from "axios";
+
+// src/context/hook.ts
+import { AsyncLocalStorage } from "async_hooks";
+var asyncLocalStorage = new AsyncLocalStorage();
+var runWithContext = (context, fn) => {
+  return asyncLocalStorage.run(context, fn);
+};
+var getCurrentContext = () => {
+  let context = asyncLocalStorage.getStore();
+  if (!context) {
+    throw new Error("No Slate context is available");
+  }
+  return context;
+};
+
+// src/error/defaults.ts
+var DEFAULT_CODE = "internal.unexpected";
+var DEFAULT_MESSAGES = {
+  "declaration.invalid_definition": "The slate definition is invalid.",
+  "context.missing": "No Slate context is available.",
+  "input.invalid": "The provided input is invalid.",
+  "request.bad": "The request is invalid.",
+  "request.invalid_version": "The requested version is invalid.",
+  "request.precondition_failed": "The request precondition failed.",
+  "request.not_acceptable": "The request is not acceptable.",
+  "request.rate_limited": "Too many requests were made in a short period of time.",
+  "config.invalid": "The provided configuration is invalid.",
+  "auth.required": "Authentication is required.",
+  "auth.invalid": "Authentication failed.",
+  "auth.expired": "Authentication has expired.",
+  "permission.denied": "Permission was denied.",
+  "resource.not_found": "The requested resource was not found.",
+  "resource.conflict": "The requested resource is in conflict.",
+  "resource.gone": "The requested resource is no longer available.",
+  "payment.required": "Payment is required to continue.",
+  "operation.not_implemented": "The requested operation is not implemented.",
+  "upstream.invalid_request": "The upstream service rejected the request.",
+  "upstream.rate_limited": "The upstream service rate limited the request.",
+  "upstream.timeout": "The upstream service timed out.",
+  "upstream.network_error": "A network error occurred while contacting the upstream service.",
+  "upstream.unavailable": "The upstream service is unavailable.",
+  "upstream.invalid_response": "The upstream service returned an invalid response.",
+  "upstream.error": "The upstream service returned an error.",
+  "transport.invoke_failed": "The provider transport failed.",
+  "internal.timeout": "The operation timed out.",
+  "internal.unexpected": "An unexpected internal error occurred."
+};
+var SERVICE_ERROR_CODE_MAP = {
+  invalid_data: "input.invalid",
+  bad_request: "request.bad",
+  not_found: "resource.not_found",
+  unauthorized: "auth.required",
+  forbidden: "permission.denied",
+  invalid_version: "request.invalid_version",
+  conflict: "resource.conflict",
+  gone: "resource.gone",
+  payment_required: "payment.required",
+  precondition_failed: "request.precondition_failed",
+  not_acceptable: "request.not_acceptable",
+  not_implemented: "operation.not_implemented",
+  too_many_requests: "request.rate_limited",
+  timeout: "internal.timeout",
+  internal_server_error: "internal.unexpected"
+};
+
+// src/error/utils.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var normalizeKind = (code, kind) => {
+  if (kind) return kind;
+  if (code.startsWith("declaration.")) return "declaration";
+  if (code.startsWith("input.")) return "validation";
+  if (code.startsWith("request.")) return "request";
+  if (code.startsWith("config.")) return "config";
+  if (code.startsWith("auth.") || code.startsWith("permission.")) return "auth";
+  if (code.startsWith("resource.")) return "resource";
+  if (code.startsWith("payment.")) return "payment";
+  if (code.startsWith("transport.")) return "transport";
+  if (code.startsWith("upstream.")) return "upstream";
+  return "internal";
+};
+var normalizeStatus = (code, status) => {
+  if (status) return status;
+  if (code === "input.invalid" || code === "request.bad" || code === "config.invalid")
+    return 400;
+  if (code === "request.invalid_version") return 400;
+  if (code === "auth.required" || code === "auth.invalid" || code === "auth.expired")
+    return 401;
+  if (code === "payment.required") return 402;
+  if (code === "permission.denied") return 403;
+  if (code === "resource.not_found") return 404;
+  if (code === "resource.conflict") return 409;
+  if (code === "resource.gone") return 410;
+  if (code === "request.not_acceptable") return 406;
+  if (code === "request.precondition_failed") return 412;
+  if (code === "request.rate_limited" || code === "upstream.rate_limited") return 429;
+  if (code === "operation.not_implemented") return 501;
+  if (code === "upstream.invalid_request") return 400;
+  if (code === "upstream.timeout" || code === "internal.timeout") return 504;
+  if (code === "upstream.unavailable") return 503;
+  if (code === "upstream.error") return 502;
+  return void 0;
+};
+var normalizeRetryable = (code, retryable) => {
+  if (typeof retryable === "boolean") return retryable;
+  return code === "request.rate_limited" || code === "upstream.rate_limited" || code === "upstream.timeout" || code === "upstream.network_error" || code === "upstream.unavailable" || code === "upstream.error" || code === "transport.invoke_failed" || code === "internal.timeout";
+};
+var getDefaultMessage = (code, message) => {
+  if (message && message.trim()) return message;
+  return DEFAULT_MESSAGES[code] ?? DEFAULT_MESSAGES[DEFAULT_CODE];
+};
+var cleanRecord = (value) => {
+  if (!value) return void 0;
+  let entries = Object.entries(value).filter(([, entry]) => entry !== void 0);
+  if (entries.length === 0) return void 0;
+  return Object.fromEntries(entries);
+};
+var mergeRecords = (left, right) => {
+  if (!left && !right) return void 0;
+  return cleanRecord({
+    ...left ?? {},
+    ...right ?? {}
+  });
+};
+var mergeSlateErrorData = (base, override) => {
+  if (!override) return base;
+  return {
+    ...base,
+    ...override,
+    provider: cleanRecord({
+      ...base.provider ?? {},
+      ...override.provider ?? {}
+    }),
+    upstream: cleanRecord({
+      ...base.upstream ?? {},
+      ...override.upstream ?? {}
+    }),
+    baggage: mergeRecords(base.baggage, override.baggage),
+    issues: override.issues ?? base.issues,
+    requestTraces: override.requestTraces ?? base.requestTraces
+  };
+};
+var sanitizeForBaggage = (value, depth = 0) => {
+  if (value == null) return value;
+  if (depth >= 4) return "[truncated]";
+  if (typeof value === "string") {
+    return value.length > 2e3 ? `${value.slice(0, 2e3)}...[truncated]` : value;
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, 20).map((item) => sanitizeForBaggage(item, depth + 1));
+  }
+  if (isRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).slice(0, 30).map(([key, entry]) => [key, sanitizeForBaggage(entry, depth + 1)])
+    );
+  }
+  return String(value);
+};
+var normalizeSlateErrorInput = (input) => {
+  let code = input.code || DEFAULT_CODE;
+  return {
+    code,
+    message: getDefaultMessage(code, input.message),
+    kind: normalizeKind(code, input.kind),
+    retryable: normalizeRetryable(code, input.retryable),
+    status: normalizeStatus(code, input.status ?? input.upstream?.status),
+    issues: input.issues,
+    provider: cleanRecord(input.provider),
+    upstream: cleanRecord({
+      ...input.upstream,
+      status: input.upstream?.status ?? input.status
+    }),
+    baggage: cleanRecord(input.baggage),
+    requestTraces: input.requestTraces
+  };
+};
+var isSlateErrorResponse = (error) => {
+  if (!isRecord(error)) return false;
+  return typeof error.code === "string" && typeof error.message === "string";
+};
+
+// src/error/axios.ts
+var getResponseField = (value, key) => {
+  if (!isRecord(value)) return void 0;
+  return value[key];
+};
+var getNestedMessage = (value) => {
+  if (typeof value === "string") return value;
+  if (!isRecord(value)) return void 0;
+  let message = getResponseField(value, "message");
+  if (typeof message === "string" && message.trim()) return message;
+  let description = getResponseField(value, "description");
+  if (typeof description === "string" && description.trim()) return description;
+  let error = getResponseField(value, "error");
+  if (typeof error === "string" && error.trim()) return error;
+  if (isRecord(error)) {
+    let nested = getNestedMessage(error);
+    if (nested) return nested;
+  }
+  let errorDescription = getResponseField(value, "error_description");
+  if (typeof errorDescription === "string" && errorDescription.trim()) {
+    return errorDescription;
+  }
+  return void 0;
+};
+var getNestedCode = (value) => {
+  if (!isRecord(value)) return void 0;
+  let directCode = getResponseField(value, "code");
+  if (typeof directCode === "string" && directCode.trim()) return directCode;
+  let errorCode = getResponseField(value, "error_code");
+  if (typeof errorCode === "string" && errorCode.trim()) return errorCode;
+  let type = getResponseField(value, "type");
+  if (typeof type === "string" && type.trim()) return type;
+  let error = getResponseField(value, "error");
+  if (typeof error === "string" && error.trim()) return error;
+  if (isRecord(error)) return getNestedCode(error);
+  return void 0;
+};
+var getNestedType = (value) => {
+  if (!isRecord(value)) return void 0;
+  let type = getResponseField(value, "type");
+  if (typeof type === "string" && type.trim()) return type;
+  let error = getResponseField(value, "error");
+  if (isRecord(error)) {
+    let nestedType = getNestedType(error);
+    if (nestedType) return nestedType;
+  }
+  return void 0;
+};
+var getHeaderValue = (headers, key) => {
+  if (!headers) return void 0;
+  if (typeof headers.get === "function") {
+    let value = headers.get(key);
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  if (isRecord(headers)) {
+    for (let [headerKey, headerValue] of Object.entries(headers)) {
+      if (headerKey.toLowerCase() !== key.toLowerCase()) continue;
+      if (typeof headerValue === "string" && headerValue.trim()) return headerValue;
+      if (Array.isArray(headerValue)) {
+        let first = headerValue.find((item) => typeof item === "string" && item.trim());
+        if (typeof first === "string") return first;
+      }
+    }
+  }
+  return void 0;
+};
+var buildRequestUrl = (error) => {
+  let baseURL = error.config?.baseURL;
+  let url = error.config?.url;
+  if (!url) return void 0;
+  if (!baseURL) return url;
+  try {
+    return new URL(url, baseURL).toString();
+  } catch {
+    return url;
+  }
+};
+var getProviderDefaults = () => {
+  try {
+    let ctx = getCurrentContext();
+    return {
+      provider: {
+        key: ctx.specification.key
+      },
+      ...ctx.getHttpTraces().length > 0 ? { requestTraces: ctx.getHttpTraces() } : {}
+    };
+  } catch {
+    return {};
+  }
+};
+var inferAxiosCode = (error, data) => {
+  let status = error.response?.status;
+  let axiosCode = error.code?.toUpperCase();
+  let remoteCode = getNestedCode(data)?.toLowerCase();
+  if (axiosCode === "ECONNABORTED" || axiosCode === "ETIMEDOUT" || status === 408 || remoteCode?.includes("timeout")) {
+    return "upstream.timeout";
+  }
+  if (!error.response) {
+    return "upstream.network_error";
+  }
+  if (status === 401) return "auth.invalid";
+  if (status === 403) {
+    return remoteCode?.includes("rate") ? "upstream.rate_limited" : "permission.denied";
+  }
+  if (status === 404) return "resource.not_found";
+  if (status === 409) return "resource.conflict";
+  if (status === 422 || status === 400) return "upstream.invalid_request";
+  if (status === 429) return "upstream.rate_limited";
+  if (status === 502 || status === 503 || status === 504) return "upstream.unavailable";
+  if (status && status >= 500) return "upstream.error";
+  return "upstream.error";
+};
+var inferAxiosMessage = (error, data, code) => {
+  return getNestedMessage(data) ?? error.response?.statusText ?? error.message ?? getDefaultMessage(code);
+};
+var inferAxiosRetryable = (error, code) => {
+  let headerValue = getHeaderValue(error.response?.headers, "retry-after");
+  if (headerValue) return true;
+  return normalizeRetryable(code, void 0);
+};
+var isAxiosErrorLike = (error) => isAxiosError(error);
+var inferSlateErrorFromAxios = (error, options = {}) => {
+  let responseData = error.response ? options.extractResponseData?.(error.response) ?? error.response.data : void 0;
+  let code = inferAxiosCode(error, responseData);
+  return normalizeSlateErrorInput({
+    ...getProviderDefaults(),
+    ...options.defaults,
+    code: options.defaults?.code ?? code,
+    message: options.defaults?.message ?? inferAxiosMessage(error, responseData, code),
+    kind: options.defaults?.kind ?? normalizeKind(options.defaults?.code ?? code),
+    retryable: options.defaults?.retryable ?? inferAxiosRetryable(error, options.defaults?.code ?? code),
+    status: options.defaults?.status ?? error.response?.status,
+    provider: {
+      ...getProviderDefaults().provider,
+      ...options.defaults?.provider ?? {}
+    },
+    upstream: {
+      ...options.defaults?.upstream ?? {},
+      status: error.response?.status ?? options.defaults?.upstream?.status,
+      code: getNestedCode(responseData) ?? options.defaults?.upstream?.code,
+      type: getNestedType(responseData) ?? options.defaults?.upstream?.type,
+      requestId: getHeaderValue(error.response?.headers, "x-request-id") ?? getHeaderValue(error.response?.headers, "request-id") ?? getHeaderValue(error.response?.headers, "x-correlation-id") ?? options.defaults?.upstream?.requestId,
+      method: error.config?.method?.toUpperCase() ?? options.defaults?.upstream?.method,
+      url: buildRequestUrl(error) ?? options.defaults?.upstream?.url
+    },
+    baggage: mergeRecords(options.defaults?.baggage, {
+      axiosCode: error.code,
+      response: sanitizeForBaggage(responseData)
+    })
+  });
+};
+
+// src/error/service.ts
+import { isServiceError } from "@lowerdeck/error";
+var SERVICE_ERROR_DATA_RESERVED_KEYS = /* @__PURE__ */ new Set([
+  "status",
+  "code",
+  "message",
+  "hint",
+  "description",
+  "reason",
+  "errors",
+  "object",
+  "ok"
+]);
+var isStructuredValue = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+var mapServiceErrorCodeByStatus = (status) => {
+  if (status === 400) return "request.bad";
+  if (status === 401) return "auth.required";
+  if (status === 402) return "payment.required";
+  if (status === 403) return "permission.denied";
+  if (status === 404) return "resource.not_found";
+  if (status === 406) return "request.not_acceptable";
+  if (status === 409) return "resource.conflict";
+  if (status === 410) return "resource.gone";
+  if (status === 412) return "request.precondition_failed";
+  if (status === 429) return "request.rate_limited";
+  if (status === 501) return "operation.not_implemented";
+  if (status === 504) return "internal.timeout";
+  if (status && status >= 500) return "internal.unexpected";
+  return DEFAULT_CODE;
+};
+var normalizeServiceErrorIssues = (errors) => {
+  if (!Array.isArray(errors)) return void 0;
+  let issues = errors.map((error) => {
+    if (!isRecord(error)) {
+      return {
+        message: String(error)
+      };
+    }
+    let path = Array.isArray(error.path) ? error.path.map((entry) => String(entry)) : void 0;
+    return {
+      ...error,
+      path,
+      code: typeof error.code === "string" ? error.code : void 0,
+      message: typeof error.message === "string" ? error.message : typeof error.hint === "string" ? error.hint : "Validation issue"
+    };
+  });
+  return issues.length > 0 ? issues : void 0;
+};
+var getServiceErrorBaggage = (data) => {
+  let extraEntries = Object.entries(data).filter(([key]) => !SERVICE_ERROR_DATA_RESERVED_KEYS.has(key));
+  return cleanRecord({
+    serviceError: {
+      code: data.code,
+      status: data.status,
+      hint: data.hint,
+      description: data.description,
+      reason: data.reason
+    },
+    ...extraEntries.length > 0 ? {
+      serviceErrorData: sanitizeForBaggage(Object.fromEntries(extraEntries))
+    } : {}
+  });
+};
+var mapServiceErrorCode = (code, status) => SERVICE_ERROR_CODE_MAP[code] ?? mapServiceErrorCodeByStatus(status);
+var isServiceErrorData = (value) => isRecord(value) && typeof value.status === "number" && typeof value.code === "string" && typeof value.message === "string" && !("config" in value) && !("request" in value) && !("response" in value) && !("isAxiosError" in value);
+var getServiceErrorData = (error) => {
+  if (isServiceError(error)) {
+    return isServiceErrorData(error.data) ? error.data : null;
+  }
+  if (isServiceErrorData(error)) {
+    return error;
+  }
+  if (isStructuredValue(error) && "data" in error && isServiceErrorData(error.data)) {
+    return error.data;
+  }
+  if (isStructuredValue(error) && "toResponse" in error && typeof error.toResponse === "function") {
+    let response = error.toResponse();
+    return isServiceErrorData(response) ? response : null;
+  }
+  return null;
+};
+var mapServiceErrorToSlateErrorInput = (error, defaults = {}) => {
+  let data = getServiceErrorData(error);
+  if (!data) {
+    return {
+      code: defaults.code ?? DEFAULT_CODE,
+      message: defaults.message ?? "An unexpected internal error occurred.",
+      kind: defaults.kind,
+      retryable: defaults.retryable,
+      status: defaults.status,
+      provider: defaults.provider,
+      upstream: defaults.upstream,
+      baggage: defaults.baggage
+    };
+  }
+  let code = defaults.code ?? mapServiceErrorCode(data.code, data.status);
+  return {
+    code,
+    message: defaults.message ?? data.message,
+    kind: defaults.kind ?? normalizeKind(code),
+    retryable: defaults.retryable ?? normalizeRetryable(code),
+    status: defaults.status ?? data.status,
+    issues: defaults.issues ?? normalizeServiceErrorIssues(data.errors),
+    provider: defaults.provider,
+    upstream: defaults.upstream,
+    baggage: cleanRecord({
+      ...defaults.baggage ?? {},
+      ...getServiceErrorBaggage(data)
+    })
+  };
+};
+
+// src/error/base.ts
+var SlateError = class _SlateError extends Error {
+  cause;
+  data;
+  constructor(input) {
+    let normalized = normalizeSlateErrorInput(input);
+    super(normalized.message);
+    this.name = "SlateError";
+    this.data = normalized;
+    this.cause = input.cause;
+  }
+  get code() {
+    return this.data.code;
+  }
+  get kind() {
+    return this.data.kind;
+  }
+  get status() {
+    return this.data.status;
+  }
+  get retryable() {
+    return this.data.retryable;
+  }
+  toResponse() {
+    return {
+      ...this.data
+    };
+  }
+  toJSON() {
+    return this.toResponse();
+  }
+  static is(error) {
+    return error instanceof _SlateError;
+  }
+  static fromUnknown(error, defaults = {}) {
+    if (_SlateError.is(error)) return error;
+    if (isSlateErrorResponse(error)) return new _SlateError({ ...defaults, ...error });
+    if (getServiceErrorData(error)) return _SlateError.fromServiceError(error, defaults);
+    if (isAxiosErrorLike(error)) return _SlateError.fromAxios(error, { defaults });
+    if (error instanceof Error) {
+      return new _SlateError({
+        code: defaults.code ?? DEFAULT_CODE,
+        message: error.message,
+        kind: defaults.kind,
+        retryable: defaults.retryable,
+        status: defaults.status,
+        issues: defaults.issues,
+        provider: defaults.provider,
+        upstream: defaults.upstream,
+        baggage: mergeRecords(defaults.baggage, {
+          originalName: error.name
+        }),
+        cause: error
+      });
+    }
+    return new _SlateError({
+      code: defaults.code ?? DEFAULT_CODE,
+      message: getDefaultMessage(defaults.code ?? DEFAULT_CODE, defaults.message),
+      kind: defaults.kind,
+      retryable: defaults.retryable,
+      status: defaults.status,
+      issues: defaults.issues,
+      provider: defaults.provider,
+      upstream: defaults.upstream,
+      baggage: mergeRecords(defaults.baggage, {
+        originalValue: sanitizeForBaggage(error)
+      })
+    });
+  }
+  static fromServiceError(error, defaults = {}) {
+    return new _SlateError(mapServiceErrorToSlateErrorInput(error, defaults));
+  }
+  static fromAxios(error, options = {}) {
+    if (_SlateError.is(error)) return error;
+    if (getServiceErrorData(error))
+      return _SlateError.fromServiceError(error, options.defaults);
+    if (!isAxiosErrorLike(error)) return _SlateError.fromUnknown(error, options.defaults);
+    let inferred = inferSlateErrorFromAxios(error, options);
+    let mapped = options.mapAxiosError?.(error, inferred);
+    if (_SlateError.is(mapped)) return mapped;
+    return new _SlateError(mergeSlateErrorData(inferred, mapped ?? void 0));
+  }
+};
+var createSlateError = (input) => new SlateError(input);
+
+// src/error/declaration.ts
+var SlateDeclarationError = class _SlateDeclarationError extends SlateError {
+  constructor(message, input = {}) {
+    super({
+      code: "declaration.invalid_definition",
+      kind: "declaration",
+      message,
+      ...input
+    });
+    this.name = "SlateError.DeclarationError";
+  }
+  static is(error) {
+    return error instanceof _SlateDeclarationError;
+  }
+};
+
+// src/action/scopes.ts
+var scopeClause = (...scopes) => {
+  assertScopeValues(scopes);
+  return {
+    OR: [...scopes]
+  };
+};
+var anyOf = (...scopes) => ({
+  AND: [scopeClause(...scopes)]
+});
+var allOf = (...inputs) => {
+  let AND = inputs.flatMap((input) => normalizeScopes(input).AND);
+  return validateScopes({ AND });
+};
+var mergeScopes = (...inputs) => {
+  let AND = inputs.flatMap((input) => input ? input.AND : []);
+  if (AND.length === 0) {
+    return void 0;
+  }
+  return validateScopes({ AND });
+};
+var validateScopes = (scopes) => {
+  if (!Array.isArray(scopes.AND) || scopes.AND.length === 0) {
+    throw new SlateDeclarationError("Action scopes must include at least one AND clause");
+  }
+  return {
+    AND: scopes.AND.map((clause) => normalizeClause(clause))
+  };
+};
+var normalizeScopes = (input) => {
+  if (isScopes(input)) {
+    return validateScopes(input);
+  }
+  return {
+    AND: [normalizeClause(input)]
+  };
+};
+var normalizeClause = (input) => {
+  if (typeof input === "string") {
+    return scopeClause(input);
+  }
+  if (Array.isArray(input)) {
+    return scopeClause(...input);
+  }
+  if (!isClause(input)) {
+    throw new SlateDeclarationError("Action scope clauses must be strings or OR clauses");
+  }
+  assertScopeValues(input.OR);
+  return {
+    OR: [...input.OR]
+  };
+};
+var assertScopeValues = (scopes) => {
+  if (scopes.length === 0) {
+    throw new SlateDeclarationError("Each action scope clause must include at least one OR scope");
+  }
+  for (let scope of scopes) {
+    if (typeof scope !== "string" || scope.trim().length === 0) {
+      throw new SlateDeclarationError("Action scopes must be non-empty strings");
+    }
+  }
+};
+var isClause = (value) => typeof value === "object" && value !== null && "OR" in value && Array.isArray(value.OR);
+var isScopes = (value) => typeof value === "object" && value !== null && "AND" in value && Array.isArray(value.AND);
+
+// src/action/builder.ts
+var SlateActionBuilder = class {
+  constructor(type, spec2, params, factory) {
+    this.type = type;
+    this.spec = spec2;
+    this.params = params;
+    this.factory = factory;
+    this.#configSchema = spec2.configSchema;
+    this.#authSchema = spec2.authSchema;
+  }
+  type;
+  spec;
+  params;
+  factory;
+  #configSchema;
+  #authSchema;
+  #inputSchema = null;
+  #outputSchema = null;
+  #scopes;
+  #toolParams = null;
+  #triggerParams = null;
+  input(schema) {
+    this.#inputSchema = schema;
+    return this;
+  }
+  output(schema) {
+    this.#outputSchema = schema;
+    return this;
+  }
+  scopes(scopes) {
+    validateScopes(scopes);
+    this.#scopes = scopes;
+    return this;
+  }
+  handleInvocation(handler) {
+    if (this.type !== "tool") {
+      throw new SlateDeclarationError("handleInvocation can only be set for tool actions");
+    }
+    this.#toolParams = {
+      type: "tool",
+      handleInvocation: handler
+    };
+    return this;
+  }
+  webhook(props) {
+    if (this.type !== "trigger") {
+      throw new SlateDeclarationError("handleEvent can only be set for trigger actions");
+    }
+    this.#triggerParams = {
+      type: "trigger",
+      source: "webhook",
+      handleEvent: props.handleEvent,
+      handleRequest: props.handleRequest,
+      autoRegisterWebhook: props.autoRegisterWebhook,
+      autoUnregisterWebhook: props.autoUnregisterWebhook
+    };
+    return this;
+  }
+  polling(props) {
+    if (this.type !== "trigger") {
+      throw new SlateDeclarationError("handleEvent can only be set for trigger actions");
+    }
+    this.#triggerParams = {
+      type: "trigger",
+      source: "polling",
+      polling: props.options,
+      pollEvents: props.pollEvents,
+      handleEvent: props.handleEvent
+    };
+    return this;
+  }
+  build() {
+    let scopes = this.#scopes ?? this.params.scopes;
+    if (scopes) {
+      validateScopes(scopes);
+    }
+    if (!this.#inputSchema) {
+      throw new SlateDeclarationError("Input schema is not defined");
+    }
+    if (!this.#outputSchema) {
+      throw new SlateDeclarationError("Output schema is not defined");
+    }
+    if (this.type === "tool" && !this.#toolParams) {
+      throw new SlateDeclarationError("Tool invocation handler is not defined");
+    }
+    if (this.type === "trigger" && !this.#triggerParams) {
+      throw new SlateDeclarationError("Trigger event handlers are not defined");
+    }
+    return this.factory({
+      ...this.params,
+      scopes,
+      configSchema: this.#configSchema,
+      authSchema: this.#authSchema,
+      inputSchema: this.#inputSchema,
+      outputSchema: this.#outputSchema,
+      ...this.#toolParams,
+      ...this.#triggerParams
+    });
+  }
+};
+
+// src/action/tool.ts
+var SlateTool = class _SlateTool extends SlateAction {
+  #handleInvocation;
+  constructor(spec2, inputSchema, outputSchema, params) {
+    super("tool", spec2, inputSchema, outputSchema, params);
+    this.#handleInvocation = params.handleInvocation;
+  }
+  static create(spec2, params) {
+    return new SlateActionBuilder("tool", spec2, params, (params2) => {
+      if (params2.type !== "tool") throw new Error("Invalid action type for tool");
+      return new _SlateTool(spec2, params2.inputSchema, params2.outputSchema, params2);
+    });
+  }
+  get handleInvocation() {
+    return this.#handleInvocation;
+  }
+};
+var tool = (spec2, params) => SlateTool.create(spec2, params);
+
+// src/action/trigger.ts
+var SlateDefaultPollingIntervalSeconds = 60 * 10;
+var SlateTrigger = class _SlateTrigger extends SlateAction {
+  #source;
+  #polling;
+  #handleEvent;
+  #handleRequest;
+  #pollEvents;
+  #autoRegisterWebhook;
+  #autoUnregisterWebhook;
+  constructor(spec2, inputSchema, outputSchema, params) {
+    super("trigger", spec2, inputSchema, outputSchema, params);
+    this.#source = params.source;
+    this.#polling = params.polling || {
+      intervalInSeconds: SlateDefaultPollingIntervalSeconds
+    };
+    this.#handleEvent = params.handleEvent;
+    this.#handleRequest = params.handleRequest;
+    this.#pollEvents = params.pollEvents;
+    this.#autoRegisterWebhook = params.autoRegisterWebhook;
+    this.#autoUnregisterWebhook = params.autoUnregisterWebhook;
+  }
+  static create(spec2, params) {
+    return new SlateActionBuilder("trigger", spec2, params, (params2) => {
+      if (params2.type !== "trigger") throw new Error("Invalid action type for trigger");
+      return new _SlateTrigger(spec2, params2.inputSchema, params2.outputSchema, params2);
+    });
+  }
+  get polling() {
+    return this.#polling;
+  }
+  get source() {
+    return this.#source;
+  }
+  get handleEvent() {
+    return this.#handleEvent;
+  }
+  get handleRequest() {
+    return this.#handleRequest;
+  }
+  get pollEvents() {
+    return this.#pollEvents;
+  }
+  get autoRegisterWebhook() {
+    return this.#autoRegisterWebhook;
+  }
+  get autoUnregisterWebhook() {
+    return this.#autoUnregisterWebhook;
+  }
+};
+var trigger = (spec2, params) => SlateTrigger.create(spec2, params);
+
+// src/action/attachment.ts
+var createUrlAttachment = (url, mimeType) => ({
+  mimeType,
+  content: {
+    type: "url",
+    url
+  }
+});
+var createBase64Attachment = (content, mimeType) => ({
+  mimeType,
+  content: {
+    type: "content",
+    encoding: "base64",
+    content
+  }
+});
+var createTextAttachment = (content, mimeType) => ({
+  mimeType,
+  content: {
+    type: "content",
+    encoding: "utf-8",
+    content
+  }
+});
+
+// src/auth/auth.ts
+var SlateAuth = class _SlateAuth {
+  #outputSchema = null;
+  #authStack = [];
+  constructor() {
+  }
+  static create() {
+    return new _SlateAuth();
+  }
+  output(schema) {
+    this.#outputSchema = schema;
+    return this;
+  }
+  addAuth(auth2) {
+    let existingKeys = this.#authStack.map((a) => a.key);
+    if (existingKeys.includes(auth2.key)) {
+      throw new Error(`Auth with key "${auth2.key}" already exists in the auth stack`);
+    }
+    this.#authStack.push(auth2);
+    return this;
+  }
+  addOauth(auth2) {
+    this.addAuth(auth2);
+    return this;
+  }
+  addTokenAuth(auth2) {
+    this.addAuth(auth2);
+    return this;
+  }
+  addServiceAccountAuth(auth2) {
+    this.addAuth(auth2);
+    return this;
+  }
+  addCustomAuth(auth2) {
+    this.addAuth(auth2);
+    return this;
+  }
+  addNone() {
+    this.addAuth({
+      type: "auth.none",
+      name: "No Authentication",
+      key: "none"
+    });
+    return this;
+  }
+  get authStack() {
+    return this.#authStack.filter((a) => a.type !== "auth.none");
+  }
+  get outputSchema() {
+    if (!this.#outputSchema) {
+      throw new Error("Output schema is not defined for this auth");
+    }
+    return this.#outputSchema;
+  }
+};
+var auth = () => SlateAuth.create();
+
+// src/axios/index.ts
+import baseAxios, { getAdapter, isAxiosError as isAxiosError2 } from "axios";
+
+// src/axios/trace.ts
+var traceDraftsByConfig = /* @__PURE__ */ new WeakMap();
+var traceDraftsByHeaders = /* @__PURE__ */ new WeakMap();
+var TRACE_TEXT_LIMIT = 10 * 1024;
+var REDACTED_VALUE = "[redacted]";
+var STRUCTURED_DEPTH_LIMIT = 6;
+var STRUCTURED_ENTRY_LIMIT = 50;
+var CORE_SECRET_KEY_ATOMS = [
+  // HTTP authentication
+  "authorization",
+  "proxy[-_.]?authorization",
+  "www[-_.]?authenticate",
+  "bearer",
+  // Generic tokens
+  "token",
+  "tokens",
+  "access[-_.]?token",
+  "refresh[-_.]?token",
+  "id[-_.]?token",
+  "auth[-_.]?token",
+  "bearer[-_.]?token",
+  "session[-_.]?token",
+  "api[-_.]?token",
+  "app[-_.]?token",
+  "user[-_.]?token",
+  "oauth[-_.]?token",
+  "personal[-_.]?access[-_.]?token",
+  "x[-_.]?auth[-_.]?token",
+  "x[-_.]?access[-_.]?token",
+  "x[-_.]?refresh[-_.]?token",
+  // API keys
+  "apikey",
+  "api[-_.]?key",
+  "app[-_.]?key",
+  "x[-_.]?api[-_.]?key",
+  "x[-_.]?app[-_.]?key",
+  // OAuth client credentials
+  "client[-_.]?secret",
+  "client[-_.]?key",
+  "consumer[-_.]?secret",
+  "consumer[-_.]?key",
+  // Cryptographic keys
+  "private[-_.]?key",
+  "privatekey",
+  "secret[-_.]?key",
+  "secretkey",
+  "secret[-_.]?access[-_.]?key",
+  "encryption[-_.]?key",
+  "decryption[-_.]?key",
+  "signing[-_.]?key",
+  "signing[-_.]?secret",
+  "master[-_.]?key",
+  "master[-_.]?secret",
+  "master[-_.]?password",
+  "shared[-_.]?secret",
+  "webhook[-_.]?secret",
+  "webhook[-_.]?signing[-_.]?secret",
+  // OAuth codes & PKCE
+  "auth[-_.]?code",
+  "authcode",
+  "authorization[-_.]?code",
+  "code[-_.]?verifier",
+  "code[-_.]?challenge",
+  // Passwords & passcodes
+  "password",
+  "passwd",
+  "pwd",
+  "passphrase",
+  "pass[-_.]?phrase",
+  "pin",
+  "passcode",
+  // Generic secret markers
+  "secret",
+  "secrets",
+  "credential",
+  "credentials",
+  "creds",
+  "auth",
+  "x[-_.]?auth",
+  "x[-_.]?auth[-_.]?key",
+  // CSRF / XSRF
+  "csrf",
+  "xsrf",
+  "csrf[-_.]?token",
+  "xsrf[-_.]?token",
+  "x[-_.]?csrf[-_.]?token",
+  "x[-_.]?xsrf[-_.]?token",
+  // JWT
+  "jwt",
+  // Sessions & cookies
+  "session[-_.]?id",
+  "sessionid",
+  "sid",
+  "cookie",
+  "cookies",
+  "set[-_.]?cookie",
+  // Signatures / MAC
+  "signature",
+  "x[-_.]?hub[-_.]?signature",
+  "x[-_.]?signature",
+  "sig",
+  "hmac",
+  "mac",
+  // Crypto artifacts
+  "salt",
+  "nonce",
+  // Multi-factor / verification
+  "otp",
+  "totp",
+  "mfa",
+  "mfa[-_.]?code",
+  "2fa",
+  "two[-_.]?factor",
+  "twofactor",
+  "verification[-_.]?code",
+  "verify[-_.]?code",
+  "confirm(?:ation)?[-_.]?code",
+  "sms[-_.]?code",
+  "email[-_.]?code",
+  // Recovery & seed phrases
+  "seed[-_.]?phrase",
+  "mnemonic",
+  "recovery[-_.]?key",
+  "recovery[-_.]?code",
+  "recovery[-_.]?phrase",
+  // PII / financial
+  "card[-_.]?number",
+  "card[-_.]?code",
+  "cvv",
+  "cvc",
+  "ccv",
+  "cc[-_.]?num(?:ber)?",
+  "pan",
+  "ssn",
+  "social[-_.]?security",
+  "license[-_.]?key"
+];
+var URL_FORM_SECRET_KEY_ATOMS = [...CORE_SECRET_KEY_ATOMS, "code"];
+var buildKeyBoundaryPattern = (atoms, flags) => new RegExp(
+  `(?:^|[^A-Za-z0-9])(?:${atoms.join("|")})(?=[^A-Za-z0-9]|$)`,
+  flags
+);
+var SECRET_KEY_PATTERN = buildKeyBoundaryPattern(CORE_SECRET_KEY_ATOMS, "i");
+var URL_FORM_SECRET_KEY_PATTERN = buildKeyBoundaryPattern(
+  URL_FORM_SECRET_KEY_ATOMS,
+  "i"
+);
+var NON_SECRET_KEY_EXACT = /* @__PURE__ */ new Set([
+  "token_type",
+  "token-type",
+  "tokentype",
+  "token_kind",
+  "token-kind",
+  "tokenkind",
+  "token_ttl",
+  "token-ttl",
+  "token_expires_in",
+  "token-expires-in",
+  "token_expiry",
+  "signature_method",
+  "signature-method",
+  "signature_type",
+  "signature-type",
+  "signature_version",
+  "signature-version",
+  "auth_type",
+  "auth-type",
+  "auth_method",
+  "auth-method",
+  "authentication_type",
+  "authentication-type",
+  "authentication_method",
+  "authentication-method",
+  "grant_type",
+  "grant-type",
+  "password_strength",
+  "password-strength",
+  "password_policy",
+  "password-policy",
+  "key_type",
+  "key-type",
+  "key_name",
+  "key-name",
+  "key_id",
+  "key-id",
+  "kid"
+]);
+var isSecretKeyName = (name) => {
+  let normalized = name.toLowerCase();
+  if (NON_SECRET_KEY_EXACT.has(normalized)) return false;
+  return SECRET_KEY_PATTERN.test(normalized);
+};
+var isUrlFormSecretKeyName = (name) => {
+  let normalized = name.toLowerCase();
+  if (NON_SECRET_KEY_EXACT.has(normalized)) return false;
+  return URL_FORM_SECRET_KEY_PATTERN.test(normalized);
+};
+var KNOWN_SECRET_VALUE_PATTERNS = [
+  // JSON Web Tokens (header.payload.signature)
+  /\beyJ[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{4,}\b/g,
+  // AWS access key IDs
+  /\b(?:AKIA|ASIA|AGPA|AIDA|ANPA|ANVA|AROA|APKA|ASCA)[A-Z0-9]{16}\b/g,
+  // GitHub tokens (PAT / OAuth / server-to-server / user-to-server / refresh)
+  /\bgh[pousr]_[A-Za-z0-9]{30,}\b/g,
+  // Slack tokens
+  /\bxox[abprs]-[A-Za-z0-9-]{10,}\b/g,
+  // Stripe secret / public / restricted keys
+  /\b(?:sk|rk|pk)_(?:test|live)_[A-Za-z0-9]{16,}\b/g,
+  // OpenAI API keys
+  /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/g,
+  // Anthropic API keys
+  /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g,
+  // Google API keys
+  /\bAIza[A-Za-z0-9_-]{35}\b/g,
+  // SendGrid API keys
+  /\bSG\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\b/g,
+  // Twilio API keys
+  /\bSK[0-9a-fA-F]{32}\b/g,
+  // PEM-encoded private keys (multi-line)
+  /-----BEGIN[A-Z ]*PRIVATE KEY-----[\s\S]*?-----END[A-Z ]*PRIVATE KEY-----/g,
+  // SSH private keys (OpenSSH format)
+  /-----BEGIN OPENSSH PRIVATE KEY-----[\s\S]*?-----END OPENSSH PRIVATE KEY-----/g
+];
+var HTTP_AUTH_SCHEME_PATTERN = /\b(bearer|basic|digest|token|negotiate|apikey)\s+([A-Za-z0-9_\-.~+/=]{4,})/gi;
+var GENERIC_KEY_VALUE_PATTERN = /(?<![A-Za-z0-9])([A-Za-z0-9][A-Za-z0-9_\-.]*)(\s*=\s*)([^&#\s;]+)/g;
+var GENERIC_JSON_KEY_VALUE_PATTERN = /"([^"\\]*(?:\\.[^"\\]*)*)"(\s*:\s*)"([^"\\]*(?:\\.[^"\\]*)*)"/g;
+var SAFE_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "accept",
+  "accept-encoding",
+  "accept-language",
+  "cache-control",
+  "connection",
+  "content-encoding",
+  "content-language",
+  "content-length",
+  "content-type",
+  "date",
+  "etag",
+  "expires",
+  "if-modified-since",
+  "if-none-match",
+  "keep-alive",
+  "last-modified",
+  "location",
+  "origin",
+  "pragma",
+  "referer",
+  "referrer-policy",
+  "request-id",
+  "retry-after",
+  "server",
+  "transfer-encoding",
+  "user-agent",
+  "vary",
+  "via",
+  "x-correlation-id",
+  "x-powered-by",
+  "x-request-id",
+  "x-slates-provider",
+  "x-trace-id"
+]);
+var SAFE_HEADER_PREFIXES = ["ratelimit-", "x-ratelimit-"];
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isObjectLike = (value) => typeof value === "object" && value !== null;
+var normalizeContentType = (value) => value?.split(";")[0]?.trim().toLowerCase() || void 0;
+var isTextContentType = (contentType) => !contentType || /(^text\/)|json|xml|html|javascript|graphql|x-www-form-urlencoded|svg/.test(contentType);
+var isSafeHeaderName = (name) => {
+  let normalized = name.toLowerCase();
+  if (isSecretKeyName(normalized)) return false;
+  if (SAFE_HEADER_NAMES.has(normalized)) return true;
+  return SAFE_HEADER_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+};
+var truncateText = (text) => {
+  if (text.length <= TRACE_TEXT_LIMIT) {
+    return { text, truncated: false };
+  }
+  return {
+    text: `${text.slice(0, TRACE_TEXT_LIMIT)}...[truncated]`,
+    truncated: true
+  };
+};
+var sanitizeFreeText = (text) => {
+  if (!text) return text;
+  let result = text;
+  result = result.replace(
+    HTTP_AUTH_SCHEME_PATTERN,
+    (_match, scheme) => `${scheme} ${REDACTED_VALUE}`
+  );
+  for (let pattern of KNOWN_SECRET_VALUE_PATTERNS) {
+    result = result.replace(pattern, REDACTED_VALUE);
+  }
+  result = result.replace(
+    GENERIC_KEY_VALUE_PATTERN,
+    (match, key, equals, _value) => isUrlFormSecretKeyName(key) ? `${key}${equals}${REDACTED_VALUE}` : match
+  );
+  result = result.replace(
+    GENERIC_JSON_KEY_VALUE_PATTERN,
+    (match, key, colon, _value) => isSecretKeyName(key) ? `"${key}"${colon}"${REDACTED_VALUE}"` : match
+  );
+  return result;
+};
+var sanitizeScalar = (value) => truncateText(sanitizeFreeText(value));
+var redactStructuredValue = (value, depth = 0) => {
+  if (value == null) return value;
+  if (depth >= STRUCTURED_DEPTH_LIMIT) return "[truncated]";
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return typeof value === "string" ? sanitizeFreeText(value) : value;
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, STRUCTURED_ENTRY_LIMIT).map((entry) => redactStructuredValue(entry, depth + 1));
+  }
+  if (isRecord2(value)) {
+    return Object.fromEntries(
+      Object.entries(value).slice(0, STRUCTURED_ENTRY_LIMIT).map(([key, entry]) => [
+        key,
+        isSecretKeyName(key) ? REDACTED_VALUE : redactStructuredValue(entry, depth + 1)
+      ])
+    );
+  }
+  return String(value);
+};
+var maybeParseJson = (text, contentType) => {
+  let trimmed = text.trim();
+  if (!trimmed) return null;
+  if (!contentType?.includes("json") && !/^[\[{]/.test(trimmed)) {
+    return null;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+};
+var sanitizeTextBody = (text, contentType) => {
+  if (!text) return void 0;
+  let normalizedContentType = normalizeContentType(contentType);
+  let parsedJson = maybeParseJson(text, normalizedContentType);
+  let normalizedText = parsedJson !== null ? JSON.stringify(redactStructuredValue(parsedJson)) : sanitizeFreeText(text);
+  let { text: truncatedText, truncated } = truncateText(normalizedText);
+  return {
+    ...normalizedContentType ? { contentType: normalizedContentType } : {},
+    text: truncatedText,
+    ...truncated ? { truncated: true } : {}
+  };
+};
+var isBinaryLike = (value) => {
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) return true;
+  if (value instanceof ArrayBuffer) return true;
+  if (ArrayBuffer.isView(value)) return true;
+  if (typeof Blob !== "undefined" && value instanceof Blob) return true;
+  if (typeof FormData !== "undefined" && value instanceof FormData) return true;
+  return false;
+};
+var serializeTextBody = (value, contentType) => {
+  let normalizedContentType = normalizeContentType(contentType);
+  if (value == null || isBinaryLike(value) || !isTextContentType(normalizedContentType)) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return sanitizeTextBody(value, normalizedContentType);
+  }
+  if (value instanceof URLSearchParams) {
+    return sanitizeTextBody(value.toString(), normalizedContentType);
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return sanitizeTextBody(String(value), normalizedContentType);
+  }
+  if (Array.isArray(value) || isRecord2(value)) {
+    return sanitizeTextBody(JSON.stringify(redactStructuredValue(value)), "application/json");
+  }
+  return void 0;
+};
+var buildUrl = (baseURL, url) => {
+  if (!url) return "";
+  if (!baseURL) return url;
+  try {
+    return new URL(url, baseURL).toString();
+  } catch {
+    return url;
+  }
+};
+var REDACTED_ENCODED = encodeURIComponent(REDACTED_VALUE);
+var decodeRedactedMarker = (value) => REDACTED_ENCODED === REDACTED_VALUE ? value : value.split(REDACTED_ENCODED).join(REDACTED_VALUE);
+var redactHashFragment = (hash) => {
+  if (!hash || !hash.includes("=")) return hash;
+  let withoutHash = hash.startsWith("#") ? hash.slice(1) : hash;
+  let redacted = withoutHash.replace(
+    /(?<![A-Za-z0-9])([A-Za-z0-9][A-Za-z0-9_\-.]*)=([^&]*)/g,
+    (match, key, _rawValue) => isUrlFormSecretKeyName(key) ? `${key}=${REDACTED_VALUE}` : match
+  );
+  return redacted ? `#${redacted}` : "";
+};
+var sanitizeUrl = (value) => {
+  if (!value) return value;
+  try {
+    let url = new URL(value);
+    if (url.username || url.password) {
+      url.username = "";
+      url.password = "";
+    }
+    for (let key of Array.from(url.searchParams.keys())) {
+      if (isUrlFormSecretKeyName(key)) {
+        url.searchParams.set(key, REDACTED_VALUE);
+      }
+    }
+    url.hash = redactHashFragment(url.hash);
+    return decodeRedactedMarker(url.toString());
+  } catch {
+    return value.replace(
+      /([?&]([^=&#]+)=)([^&#]+)/g,
+      (_match, prefix, key, rawValue) => isUrlFormSecretKeyName(key) ? `${prefix}${REDACTED_VALUE}` : `${prefix}${rawValue}`
+    );
+  }
+};
+var flattenHeaderValue = (value) => {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (Array.isArray(value)) {
+    let normalized = value.map((entry) => flattenHeaderValue(entry)).filter((entry) => typeof entry === "string" && entry.length > 0);
+    return normalized.length > 0 ? normalized.join(", ") : void 0;
+  }
+  return void 0;
+};
+var headerEntries = (headers) => {
+  if (!headers) return [];
+  if (typeof headers.toJSON === "function") {
+    let json = headers.toJSON();
+    if (isRecord2(json)) {
+      return Object.entries(json).map(([key, value]) => {
+        let flattened = flattenHeaderValue(value);
+        return flattened ? [key, flattened] : null;
+      }).filter((entry) => entry !== null);
+    }
+  }
+  if (typeof headers.entries === "function") {
+    return Array.from(
+      headers.entries()
+    ).map(([key, value]) => [key, value]);
+  }
+  if (isRecord2(headers)) {
+    return Object.entries(headers).map(([key, value]) => {
+      let flattened = flattenHeaderValue(value);
+      return flattened ? [key, flattened] : null;
+    }).filter((entry) => entry !== null);
+  }
+  return [];
+};
+var sanitizeHeaders = (headers) => {
+  let entries = headerEntries(headers).map(([key, value]) => [key.toLowerCase(), sanitizeScalar(value).text]).filter(([key]) => isSafeHeaderName(key));
+  if (entries.length === 0) return void 0;
+  return Object.fromEntries(entries);
+};
+var getContentType = (headers) => headerEntries(headers).find(([key]) => key.toLowerCase() === "content-type")?.[1];
+var takeTraceDraft = (config2) => {
+  if (!config2) return void 0;
+  let draft = config2.__slatesHttpTraceDraft ?? (isObjectLike(config2) ? traceDraftsByConfig.get(config2) : void 0) ?? (isObjectLike(config2.headers) ? traceDraftsByHeaders.get(config2.headers) : void 0);
+  if (!draft) return void 0;
+  return draft;
+};
+var clearTraceDraft = (config2, draft) => {
+  if (!config2) return;
+  if (config2.__slatesHttpTraceDraft === draft) {
+    delete config2.__slatesHttpTraceDraft;
+  }
+  if (isObjectLike(config2)) {
+    traceDraftsByConfig.delete(config2);
+  }
+  if (isObjectLike(config2.headers)) {
+    traceDraftsByHeaders.delete(config2.headers);
+  }
+};
+var attachHttpTraceDraft = (config2, context) => {
+  let traceAwareConfig = config2;
+  let contentType = getContentType(config2.headers);
+  traceAwareConfig.__slatesHttpTraceDraft = {
+    context,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    startedAtMs: Date.now(),
+    request: {
+      method: (config2.method ?? "GET").toUpperCase(),
+      url: sanitizeUrl(buildUrl(config2.baseURL, config2.url)),
+      ...sanitizeHeaders(config2.headers) ? { headers: sanitizeHeaders(config2.headers) } : {},
+      ...serializeTextBody(config2.data, contentType) ? { body: serializeTextBody(config2.data, contentType) } : {}
+    }
+  };
+  if (isObjectLike(traceAwareConfig)) {
+    traceDraftsByConfig.set(traceAwareConfig, traceAwareConfig.__slatesHttpTraceDraft);
+  }
+  if (isObjectLike(traceAwareConfig.headers)) {
+    traceDraftsByHeaders.set(
+      traceAwareConfig.headers,
+      traceAwareConfig.__slatesHttpTraceDraft
+    );
+  }
+  return config2;
+};
+var recordHttpTraceFromResponse = (response) => {
+  let config2 = response.config;
+  let draft = takeTraceDraft(config2);
+  if (!draft) return response;
+  clearTraceDraft(config2, draft);
+  let contentType = getContentType(response.headers);
+  draft.context.recordHttpTrace({
+    startedAt: draft.startedAt,
+    durationMs: Math.max(Date.now() - draft.startedAtMs, 0),
+    request: draft.request,
+    response: {
+      status: response.status,
+      ...response.statusText ? { statusText: response.statusText } : {},
+      ...sanitizeHeaders(response.headers) ? { headers: sanitizeHeaders(response.headers) } : {},
+      ...serializeTextBody(response.data, contentType) ? { body: serializeTextBody(response.data, contentType) } : {}
+    }
+  });
+  return response;
+};
+var recordHttpTraceFromError = (error) => {
+  let config2 = error.config;
+  let draft = takeTraceDraft(config2);
+  if (!draft) return;
+  clearTraceDraft(config2, draft);
+  let responseContentType = getContentType(error.response?.headers);
+  draft.context.recordHttpTrace({
+    startedAt: draft.startedAt,
+    durationMs: Math.max(Date.now() - draft.startedAtMs, 0),
+    request: draft.request,
+    ...error.response ? {
+      response: {
+        status: error.response.status,
+        ...error.response.statusText ? { statusText: error.response.statusText } : {},
+        ...sanitizeHeaders(error.response.headers) ? { headers: sanitizeHeaders(error.response.headers) } : {},
+        ...serializeTextBody(error.response.data, responseContentType) ? { body: serializeTextBody(error.response.data, responseContentType) } : {}
+      }
+    } : {},
+    error: {
+      ...error.code ? { code: error.code } : {},
+      message: error.message
+    }
+  });
+};
+
+// src/axios/index.ts
+var applySlateInterceptors = (instance, errorMapping) => {
+  instance.interceptors.request.use(
+    (request) => {
+      let ctx = getCurrentContext();
+      let spec2 = ctx.specification;
+      request.headers.set("User-Agent", `slates.dev@1.0.0/${spec2.key}`);
+      request.headers.set("X-Slates-Provider", spec2.key);
+      let tracedRequest = attachHttpTraceDraft(request, ctx);
+      if (!tracedRequest.__slatesTraceAdapterWrapped) {
+        let adapter = getAdapter(tracedRequest.adapter ?? baseAxios.defaults.adapter);
+        tracedRequest.adapter = async (config2) => {
+          try {
+            let response = await adapter(config2);
+            return recordHttpTraceFromResponse(response);
+          } catch (error) {
+            if (isAxiosError2(error)) {
+              recordHttpTraceFromError(error);
+            }
+            throw error;
+          }
+        };
+        tracedRequest.__slatesTraceAdapterWrapped = true;
+      }
+      return tracedRequest;
+    },
+    (error) => Promise.reject(error)
+  );
+  instance.interceptors.response.use(
+    (response) => response,
+    (error) => Promise.reject(SlateError.fromAxios(error, errorMapping))
+  );
+};
+applySlateInterceptors(baseAxios);
+var createAxios = (config2) => {
+  let { errorMapping, ...axiosConfig } = config2 ?? {};
+  let instance = baseAxios.create({
+    ...axiosConfig,
+    headers: {
+      ...axiosConfig.headers
+    }
+  });
+  applySlateInterceptors(instance, errorMapping);
+  return instance;
+};
+var axios = createAxios();
+
+// src/config/config.ts
+var SlateConfig = class _SlateConfig {
+  #configSchema;
+  #configChanged = null;
+  #getDefaultConfig = null;
+  constructor(schema) {
+    this.#configSchema = schema;
+  }
+  static create(schema) {
+    return new _SlateConfig(schema);
+  }
+  config(schema) {
+    this.#configSchema = schema;
+    return this;
+  }
+  onConfigChanged(handler) {
+    this.#configChanged = handler;
+    return this;
+  }
+  getDefaultConfig(getter) {
+    this.#getDefaultConfig = getter;
+    return this;
+  }
+  get configSchema() {
+    return this.#configSchema;
+  }
+  get handlers() {
+    return {
+      configChanged: this.#configChanged,
+      getDefaultConfig: this.#getDefaultConfig
+    };
+  }
+};
+var config = (schema) => SlateConfig.create(schema);
+
+// src/context/context.ts
+var SlateContext = class {
+  constructor(config2, input, auth2, spec2, logger) {
+    this.spec = spec2;
+    this.logger = logger;
+    this.#config = config2;
+    this.#input = input;
+    this.#auth = auth2;
+  }
+  spec;
+  logger;
+  #config;
+  #input;
+  #auth;
+  #httpTraces = [];
+  get specification() {
+    return this.spec;
+  }
+  get config() {
+    return Object.freeze(this.#config);
+  }
+  get input() {
+    return Object.freeze(this.#input);
+  }
+  get event() {
+    return Object.freeze(this.#input);
+  }
+  get state() {
+    return Object.freeze(this.#input.state);
+  }
+  get request() {
+    return Object.freeze(this.#input.request);
+  }
+  get auth() {
+    return Object.freeze(this.#auth);
+  }
+  recordHttpTrace(trace) {
+    this.#httpTraces.push(trace);
+  }
+  getHttpTraces() {
+    return this.#httpTraces.map((trace) => ({
+      ...trace,
+      request: {
+        ...trace.request,
+        ...trace.request.headers ? { headers: { ...trace.request.headers } } : {},
+        ...trace.request.body ? { body: { ...trace.request.body } } : {}
+      },
+      ...trace.response ? {
+        response: {
+          ...trace.response,
+          ...trace.response.headers ? { headers: { ...trace.response.headers } } : {},
+          ...trace.response.body ? { body: { ...trace.response.body } } : {}
+        }
+      } : {},
+      ...trace.error ? { error: { ...trace.error } } : {}
+    }));
+  }
+  info(message) {
+    this.logger.info(message);
+  }
+  warn(message) {
+    this.logger.warn(message);
+  }
+  error(message) {
+    this.logger.error(message);
+  }
+  progress(message) {
+    this.logger.progress(message);
+  }
+};
+
+// src/logger/logger.ts
+import { encode } from "@toon-format/toon";
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var normalizeMessage = (message) => {
+  if (Array.isArray(message)) {
+    let parts = message.map((part) => normalizeMessage(part));
+    let combinedMessage = parts.map((part) => part.message).filter(Boolean).join(" ").trim();
+    let dataParts = parts.map((part) => {
+      if (part.data) {
+        return {
+          message: part.message,
+          ...part.data
+        };
+      }
+      return part.message;
+    }).filter(Boolean);
+    return {
+      message: combinedMessage || "Log entry",
+      data: dataParts.length > 0 ? { parts: dataParts } : void 0
+    };
+  }
+  if (typeof message === "object") {
+    if (message === null) return { message: "null" };
+    if (message instanceof Error) {
+      return {
+        message: `${message.name}: ${message.message}`,
+        data: {
+          error: {
+            name: message.name,
+            message: message.message,
+            stack: message.stack
+          }
+        }
+      };
+    }
+    if (isRecord3(message) && typeof message.message === "string") {
+      let { message: text, ...data } = message;
+      return {
+        message: text || "Log entry",
+        data: Object.keys(data).length > 0 ? data : void 0
+      };
+    }
+    return {
+      message: encode(message),
+      data: isRecord3(message) ? message : void 0
+    };
+  }
+  return { message: String(message) };
+};
+var SlateLogger = class {
+  #logs = [];
+  #listeners = [];
+  #timer = null;
+  constructor(listeners = []) {
+    this.#listeners.push(...listeners);
+  }
+  flush() {
+    if (this.#timer) clearTimeout(this.#timer);
+    if (this.#logs.length === 0) return;
+    let logs = this.#logs.splice(0);
+    for (let listener of this.#listeners) {
+      listener(logs);
+    }
+  }
+  scheduleFlush() {
+    if (this.#timer) return;
+    this.#timer = setTimeout(() => {
+      this.flush();
+      this.#timer = null;
+    }, 10);
+  }
+  log(type, message) {
+    let normalized = normalizeMessage(message);
+    this.#logs.push({
+      type,
+      timestamp: /* @__PURE__ */ new Date(),
+      message: normalized.message,
+      data: normalized.data
+    });
+    this.scheduleFlush();
+  }
+  info(...message) {
+    this.log("info", message.length === 1 ? message[0] : message.flat());
+  }
+  warn(...message) {
+    this.log("warn", message.length === 1 ? message[0] : message.flat());
+  }
+  error(...message) {
+    this.log("error", message.length === 1 ? message[0] : message.flat());
+  }
+  progress(...message) {
+    this.log("progress", message.length === 1 ? message[0] : message.flat());
+  }
+};
+
+// src/specification/slate.ts
+var Slate = class _Slate {
+  constructor(_spec, _actions) {
+    this._spec = _spec;
+    this._actions = _actions;
+  }
+  _spec;
+  _actions;
+  static create(params) {
+    return new _Slate(params.spec, [...params.triggers, ...params.tools]);
+  }
+  get spec() {
+    return this._spec;
+  }
+  get actions() {
+    return this._actions;
+  }
+};
+
+// src/specification/specification.ts
+import z from "zod";
+var SlateSpecification = class _SlateSpecification {
+  constructor(_config, _auth, _params) {
+    this._config = _config;
+    this._auth = _auth;
+    this._params = _params;
+  }
+  _config;
+  _auth;
+  _params;
+  static create(params) {
+    return new _SlateSpecification(params.config, params.auth, params);
+  }
+  get configSchema() {
+    return this._config.configSchema;
+  }
+  get authSchema() {
+    return "outputSchema" in this._auth ? this._auth.outputSchema : z.object({});
+  }
+  get config() {
+    return this._config;
+  }
+  get auth() {
+    return this._auth;
+  }
+  get parameters() {
+    return this._params;
+  }
+  get key() {
+    return this._params.key;
+  }
+  get name() {
+    return this._params.name;
+  }
+  get description() {
+    return this._params.description;
+  }
+};
+var spec = (params) => SlateSpecification.create(params);
+export {
+  Slate,
+  SlateAction,
+  SlateAuth,
+  SlateConfig,
+  SlateContext,
+  SlateDeclarationError,
+  SlateDefaultPollingIntervalSeconds,
+  SlateError,
+  SlateLogger,
+  SlateSpecification,
+  SlateTool,
+  SlateTrigger,
+  allOf,
+  anyOf,
+  auth,
+  axios,
+  config,
+  createAxios,
+  createBase64Attachment,
+  createSlateError,
+  createTextAttachment,
+  createUrlAttachment,
+  getCurrentContext,
+  getServiceErrorData,
+  inferSlateErrorFromAxios,
+  isAxiosErrorLike,
+  isServiceErrorData,
+  mapServiceErrorCode,
+  mapServiceErrorToSlateErrorInput,
+  mergeScopes,
+  runWithContext,
+  scopeClause,
+  spec,
+  tool,
+  trigger,
+  validateScopes
+};