@slates/provider 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/index.module.js

@@ -1,2 +1,2775 @@
-import t from"axios";import{AsyncLocalStorage as e}from"async_hooks";import{encode as n}from"@toon-format/toon";import r from"zod";function i(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,r=Array(e);n<e;n++)r[n]=t[n];return r}function o(t,e){if(!{}.hasOwnProperty.call(t,e))throw new TypeError("attempted to use private field on non-instance");return t}var u=0;function a(t){return"__private_"+u+++"_"+t}function c(t,e){for(var n=0;n<e.length;n++){var r=e[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(t,d(r.key),r)}}function s(t,e,n){return e&&c(t.prototype,e),n&&c(t,n),Object.defineProperty(t,"prototype",{writable:!1}),t}function h(){return h=Object.assign?Object.assign.bind():function(t){for(var e=1;e<arguments.length;e++){var n=arguments[e];for(var r in n)({}).hasOwnProperty.call(n,r)&&(t[r]=n[r])}return t},h.apply(null,arguments)}function f(t){return f=Object.setPrototypeOf?Object.getPrototypeOf.bind():function(t){return t.__proto__||Object.getPrototypeOf(t)},f(t)}function l(t,e){t.prototype=Object.create(e.prototype),t.prototype.constructor=t,g(t,e)}function p(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],function(){}))}catch(t){}return(p=function(){return!!t})()}function g(t,e){return g=Object.setPrototypeOf?Object.setPrototypeOf.bind():function(t,e){return t.__proto__=e,t},g(t,e)}function d(t){var e=function(t){if("object"!=typeof t||!t)return t;var e=t[Symbol.toPrimitive];if(void 0!==e){var n=e.call(t,"string");if("object"!=typeof n)return n;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(t)}(t);return"symbol"==typeof e?e:e+""}function y(t){var e="function"==typeof Map?new Map:void 0;return y=function(t){if(null===t||!function(t){try{return-1!==Function.toString.call(t).indexOf("[native code]")}catch(e){return"function"==typeof t}}(t))return t;if("function"!=typeof t)throw new TypeError("Super expression must either be null or a function");if(void 0!==e){if(e.has(t))return e.get(t);e.set(t,n)}function n(){return function(t,e,n){if(p())return Reflect.construct.apply(null,arguments);var r=[null];r.push.apply(r,e);var i=new(t.bind.apply(t,r));return n&&g(i,n.prototype),i}(t,arguments,f(this).constructor)}return n.prototype=Object.create(t.prototype,{constructor:{value:n,enumerable:!1,writable:!0,configurable:!0}}),g(n,t)},y(t)}var v=/*#__PURE__*/function(){return s(function(t,e,n,r,i){this.type=void 0,this._spec=void 0,this._inputSchema=void 0,this._outputSchema=void 0,this._params=void 0,this.type=t,this._spec=e,this._inputSchema=n,this._outputSchema=r,this._params=i},[{key:"configSchema",get:function(){return this._spec.configSchema}},{key:"inputSchema",get:function(){return this._inputSchema}},{key:"outputSchema",get:function(){return this._outputSchema}},{key:"parameters",get:function(){return this._params}},{key:"key",get:function(){return this._params.key}},{key:"name",get:function(){return this._params.name}},{key:"description",get:function(){return this._params.description}},{key:"tags",get:function(){return this._params.tags}},{key:"instructions",get:function(){return this._params.instructions}},{key:"constraints",get:function(){return this._params.constraints}},{key:"metadata",get:function(){return this._params.metadata}}])}(),b=/*#__PURE__*/function(t){function e(e){var n;return(n=t.call(this,e)||this).name="SlateError",n}return l(e,t),e.is=function(t){return t instanceof e},e}(/*#__PURE__*/y(Error)),m=/*#__PURE__*/function(t){function e(e){var n;return(n=t.call(this,"[Declaration Error]: "+e)||this).name="SlateError.DeclarationError",n}return l(e,t),e.is=function(t){return t instanceof e},e}(b),w=/*#__PURE__*/a("configSchema"),k=/*#__PURE__*/a("authSchema"),O=/*#__PURE__*/a("inputSchema"),_=/*#__PURE__*/a("outputSchema"),S=/*#__PURE__*/a("toolParams"),j=/*#__PURE__*/a("triggerParams"),P=/*#__PURE__*/function(){function t(t,e,n,r){this.type=void 0,this.spec=void 0,this.params=void 0,this.factory=void 0,Object.defineProperty(this,w,{writable:!0,value:void 0}),Object.defineProperty(this,k,{writable:!0,value:void 0}),Object.defineProperty(this,O,{writable:!0,value:null}),Object.defineProperty(this,_,{writable:!0,value:null}),Object.defineProperty(this,S,{writable:!0,value:null}),Object.defineProperty(this,j,{writable:!0,value:null}),this.type=t,this.spec=e,this.params=n,this.factory=r,o(this,w)[w]=e.configSchema,o(this,k)[k]=e.authSchema}var e=t.prototype;return e.input=function(t){return o(this,O)[O]=t,this},e.output=function(t){return o(this,_)[_]=t,this},e.handleInvocation=function(t){if("tool"!==this.type)throw new m("handleInvocation can only be set for tool actions");return o(this,S)[S]={type:"tool",handleInvocation:t},this},e.webhook=function(t){if("trigger"!==this.type)throw new m("handleEvent can only be set for trigger actions");return o(this,j)[j]={type:"trigger",source:"webhook",handleEvent:t.handleEvent,handleRequest:t.handleRequest,autoRegisterWebhook:t.autoRegisterWebhook,autoUnregisterWebhook:t.autoUnregisterWebhook},this},e.polling=function(t){if("trigger"!==this.type)throw new m("handleEvent can only be set for trigger actions");return o(this,j)[j]={type:"trigger",source:"polling",polling:t.options,pollEvents:t.pollEvents,handleEvent:t.handleEvent},this},e.build=function(){if(!o(this,O)[O])throw new m("Input schema is not defined");if(!o(this,_)[_])throw new m("Output schema is not defined");if("tool"===this.type&&!o(this,S)[S])throw new m("Tool invocation handler is not defined");if("trigger"===this.type&&!o(this,j)[j])throw new m("Trigger event handlers are not defined");return this.factory(h({},this.params,{configSchema:o(this,w)[w],authSchema:o(this,k)[k],inputSchema:o(this,O)[O],outputSchema:o(this,_)[_]},o(this,S)[S],o(this,j)[j]))},t}(),E=/*#__PURE__*/a("handleInvocation"),A=/*#__PURE__*/function(t){function e(e,n,r,i){var u;return u=t.call(this,"tool",e,n,r,i)||this,Object.defineProperty(u,E,{writable:!0,value:void 0}),o(u,E)[E]=i.handleInvocation,u}return l(e,t),e.create=function(t,n){return new P("tool",t,n,function(n){if("tool"!=n.type)throw new Error("Invalid action type for tool");return new e(t,n.inputSchema,n.outputSchema,n)})},s(e,[{key:"handleInvocation",get:function(){return o(this,E)[E]}}])}(v),R=function(t,e){return A.create(t,e)},I=600,W=/*#__PURE__*/a("source"),C=/*#__PURE__*/a("polling"),T=/*#__PURE__*/a("handleEvent"),q=/*#__PURE__*/a("handleRequest"),x=/*#__PURE__*/a("pollEvents"),z=/*#__PURE__*/a("autoRegisterWebhook"),U=/*#__PURE__*/a("autoUnregisterWebhook"),D=/*#__PURE__*/function(t){function e(e,n,r,i){var u;return u=t.call(this,"trigger",e,n,r,i)||this,Object.defineProperty(u,W,{writable:!0,value:void 0}),Object.defineProperty(u,C,{writable:!0,value:void 0}),Object.defineProperty(u,T,{writable:!0,value:void 0}),Object.defineProperty(u,q,{writable:!0,value:void 0}),Object.defineProperty(u,x,{writable:!0,value:void 0}),Object.defineProperty(u,z,{writable:!0,value:void 0}),Object.defineProperty(u,U,{writable:!0,value:void 0}),o(u,W)[W]=i.source,o(u,C)[C]=i.polling||{intervalInSeconds:600},o(u,T)[T]=i.handleEvent,o(u,q)[q]=i.handleRequest,o(u,x)[x]=i.pollEvents,o(u,z)[z]=i.autoRegisterWebhook,o(u,U)[U]=i.autoUnregisterWebhook,u}return l(e,t),e.create=function(t,n){return new P("trigger",t,n,function(n){if("trigger"!=n.type)throw new Error("Invalid action type for trigger");return new e(t,n.inputSchema,n.outputSchema,n)})},s(e,[{key:"polling",get:function(){return o(this,C)[C]}},{key:"source",get:function(){return o(this,W)[W]}},{key:"handleEvent",get:function(){return o(this,T)[T]}},{key:"handleRequest",get:function(){return o(this,q)[q]}},{key:"pollEvents",get:function(){return o(this,x)[x]}},{key:"autoRegisterWebhook",get:function(){return o(this,z)[z]}},{key:"autoUnregisterWebhook",get:function(){return o(this,U)[U]}}])}(v),F=function(t,e){return D.create(t,e)},M=/*#__PURE__*/a("outputSchema"),N=/*#__PURE__*/a("authStack"),B=/*#__PURE__*/function(){function t(){Object.defineProperty(this,M,{writable:!0,value:null}),Object.defineProperty(this,N,{writable:!0,value:[]})}t.create=function(){return new t};var e=t.prototype;return e.output=function(t){return o(this,M)[M]=t,this},e.addAuth=function(t){if(o(this,N)[N].map(function(t){return t.key}).includes(t.key))throw new Error('Auth with key "'+t.key+'" already exists in the auth stack');return o(this,N)[N].push(t),this},e.addOauth=function(t){return this.addAuth(t),this},e.addTokenAuth=function(t){return this.addAuth(t),this},e.addServiceAccountAuth=function(t){return this.addAuth(t),this},e.addCustomAuth=function(t){return this.addAuth(t),this},e.addNone=function(){return this.addAuth({type:"auth.none",name:"No Authentication",key:"none"}),this},s(t,[{key:"authStack",get:function(){return o(this,N)[N].filter(function(t){return"auth.none"!=t.type})}},{key:"outputSchema",get:function(){if(!o(this,M)[M])throw new Error("Output schema is not defined for this auth");return o(this,M)[M]}}])}(),$=function(){return B.create()},G=new e,H=function(e){var n=t.create(h({},e,{headers:h({},null==e?void 0:e.headers)}));return n.interceptors.request.use(function(t){var e=function(){var t=G.getStore();if(!t)throw new Error("No Slate context is available");return t}();return t.headers.set("User-Agent","slates.dev@1.0.0/"+e.specification.key),t},function(t){return Promise.reject(t)}),n},J=H(),K=/*#__PURE__*/a("configSchema"),L=/*#__PURE__*/a("configChanged"),Q=/*#__PURE__*/a("getDefaultConfig"),V=/*#__PURE__*/function(){function t(t){Object.defineProperty(this,K,{writable:!0,value:void 0}),Object.defineProperty(this,L,{writable:!0,value:null}),Object.defineProperty(this,Q,{writable:!0,value:null}),o(this,K)[K]=t}t.create=function(e){return new t(e)};var e=t.prototype;return e.config=function(t){return o(this,K)[K]=t,this},e.onConfigChanged=function(t){return o(this,L)[L]=t,this},e.getDefaultConfig=function(t){return o(this,Q)[Q]=t,this},s(t,[{key:"configSchema",get:function(){return o(this,K)[K]}},{key:"handlers",get:function(){return{configChanged:o(this,L)[L],getDefaultConfig:o(this,Q)[Q]}}}])}(),X=function(t){return V.create(t)},Y=/*#__PURE__*/a("config"),Z=/*#__PURE__*/a("input"),tt=/*#__PURE__*/a("auth"),et=/*#__PURE__*/function(){function t(t,e,n,r,i){this.spec=void 0,this.logger=void 0,Object.defineProperty(this,Y,{writable:!0,value:void 0}),Object.defineProperty(this,Z,{writable:!0,value:void 0}),Object.defineProperty(this,tt,{writable:!0,value:void 0}),this.spec=r,this.logger=i,o(this,Y)[Y]=t,o(this,Z)[Z]=e,o(this,tt)[tt]=n}var e=t.prototype;return e.info=function(t){this.logger.info(t)},e.warn=function(t){this.logger.warn(t)},e.error=function(t){this.logger.error(t)},e.progress=function(t){this.logger.progress(t)},s(t,[{key:"specification",get:function(){return this.spec}},{key:"config",get:function(){return Object.freeze(o(this,Y)[Y])}},{key:"input",get:function(){return Object.freeze(o(this,Z)[Z])}},{key:"event",get:function(){return Object.freeze(o(this,Z)[Z])}},{key:"state",get:function(){return Object.freeze(o(this,Z)[Z].state)}},{key:"request",get:function(){return Object.freeze(o(this,Z)[Z].request)}},{key:"auth",get:function(){return Object.freeze(o(this,tt)[tt])}}])}(),nt=function(t){return"object"==typeof t?null===t?"null":t instanceof Error?"[ERROR]: "+t.name+": "+t.message+"\n"+t.stack:n(t):String(t)},rt=/*#__PURE__*/a("logs"),it=/*#__PURE__*/a("listeners"),ot=/*#__PURE__*/a("timer"),ut=/*#__PURE__*/function(){function t(t){var e;void 0===t&&(t=[]),Object.defineProperty(this,rt,{writable:!0,value:[]}),Object.defineProperty(this,it,{writable:!0,value:[]}),Object.defineProperty(this,ot,{writable:!0,value:null}),(e=o(this,it)[it]).push.apply(e,t)}var e=t.prototype;return e.flush=function(){if(o(this,ot)[ot]&&clearTimeout(o(this,ot)[ot]),0!==o(this,rt)[rt].length)for(var t,e=function(t){var e="undefined"!=typeof Symbol&&t[Symbol.iterator]||t["@@iterator"];if(e)return(e=e.call(t)).next.bind(e);if(Array.isArray(t)||(e=function(t,e){if(t){if("string"==typeof t)return i(t,e);var n={}.toString.call(t).slice(8,-1);return"Object"===n&&t.constructor&&(n=t.constructor.name),"Map"===n||"Set"===n?Array.from(t):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?i(t,e):void 0}}(t))){e&&(t=e);var n=0;return function(){return n>=t.length?{done:!0}:{done:!1,value:t[n++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}(o(this,it)[it]);!(t=e()).done;)(0,t.value)(o(this,rt)[rt])},e.scheduleFlush=function(){var t=this;o(this,ot)[ot]||(o(this,ot)[ot]=setTimeout(function(){t.flush(),o(t,ot)[ot]=null},10))},e.log=function(t,e){o(this,rt)[rt].push({type:t,timestamp:new Date,message:nt(e)}),this.scheduleFlush()},e.info=function(){this.log("info",[].slice.call(arguments).flat())},e.warn=function(){this.log("warn",[].slice.call(arguments).flat())},e.error=function(){this.log("error",[].slice.call(arguments).flat())},e.progress=function(){this.log("progress",[].slice.call(arguments).flat())},t}(),at=/*#__PURE__*/function(){function t(t,e){this._spec=void 0,this._actions=void 0,this._spec=t,this._actions=e}return t.create=function(e){return new t(e.spec,[].concat(e.triggers,e.tools))},s(t,[{key:"spec",get:function(){return this._spec}},{key:"actions",get:function(){return this._actions}}])}(),ct=/*#__PURE__*/function(){function t(t,e,n){this._config=void 0,this._auth=void 0,this._params=void 0,this._config=t,this._auth=e,this._params=n}return t.create=function(e){return new t(e.config,e.auth,e)},s(t,[{key:"configSchema",get:function(){return this._config.configSchema}},{key:"authSchema",get:function(){return"outputSchema"in this._auth?this._auth.outputSchema:r.object({})}},{key:"config",get:function(){return this._config}},{key:"auth",get:function(){return this._auth}},{key:"parameters",get:function(){return this._params}},{key:"key",get:function(){return this._params.key}},{key:"name",get:function(){return this._params.name}},{key:"description",get:function(){return this._params.description}}])}(),st=function(t){return ct.create(t)};export{at as Slate,v as SlateAction,B as SlateAuth,V as SlateConfig,et as SlateContext,m as SlateDeclarationError,I as SlateDefaultPollingIntervalSeconds,b as SlateError,ut as SlateLogger,ct as SlateSpecification,A as SlateTool,D as SlateTrigger,$ as auth,J as axios,X as config,H as createAxios,st as spec,R as tool,F as trigger};
-//# sourceMappingURL=index.module.js.map
+// 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;
+  }
+  get authMethods() {
+    return this._params.authMethods;
+  }
+  get docs() {
+    return this._params.docs;
+  }
+  get adapter() {
+    return this._params.adapter ?? null;
+  }
+  get isPublic() {
+    return this._params.isPublic === true;
+  }
+};
+
+// src/error/api.ts
+import { badRequestError, ServiceError } from "@lowerdeck/error";
+var DEFAULT_DETAIL_KEYS = ["message", "detail", "error", "error_description", "code"];
+var DEFAULT_NESTED_KEYS = ["errors"];
+var isApiErrorRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var pushDetail = (details, value, options = {}) => {
+  if (typeof value !== "string" && (options.includeNumbers === false || typeof value !== "number")) {
+    return;
+  }
+  let detail = String(value).trim();
+  if (detail && !details.includes(detail)) {
+    details.push(detail);
+  }
+};
+var collectApiErrorDetails = (value, details, options = {}) => {
+  if (Array.isArray(value)) {
+    for (let item of value) {
+      collectApiErrorDetails(item, details, options);
+    }
+    return;
+  }
+  if (!isApiErrorRecord(value)) {
+    pushDetail(details, value, options);
+    return;
+  }
+  for (let key of options.detailKeys ?? DEFAULT_DETAIL_KEYS) {
+    pushDetail(details, value[key], options);
+  }
+  for (let key of options.nestedKeys ?? DEFAULT_NESTED_KEYS) {
+    collectApiErrorDetails(value[key], details, options);
+  }
+};
+var getSlateErrorResponse = (error) => {
+  if (error.name !== "SlateError" || !isApiErrorRecord(error.data)) {
+    return void 0;
+  }
+  let data = error.data;
+  let upstream = isApiErrorRecord(data.upstream) ? data.upstream : void 0;
+  let status = upstream?.status ?? data.status;
+  return typeof status === "number" || typeof status === "string" ? { status } : void 0;
+};
+var getApiErrorResponse = (error) => {
+  if (!isApiErrorRecord(error)) {
+    return void 0;
+  }
+  if (!isApiErrorRecord(error.response)) {
+    return getSlateErrorResponse(error);
+  }
+  let response = error.response;
+  return {
+    status: typeof response.status === "number" || typeof response.status === "string" ? response.status : void 0,
+    statusText: typeof response.statusText === "string" ? response.statusText : void 0,
+    data: response.data
+  };
+};
+var getApiErrorStatus = (error) => getApiErrorResponse(error)?.status;
+var statusLabelForApiError = (status, statusText) => status !== void 0 ? `HTTP ${status}${statusText ? ` ${statusText}` : ""}: ` : "";
+var extractApiErrorMessage = (error, options = {}) => {
+  let details = [];
+  let response = options.response ?? getApiErrorResponse(error);
+  collectApiErrorDetails(response?.data, details, options);
+  if (details.length > 0) {
+    return details.join(options.separator ?? " - ");
+  }
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return options.fallbackMessage ?? "Unknown error";
+};
+var createApiServiceError = (message, options = {}) => {
+  let error = new ServiceError(badRequestError({ message }));
+  if (options.reason !== void 0) {
+    error.data.reason = options.reason;
+  }
+  if ("upstreamStatus" in options) {
+    error.data.upstreamStatus = options.upstreamStatus;
+  }
+  if ("upstreamCode" in options) {
+    error.data.upstreamCode = options.upstreamCode;
+  }
+  if (options.parent instanceof Error) {
+    error.setParent(options.parent);
+  }
+  return error;
+};
+var helpers = {
+  collectDetails: collectApiErrorDetails,
+  extractMessage: extractApiErrorMessage,
+  getResponse: getApiErrorResponse,
+  getStatus: getApiErrorStatus,
+  isRecord: isApiErrorRecord,
+  statusLabelFor: statusLabelForApiError
+};
+var buildApiServiceError = (error, options) => {
+  if (error instanceof ServiceError) {
+    return error;
+  }
+  let operation = options.operation ?? "request";
+  let response = options.extractResponse?.(error, helpers) ?? getApiErrorResponse(error);
+  let status = options.extractStatus?.(error, response, helpers) ?? response?.status;
+  let message = options.extractMessage?.(error, helpers) ?? extractApiErrorMessage(error, { ...options, response });
+  let statusLabel = statusLabelForApiError(status, response?.statusText);
+  let fullMessage = options.formatMessage?.({
+    providerLabel: options.providerLabel,
+    operation,
+    statusLabel,
+    message,
+    response,
+    status
+  }) ?? `${options.providerLabel} API ${operation} failed: ${statusLabel}${message}`;
+  return createApiServiceError(fullMessage, {
+    reason: options.reason,
+    upstreamStatus: status,
+    upstreamCode: options.extractUpstreamCode?.(error, response, helpers),
+    parent: options.parent ?? error
+  });
+};
+
+// src/error/axios.ts
+import { isAxiosError } from "axios";
+
+// src/context/hook.ts
+import { AsyncLocalStorage } from "async_hooks";
+var slateContextStorageKey = /* @__PURE__ */ Symbol.for("slates.provider.context.asyncLocalStorage");
+var globalWithSlateContext = globalThis;
+var asyncLocalStorage = globalWithSlateContext[slateContextStorageKey] ?? new AsyncLocalStorage();
+globalWithSlateContext[slateContextStorageKey] = 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?.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, isPublicTool = false) {
+    this.type = type;
+    this.spec = spec2;
+    this.params = params;
+    this.factory = factory;
+    this.isPublicTool = isPublicTool;
+    this.#configSchema = spec2.configSchema;
+    this.#authSchema = spec2.authSchema;
+  }
+  type;
+  spec;
+  params;
+  factory;
+  isPublicTool;
+  #configSchema;
+  #authSchema;
+  #inputSchema = null;
+  #outputSchema = null;
+  #scopes;
+  #authMethods;
+  #toolParams = null;
+  #triggerParams = null;
+  #interfaceLocked = false;
+  input(schema) {
+    if (this.#interfaceLocked) {
+      throw new SlateDeclarationError("Adapter contract input schema cannot be changed");
+    }
+    this.#inputSchema = schema;
+    return this;
+  }
+  output(schema) {
+    if (this.#interfaceLocked) {
+      throw new SlateDeclarationError("Adapter contract output schema cannot be changed");
+    }
+    this.#outputSchema = schema;
+    return this;
+  }
+  lockInterface() {
+    this.#interfaceLocked = true;
+    return this;
+  }
+  scopes(scopes) {
+    validateScopes(scopes);
+    this.#scopes = scopes;
+    return this;
+  }
+  authMethods(authMethods) {
+    if (this.isPublicTool) {
+      throw new SlateDeclarationError("Public tools cannot require authentication methods");
+    }
+    this.#authMethods = this.validateAuthMethods(authMethods);
+    return this;
+  }
+  validateAuthMethods(authMethods) {
+    if (!authMethods) return void 0;
+    let normalized = [...new Set(authMethods.map((authMethod) => authMethod.trim()))];
+    if (normalized.some((authMethod) => !authMethod)) {
+      throw new SlateDeclarationError("Auth method IDs must be non-empty strings");
+    }
+    return normalized;
+  }
+  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,
+      http: props.http
+    };
+    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);
+    }
+    let authMethods = this.validateAuthMethods(this.#authMethods ?? this.params.authMethods);
+    if (this.isPublicTool && authMethods) {
+      throw new SlateDeclarationError("Public tools cannot require authentication methods");
+    }
+    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,
+      authMethods,
+      isPublic: this.isPublicTool === true,
+      configSchema: this.#configSchema,
+      authSchema: this.#authSchema,
+      inputSchema: this.#inputSchema,
+      outputSchema: this.#outputSchema,
+      ...this.#toolParams,
+      ...this.#triggerParams
+    });
+  }
+};
+
+// src/action/getFileUrlTool.ts
+import { z } from "zod";
+
+// 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) => {
+      return _SlateTool.fromCreateParameters(spec2, params2);
+    });
+  }
+  static fromCreateParameters(spec2, params) {
+    if (params.type !== "tool") throw new Error("Invalid action type for tool");
+    return new _SlateTool(spec2, params.inputSchema, params.outputSchema, params);
+  }
+  get handleInvocation() {
+    return this.#handleInvocation;
+  }
+};
+var tool = (spec2, params) => SlateTool.create(spec2, params);
+
+// src/action/getFileUrlTool.ts
+var GET_FILE_URL_TOOL_ID = "metorial$getFileUrl";
+var getFileUrlToolInputSchema = z.object({
+  url: z.string(),
+  reference: z.any().nullable()
+});
+var getFileUrlToolOutputSchema = z.object({
+  url: z.string(),
+  expiresAt: z.string(),
+  headers: z.record(z.string(), z.string()).optional(),
+  query: z.record(z.string(), z.string()).optional()
+});
+var getFileUrlTool = (spec2, handleGetFileUrl) => tool(spec2, {
+  key: GET_FILE_URL_TOOL_ID,
+  name: "Get File URL",
+  description: "Reserved: refreshes an expiring attachment download URL. Hub-internal only."
+}).input(getFileUrlToolInputSchema).output(getFileUrlToolOutputSchema).handleInvocation(async (ctx) => ({
+  output: await handleGetFileUrl(ctx),
+  message: "ok"
+})).build();
+
+// src/action/publicTool.ts
+var SlatePublicTool = class {
+  constructor() {
+  }
+  static create(spec2, params) {
+    return new SlateActionBuilder(
+      "tool",
+      spec2,
+      params,
+      (params2) => {
+        return SlateTool.fromCreateParameters(spec2, {
+          ...params2,
+          isPublic: true
+        });
+      },
+      true
+    );
+  }
+};
+var publicTool = (spec2, params) => SlatePublicTool.create(spec2, params);
+
+// src/action/trigger.ts
+var SlateDefaultPollingIntervalSeconds = 60 * 10;
+var SlateTrigger = class _SlateTrigger extends SlateAction {
+  #source;
+  #polling;
+  #handleEvent;
+  #handleRequest;
+  #http;
+  #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.#http = params.http;
+    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 http() {
+    return this.#http;
+  }
+  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, opts = {}) => {
+  if (opts.refreshReference !== void 0 && !opts.refreshAt) {
+    throw new Error("createUrlAttachment: refreshAt is required when refreshReference is set");
+  }
+  return {
+    mimeType: opts.mimeType,
+    attachmentHash: opts.attachmentHash,
+    content: {
+      type: "url",
+      url,
+      ...opts.headers ? { headers: opts.headers } : {},
+      ...opts.query ? { query: opts.query } : {},
+      ...opts.refreshReference !== void 0 ? { refreshReference: opts.refreshReference } : {},
+      ...opts.refreshAt ? { refreshAt: opts.refreshAt } : {}
+    }
+  };
+};
+var createBase64Attachment = (content, mimeType, attachmentHash) => ({
+  mimeType,
+  attachmentHash,
+  content: {
+    type: "content",
+    encoding: "base64",
+    content
+  }
+});
+var createTextAttachment = (content, mimeType, attachmentHash) => ({
+  mimeType,
+  attachmentHash,
+  content: {
+    type: "content",
+    encoding: "utf-8",
+    content
+  }
+});
+
+// src/action/directUpload.ts
+var bufferAttachmentBody = async (body, maxSizeBytes) => {
+  if (body instanceof Uint8Array) {
+    if (body.byteLength > maxSizeBytes) {
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+    return body;
+  }
+  let reader = body.getReader();
+  let chunks = [];
+  let sizeBytes = 0;
+  while (true) {
+    let { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    sizeBytes += value.byteLength;
+    if (sizeBytes > maxSizeBytes) {
+      await reader.cancel();
+      throw new Error(`Attachment exceeds the maximum size of ${maxSizeBytes} bytes`);
+    }
+    chunks.push(value);
+  }
+  let buffered = new Uint8Array(sizeBytes);
+  let offset = 0;
+  for (let chunk of chunks) {
+    buffered.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return buffered;
+};
+var uploadAttachmentDirect = async (d) => {
+  let baseUrl = d.live.baseUrl.replace(/\/$/, "");
+  let body = await bufferAttachmentBody(d.body, d.live.maxAttachmentSizeBytes);
+  let registerRes = await fetch(`${baseUrl}/slates-hub/live-invocation/attachments`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${d.live.token}`
+    },
+    body: JSON.stringify({
+      attachments: [
+        {
+          mimeType: d.mimeType,
+          filename: d.filename,
+          sizeBytes: body.byteLength || void 0
+        }
+      ]
+    })
+  });
+  if (!registerRes.ok) {
+    throw new Error(
+      `Failed to register attachment for direct upload (status ${registerRes.status})`
+    );
+  }
+  let { attachments } = await registerRes.json();
+  let registration = attachments[0];
+  if (!registration) {
+    throw new Error("Live invocation API returned no attachment registrations");
+  }
+  let putRes = await fetch(registration.uploadUrl, {
+    method: "PUT",
+    headers: {
+      ...d.mimeType ? { "content-type": d.mimeType } : {},
+      "content-length": String(body.byteLength)
+    },
+    body
+  });
+  if (!putRes.ok) {
+    throw new Error(`Failed to upload attachment content (status ${putRes.status})`);
+  }
+  return {
+    mimeType: d.mimeType,
+    content: { type: "upload_reference", referenceId: registration.referenceId }
+  };
+};
+
+// src/adapter/adapter.ts
+var SlateAdapter = class {
+  constructor(_spec, _tools, _triggers) {
+    this._spec = _spec;
+    this._tools = _tools;
+    this._triggers = _triggers;
+  }
+  _spec;
+  _tools;
+  _triggers;
+  get spec() {
+    return this._spec;
+  }
+  get id() {
+    return this._spec.id;
+  }
+  get name() {
+    return this._spec.name;
+  }
+  get capabilities() {
+    return this._spec.capabilities;
+  }
+  get tools() {
+    return this._tools;
+  }
+  get triggers() {
+    return this._triggers;
+  }
+  get actions() {
+    return [...this._triggers, ...this._tools];
+  }
+};
+
+// src/adapter/spec.ts
+var SlateAdapterSpec = class _SlateAdapterSpec {
+  constructor(_params) {
+    this._params = _params;
+  }
+  _params;
+  static create(params) {
+    let id = params.id?.trim();
+    let name = params.name?.trim();
+    if (!id) {
+      throw new SlateDeclarationError("Adapter id must be a non-empty string");
+    }
+    if (!name) {
+      throw new SlateDeclarationError("Adapter name must be a non-empty string");
+    }
+    return new _SlateAdapterSpec({
+      id,
+      name,
+      capabilities: validateCapabilities(params.capabilities ?? [])
+    });
+  }
+  get id() {
+    return this._params.id;
+  }
+  get name() {
+    return this._params.name;
+  }
+  get capabilities() {
+    return this._params.capabilities;
+  }
+  get parameters() {
+    return this._params;
+  }
+  tool(spec2, params) {
+    return SlateTool.create(spec2, this.linkAction(params));
+  }
+  publicTool(spec2, params) {
+    return SlatePublicTool.create(spec2, this.linkAction(params));
+  }
+  trigger(spec2, params) {
+    return SlateTrigger.create(spec2, this.linkAction(params));
+  }
+  register(params) {
+    let actions = [...params.tools, ...params.triggers];
+    let seenKeys = /* @__PURE__ */ new Set();
+    for (let action of actions) {
+      if (action.adapter && action.adapter !== this.id) {
+        throw new SlateDeclarationError(
+          `Action "${action.key}" is linked to adapter "${action.adapter}", not "${this.id}"`
+        );
+      }
+      if (!action.adapter) {
+        throw new SlateDeclarationError(
+          `Action "${action.key}" must be created with this adapter's tool(), publicTool(), or trigger() helpers`
+        );
+      }
+      if (seenKeys.has(action.key)) {
+        throw new SlateDeclarationError(
+          `Adapter "${this.id}" already has an action with key "${action.key}"`
+        );
+      }
+      seenKeys.add(action.key);
+    }
+    return new SlateAdapter(this, params.tools, params.triggers);
+  }
+  linkAction(params) {
+    if (params.adapter != null && params.adapter !== this.id) {
+      throw new SlateDeclarationError(
+        `Action "${params.key}" cannot be linked to adapter "${this.id}" because it is already linked to "${params.adapter}"`
+      );
+    }
+    return {
+      ...params,
+      adapter: this.id
+    };
+  }
+};
+var adapterSpec = (params) => SlateAdapterSpec.create(params);
+var validateCapabilities = (capabilities) => {
+  let seenIds = /* @__PURE__ */ new Set();
+  return capabilities.map((capability) => {
+    let id = capability.id?.trim();
+    if (!id) {
+      throw new SlateDeclarationError("Adapter capability ids must be non-empty strings");
+    }
+    if (seenIds.has(id)) {
+      throw new SlateDeclarationError(`Adapter capability "${id}" is defined more than once`);
+    }
+    seenIds.add(id);
+    return {
+      id,
+      value: capability.value
+    };
+  });
+};
+
+// 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/auth/oauth.ts
+var isOAuthTokenResponse = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var formatOAuthTokenResponseMessage = (fieldLabel, providerLabel = "OAuth provider", operation = "token response") => `${providerLabel} OAuth ${operation} did not return ${fieldLabel}.`;
+var getOAuthExpiresAtFromExpiresIn = (expiresIn, options = {}) => {
+  let {
+    nowMs = Date.now(),
+    providerLabel,
+    operation,
+    required = false,
+    expiresInType = "numberLike",
+    message
+  } = options;
+  if (expiresIn === void 0 || expiresIn === null || expiresIn === "") {
+    if (required) {
+      throw createApiServiceError(
+        message ?? formatOAuthTokenResponseMessage(
+          "a valid expires_in value",
+          providerLabel,
+          operation
+        ),
+        { reason: "oauth_token_response" }
+      );
+    }
+    return void 0;
+  }
+  let seconds = typeof expiresIn === "number" ? expiresIn : expiresInType === "numberLike" && typeof expiresIn === "string" ? Number(expiresIn) : Number.NaN;
+  if (!Number.isFinite(seconds)) {
+    throw createApiServiceError(
+      message ?? formatOAuthTokenResponseMessage("a valid expires_in value", providerLabel, operation),
+      { reason: "oauth_token_response" }
+    );
+  }
+  return new Date(nowMs + seconds * 1e3).toISOString();
+};
+var getRefreshToken = (refreshToken, previousRefreshToken, fallbackMode) => {
+  if (typeof refreshToken === "string") {
+    if (fallbackMode === "falsy" && !refreshToken) {
+      return previousRefreshToken;
+    }
+    return refreshToken;
+  }
+  if (fallbackMode === "falsy" && !refreshToken) {
+    return previousRefreshToken;
+  }
+  return refreshToken === void 0 || refreshToken === null ? previousRefreshToken : void 0;
+};
+var normalizeOAuthTokenResponse = (data, options = {}) => {
+  let {
+    providerLabel,
+    operation,
+    previousRefreshToken,
+    refreshTokenFallbackMode = "nullish",
+    accessTokenMessage,
+    expiresInMessage,
+    ...expiresAtOptions
+  } = options;
+  if (!isOAuthTokenResponse(data)) {
+    throw createApiServiceError(
+      accessTokenMessage ?? formatOAuthTokenResponseMessage("a token response object", providerLabel, operation),
+      { reason: "oauth_token_response" }
+    );
+  }
+  if (typeof data.access_token !== "string" || !data.access_token) {
+    throw createApiServiceError(
+      accessTokenMessage ?? formatOAuthTokenResponseMessage("an access token", providerLabel, operation),
+      { reason: "oauth_token_response" }
+    );
+  }
+  return {
+    token: data.access_token,
+    refreshToken: getRefreshToken(
+      data.refresh_token,
+      previousRefreshToken,
+      refreshTokenFallbackMode
+    ),
+    expiresAt: getOAuthExpiresAtFromExpiresIn(data.expires_in, {
+      ...expiresAtOptions,
+      providerLabel,
+      operation,
+      message: expiresInMessage
+    })
+  };
+};
+
+// src/auth/redact.ts
+var AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX = "$$MT$secret$authConfig$";
+var AuthConfigSecretRedactor = class {
+  secretToPlaceholder = /* @__PURE__ */ new Map();
+  constructor(authConfig) {
+    if (authConfig) this.buildSecretMap(authConfig);
+  }
+  redact(value) {
+    return this.transform(value, (stringValue) => {
+      return this.secretToPlaceholder.get(stringValue) ?? stringValue;
+    });
+  }
+  buildSecretMap(value, path = []) {
+    if (typeof value === "string") {
+      if (value.length === 0) return;
+      this.secretToPlaceholder.set(
+        value,
+        `${AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX}${path.join(".")}`
+      );
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        this.buildSecretMap(item, [...path, String(index)]);
+      });
+      return;
+    }
+    if (this.isPlainObject(value)) {
+      Object.entries(value).forEach(([key, nestedValue]) => {
+        this.buildSecretMap(nestedValue, [...path, key]);
+      });
+    }
+  }
+  transform(value, transformString) {
+    if (typeof value === "string") {
+      return transformString(value);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => this.transform(item, transformString));
+    }
+    if (this.isPlainObject(value)) {
+      let result = {};
+      Object.entries(value).forEach(([key, nestedValue]) => {
+        result[key] = this.transform(nestedValue, transformString);
+      });
+      return result;
+    }
+    return value;
+  }
+  isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+};
+var redactUrlAttachmentSecrets = (attachments, authConfig) => {
+  if (!authConfig || !attachments) return attachments;
+  let redactor = new AuthConfigSecretRedactor(authConfig);
+  return attachments.map((attachment) => {
+    if (attachment.content.type !== "url") return attachment;
+    if (!attachment.content.headers && !attachment.content.query) return attachment;
+    return {
+      ...attachment,
+      content: {
+        ...attachment.content,
+        headers: attachment.content.headers ? redactor.redact(attachment.content.headers) : void 0,
+        query: attachment.content.query ? redactor.redact(attachment.content.query) : void 0
+      }
+    };
+  });
+};
+
+// 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, redactor) => {
+  if (!text) return text;
+  let result = redactor ? redactor.redact(text) : 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, redactor) => truncateText(sanitizeFreeText(value, redactor));
+var redactStructuredValue = (value, depth = 0, redactor) => {
+  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, redactor) : value;
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, STRUCTURED_ENTRY_LIMIT).map((entry) => redactStructuredValue(entry, depth + 1, redactor));
+  }
+  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, redactor)
+      ])
+    );
+  }
+  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, redactor) => {
+  if (!text) return void 0;
+  let normalizedContentType = normalizeContentType(contentType);
+  let parsedJson = maybeParseJson(text, normalizedContentType);
+  let normalizedText = parsedJson !== null ? JSON.stringify(redactStructuredValue(parsedJson, 0, redactor)) : sanitizeFreeText(text, redactor);
+  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, redactor) => {
+  let normalizedContentType = normalizeContentType(contentType);
+  if (value == null || isBinaryLike(value) || !isTextContentType(normalizedContentType)) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return sanitizeTextBody(value, normalizedContentType, redactor);
+  }
+  if (value instanceof URLSearchParams) {
+    return sanitizeTextBody(value.toString(), normalizedContentType, redactor);
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return sanitizeTextBody(String(value), normalizedContentType, redactor);
+  }
+  if (Array.isArray(value) || isRecord2(value)) {
+    return sanitizeTextBody(
+      JSON.stringify(redactStructuredValue(value, 0, redactor)),
+      "application/json",
+      redactor
+    );
+  }
+  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, redactor) => {
+  if (!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) => {
+      if (isUrlFormSecretKeyName(key)) return `${key}=${REDACTED_VALUE}`;
+      let literalRedacted = redactor ? redactor.redact(rawValue) : rawValue;
+      return literalRedacted !== rawValue ? `${key}=${literalRedacted}` : match;
+    }
+  );
+  return redacted ? `#${redacted}` : "";
+};
+var sanitizeUrl = (value, redactor) => {
+  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);
+        continue;
+      }
+      let rawValue = url.searchParams.get(key) ?? "";
+      let literalRedacted = redactor ? redactor.redact(rawValue) : rawValue;
+      if (literalRedacted !== rawValue) url.searchParams.set(key, literalRedacted);
+    }
+    url.hash = redactHashFragment(url.hash, redactor);
+    return decodeRedactedMarker(url.toString());
+  } catch {
+    let text = redactor ? redactor.redact(value) : value;
+    return text.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, redactor) => {
+  let entries = headerEntries(headers).map(
+    ([key, value]) => [key.toLowerCase(), sanitizeScalar(value, redactor).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) {
+    config2.__slatesHttpTraceDraft = void 0;
+  }
+  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);
+  let redactor = new AuthConfigSecretRedactor(context._getAuthConfigForRedaction());
+  traceAwareConfig.__slatesHttpTraceDraft = {
+    context,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    startedAtMs: Date.now(),
+    request: {
+      method: (config2.method ?? "GET").toUpperCase(),
+      url: sanitizeUrl(buildUrl(config2.baseURL, config2.url), redactor),
+      ...sanitizeHeaders(config2.headers, redactor) ? { headers: sanitizeHeaders(config2.headers, redactor) } : {},
+      ...serializeTextBody(config2.data, contentType, redactor) ? { body: serializeTextBody(config2.data, contentType, redactor) } : {}
+    }
+  };
+  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 redactor = new AuthConfigSecretRedactor(draft.context._getAuthConfigForRedaction());
+  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, redactor) ? { headers: sanitizeHeaders(response.headers, redactor) } : {},
+      ...serializeTextBody(response.data, contentType, redactor) ? { body: serializeTextBody(response.data, contentType, redactor) } : {}
+    }
+  });
+  return response;
+};
+var recordHttpTraceFromError = (error) => {
+  let config2 = error.config;
+  let draft = takeTraceDraft(config2);
+  if (!draft) return;
+  clearTraceDraft(config2, draft);
+  let redactor = new AuthConfigSecretRedactor(draft.context._getAuthConfigForRedaction());
+  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, redactor) ? { headers: sanitizeHeaders(error.response.headers, redactor) } : {},
+        ...serializeTextBody(error.response.data, responseContentType, redactor) ? { body: serializeTextBody(error.response.data, responseContentType, redactor) } : {}
+      }
+    } : {},
+    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;
+      let providerToken = spec2.key.replace(/[^A-Za-z0-9!#$%&'*+\-.^_`|~]/g, "-");
+      request.headers.set("User-Agent", `slates.dev/1.0.0 ${providerToken || "unknown"}`);
+      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 createAuthenticatedAxios = (config2) => {
+  let { authHeader, contentType = "application/json", errorAdapter, ...axiosConfig } = config2;
+  let instance = createAxios({
+    ...axiosConfig,
+    headers: {
+      ...contentType === false ? {} : { "Content-Type": contentType },
+      ...authHeader ? { [authHeader.name ?? "Authorization"]: authHeader.value } : {},
+      ...axiosConfig.headers
+    }
+  });
+  if (errorAdapter) {
+    instance.interceptors.response.use(
+      (response) => response,
+      (error) => Promise.reject(errorAdapter(error))
+    );
+  }
+  return instance;
+};
+var requestAxios = async (operation, request, errorAdapter) => {
+  try {
+    return await request();
+  } catch (error) {
+    throw errorAdapter(error, operation);
+  }
+};
+var requestAxiosData = async (operation, request, errorAdapter) => {
+  let response = await requestAxios(operation, request, errorAdapter);
+  return response.data;
+};
+var axios = createAxios();
+
+// src/config/config.ts
+var SlateConfig = class _SlateConfig {
+  #configSchema;
+  #docs;
+  #configChanged = null;
+  #getDefaultConfig = null;
+  constructor(schema) {
+    this.#configSchema = schema;
+  }
+  static create(schema) {
+    return new _SlateConfig(schema);
+  }
+  config(schema) {
+    this.#configSchema = schema;
+    return this;
+  }
+  docs(docs) {
+    this.#docs = docs;
+    return this;
+  }
+  onConfigChanged(handler) {
+    this.#configChanged = handler;
+    return this;
+  }
+  getDefaultConfig(getter) {
+    this.#getDefaultConfig = getter;
+    return this;
+  }
+  get configSchema() {
+    return this.#configSchema;
+  }
+  get docsReferences() {
+    return this.#docs;
+  }
+  get handlers() {
+    return {
+      configChanged: this.#configChanged,
+      getDefaultConfig: this.#getDefaultConfig
+    };
+  }
+};
+var config = (schema) => SlateConfig.create(schema);
+
+// src/context/context.ts
+import { Readable } from "stream";
+
+// src/context/pQueue.ts
+import PQueueImport from "p-queue";
+
+// src/module/resolveDefaultExport.ts
+var resolveDefaultExport = (value) => {
+  let current = value;
+  for (let i = 0; i < 4; i++) {
+    if (typeof current === "function") return current;
+    if (current && typeof current === "object" && "default" in current) {
+      current = current.default;
+      continue;
+    }
+    break;
+  }
+  throw new TypeError("Module export is not a constructor");
+};
+
+// src/context/pQueue.ts
+var PQueue = resolveDefaultExport(PQueueImport);
+
+// src/context/context.ts
+var isBufferLike = (value) => value instanceof Uint8Array || value instanceof ArrayBuffer;
+var toUint8Array = (value) => value instanceof ArrayBuffer ? new Uint8Array(value) : value;
+var isReadableStream = (value) => typeof ReadableStream !== "undefined" && value instanceof ReadableStream;
+var isNodeReadable = (value) => !!value && typeof value === "object" && typeof value.pipe === "function" && typeof value.on === "function";
+var isResponseLike = (value) => typeof Response !== "undefined" && value instanceof Response;
+var readStreamToBuffer = async (stream) => {
+  let reader = stream.getReader();
+  let chunks = [];
+  while (true) {
+    let { done, value } = await reader.read();
+    if (done) break;
+    if (value) chunks.push(value);
+  }
+  return Buffer.concat(chunks);
+};
+var SlatePublicContext = class {
+  constructor(input, spec2, logger, liveInvocation = null) {
+    this.spec = spec2;
+    this.logger = logger;
+    this.#input = input;
+    this.#liveInvocation = liveInvocation;
+  }
+  spec;
+  logger;
+  #input;
+  #httpTraces = [];
+  #liveInvocation;
+  #attachmentsDisabled = false;
+  #attachments = [];
+  #pendingUploads = [];
+  #uploadQueue;
+  #getUploadQueue() {
+    if (!this.#uploadQueue) {
+      this.#uploadQueue = new PQueue({ concurrency: 10 });
+    }
+    return this.#uploadQueue;
+  }
+  get specification() {
+    return this.spec;
+  }
+  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 registrationDetails() {
+    return Object.freeze(
+      this.#input.registrationDetails
+    );
+  }
+  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);
+  }
+  async addAttachment(input) {
+    if (input.type === "url") {
+      this.#attachments.push(
+        createUrlAttachment(input.url.toString(), {
+          mimeType: input.mimeType,
+          headers: input.headers,
+          query: input.query,
+          refreshReference: input.refreshReference,
+          refreshAt: input.refreshAt
+        })
+      );
+      return;
+    }
+    let content = input.content;
+    if (isBufferLike(content)) {
+      let bytes = toUint8Array(content);
+      this.#attachments.push(
+        createBase64Attachment(Buffer.from(bytes).toString("base64"), input.mimeType)
+      );
+      return;
+    }
+    let normalized = await this.#normalizeStreamInput(content, {
+      mimeType: input.mimeType,
+      filename: input.filename
+    });
+    if (!normalized) return;
+    if (!this.#liveInvocation || this.#attachmentsDisabled) {
+      let buffer = await readStreamToBuffer(normalized.stream);
+      this.#attachments.push(
+        createBase64Attachment(buffer.toString("base64"), normalized.mimeType)
+      );
+      return;
+    }
+    let live = this.#liveInvocation;
+    let task = this.#getUploadQueue().add(
+      () => uploadAttachmentDirect({
+        live,
+        mimeType: normalized.mimeType,
+        filename: normalized.filename,
+        body: normalized.stream
+      })
+    ).then((attachment) => {
+      this.#attachments.push(attachment);
+    }).catch((err) => {
+      this.#attachmentsDisabled = true;
+      this.warn({
+        message: `Attachment dropped: direct upload failed (${err instanceof Error ? err.message : String(err)}).`
+      });
+    });
+    this.#pendingUploads.push(task);
+  }
+  async #normalizeStreamInput(input, opts) {
+    if (isResponseLike(input)) {
+      if (!input.body) {
+        this.warn({ message: "Attachment dropped: response has no body." });
+        return null;
+      }
+      return {
+        stream: input.body,
+        mimeType: opts.mimeType ?? input.headers.get("content-type") ?? void 0,
+        filename: opts.filename
+      };
+    }
+    if (isReadableStream(input)) {
+      return { stream: input, mimeType: opts.mimeType, filename: opts.filename };
+    }
+    if (isNodeReadable(input)) {
+      return {
+        stream: Readable.toWeb(input),
+        mimeType: opts.mimeType,
+        filename: opts.filename
+      };
+    }
+    this.warn({ message: "Attachment dropped: unsupported attachment input type." });
+    return null;
+  }
+  async _finalizeAttachments() {
+    await Promise.allSettled(this.#pendingUploads);
+    return this.#attachments;
+  }
+  _getAuthConfigForRedaction() {
+    return void 0;
+  }
+};
+var SlateContext = class extends SlatePublicContext {
+  #config;
+  #auth;
+  constructor(config2, input, auth2, spec2, logger, liveInvocation = null) {
+    super(input, spec2, logger, liveInvocation);
+    this.#config = config2;
+    this.#auth = auth2;
+  }
+  get config() {
+    return Object.freeze(this.#config);
+  }
+  get auth() {
+    return Object.freeze(this.#auth);
+  }
+  _getAuthConfigForRedaction() {
+    return this.#auth;
+  }
+};
+
+// src/crypto/hmac.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var createHmacSignature = ({
+  secret,
+  payload,
+  algorithm = "sha256",
+  digest,
+  prefix = ""
+}) => `${prefix}${createHmac(algorithm, secret).update(payload).digest(digest)}`;
+var verifyHmacSignature = (options) => {
+  let expected = createHmacSignature(options);
+  let expectedBytes = Buffer.from(expected);
+  let signatureBytes = Buffer.from(options.signature);
+  let lengthsMatch = signatureBytes.length === expectedBytes.length;
+  let comparableSignature = lengthsMatch ? signatureBytes : Buffer.alloc(expectedBytes.length);
+  return timingSafeEqual(comparableSignature, expectedBytes) && lengthsMatch;
+};
+
+// src/file/index.ts
+var getResponseHeaderValue = (headers, name) => {
+  if (!headers) return void 0;
+  if (typeof headers.get === "function") {
+    let value = headers.get(name);
+    return typeof value === "string" ? value : void 0;
+  }
+  if (typeof headers !== "object") return void 0;
+  let lowerName = name.toLowerCase();
+  for (let [headerName, value] of Object.entries(headers)) {
+    if (headerName.toLowerCase() !== lowerName) continue;
+    if (Array.isArray(value)) {
+      let first = value.find((item) => typeof item === "string");
+      return typeof first === "string" ? first : void 0;
+    }
+    return typeof value === "string" ? value : void 0;
+  }
+  return void 0;
+};
+var getBase64ByteLength = (contentBase64) => Buffer.from(contentBase64, "base64").byteLength;
+
+// 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/object/index.ts
+var pickDefined = (value) => Object.fromEntries(
+  Object.entries(value).filter(([, child]) => child !== void 0)
+);
+var setIfDefined = (target, key, value) => {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+  return target;
+};
+
+// src/specification/slate.ts
+var Slate = class _Slate {
+  constructor(_spec, _actions, _adapters) {
+    this._spec = _spec;
+    this._actions = _actions;
+    this._adapters = _adapters;
+  }
+  _spec;
+  _actions;
+  _adapters;
+  static create(params) {
+    let adapters = params.adapters ?? [];
+    let actions = [...params.triggers, ...params.tools];
+    let seenAdapterIds = /* @__PURE__ */ new Set();
+    let seenActionKeys = new Map(actions.map((action) => [action.key, action]));
+    for (let adapter of adapters) {
+      if (seenAdapterIds.has(adapter.id)) {
+        throw new SlateDeclarationError(
+          `Adapter "${adapter.id}" is registered more than once`
+        );
+      }
+      seenAdapterIds.add(adapter.id);
+      for (let action of adapter.actions) {
+        let existing = seenActionKeys.get(action.key);
+        if (existing && existing !== action) {
+          throw new SlateDeclarationError(
+            `Adapter "${adapter.id}" action "${action.key}" conflicts with another action`
+          );
+        }
+        if (!existing) {
+          actions.push(action);
+          seenActionKeys.set(action.key, action);
+        }
+      }
+    }
+    return new _Slate(params.spec, actions, adapters);
+  }
+  get spec() {
+    return this._spec;
+  }
+  get actions() {
+    return this._actions;
+  }
+  get adapters() {
+    return this._adapters;
+  }
+};
+
+// src/specification/specification.ts
+import z2 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 : z2.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;
+  }
+  get docs() {
+    return this._params.docs;
+  }
+};
+var spec = (params) => SlateSpecification.create(params);
+
+// src/webhook/graph.ts
+var graphWebhookHttp = {
+  methods: ["POST"],
+  sync: {
+    mode: "match",
+    match: [{ hasQueryParam: "validationToken" }]
+  }
+};
+var getGraphWebhookValidationResponse = (request) => {
+  let validationToken = new URL(request.url).searchParams.get("validationToken");
+  if (validationToken === null) return null;
+  return {
+    status: 200,
+    headers: { "content-type": "text/plain" },
+    body: validationToken
+  };
+};
+
+// src/webhook/meta.ts
+var metaWebhookHttp = {
+  methods: ["GET", "POST"],
+  sync: {
+    mode: "match",
+    match: [{ method: "GET", hasQueryParam: "hub.mode" }]
+  }
+};
+var getMetaWebhookVerificationResponse = (request, expectedVerifyToken) => {
+  if (request.method !== "GET") return null;
+  let url = new URL(request.url);
+  let mode = url.searchParams.get("hub.mode");
+  let verifyToken = url.searchParams.get("hub.verify_token");
+  let challenge = url.searchParams.get("hub.challenge");
+  if (mode !== "subscribe" || challenge === null) {
+    return {
+      status: 400,
+      headers: { "content-type": "text/plain" },
+      body: "invalid webhook verification request"
+    };
+  }
+  if (expectedVerifyToken !== void 0 && verifyToken !== expectedVerifyToken) {
+    return {
+      status: 403,
+      headers: { "content-type": "text/plain" },
+      body: "invalid verify token"
+    };
+  }
+  return {
+    status: 200,
+    headers: { "content-type": "text/plain" },
+    body: challenge
+  };
+};
+export {
+  AUTH_CONFIG_SECRET_PLACEHOLDER_PREFIX,
+  AuthConfigSecretRedactor,
+  GET_FILE_URL_TOOL_ID,
+  Slate,
+  SlateAction,
+  SlateActionBuilder,
+  SlateAdapter,
+  SlateAdapterSpec,
+  SlateAuth,
+  SlateConfig,
+  SlateContext,
+  SlateDeclarationError,
+  SlateDefaultPollingIntervalSeconds,
+  SlateError,
+  SlateLogger,
+  SlatePublicContext,
+  SlatePublicTool,
+  SlateSpecification,
+  SlateTool,
+  SlateTrigger,
+  adapterSpec,
+  allOf,
+  anyOf,
+  auth,
+  axios,
+  buildApiServiceError,
+  collectApiErrorDetails,
+  config,
+  createApiServiceError,
+  createAuthenticatedAxios,
+  createAxios,
+  createBase64Attachment,
+  createHmacSignature,
+  createSlateError,
+  createTextAttachment,
+  createUrlAttachment,
+  extractApiErrorMessage,
+  getApiErrorResponse,
+  getApiErrorStatus,
+  getBase64ByteLength,
+  getCurrentContext,
+  getFileUrlTool,
+  getFileUrlToolInputSchema,
+  getFileUrlToolOutputSchema,
+  getGraphWebhookValidationResponse,
+  getMetaWebhookVerificationResponse,
+  getOAuthExpiresAtFromExpiresIn,
+  getResponseHeaderValue,
+  getServiceErrorData,
+  graphWebhookHttp,
+  inferSlateErrorFromAxios,
+  isApiErrorRecord,
+  isAxiosErrorLike,
+  isServiceErrorData,
+  mapServiceErrorCode,
+  mapServiceErrorToSlateErrorInput,
+  mergeScopes,
+  metaWebhookHttp,
+  normalizeOAuthTokenResponse,
+  pickDefined,
+  publicTool,
+  redactUrlAttachmentSecrets,
+  requestAxios,
+  requestAxiosData,
+  runWithContext,
+  scopeClause,
+  setIfDefined,
+  spec,
+  statusLabelForApiError,
+  tool,
+  trigger,
+  uploadAttachmentDirect,
+  validateScopes,
+  verifyHmacSignature
+};