@forgezero/providers 0.1.8 → 0.1.10

package/dist/email.js

@@ -38,25 +38,45 @@ function chainCredentials(...sources) {
     }
   };
 }
-function staticConfig(services) {
+function staticConfig(config) {
   const health = new Map;
   return {
     name: "static",
-    async list(serviceKey) {
-      return (services[serviceKey] ?? []).map((provider) => ({
-        ...provider,
-        health: health.get(`${serviceKey}:${provider.providerId}`) ?? provider.health
+    async provider(instanceKey) {
+      const provider = config.providers[instanceKey];
+      return provider ? { instanceKey, ...provider, config: { ...provider.config } } : undefined;
+    },
+    async list(serviceKey, methodKey) {
+      return (config.services[serviceKey]?.[methodKey] ?? []).map((attachment) => ({
+        ...attachment,
+        health: health.get(`${serviceKey}:${methodKey}:${attachment.instanceKey}:${attachment.providerMethod}`) ?? attachment.health
       }));
     },
-    async recordHealth(serviceKey, providerId, next) {
-      health.set(`${serviceKey}:${providerId}`, next);
+    async recordHealth(serviceKey, methodKey, instanceKey, providerMethod, next) {
+      health.set(`${serviceKey}:${methodKey}:${instanceKey}:${providerMethod}`, next);
     }
   };
 }
+function defineProviderMethod(method) {
+  return method;
+}
 function defineProvider(spec) {
   return spec;
 }
+function defineSingleMethodProvider(spec) {
+  const { method, invoke, classify, ...identity } = spec;
+  return defineProvider({
+    ...identity,
+    methods: { [method]: defineProviderMethod({ invoke, classify }) }
+  });
+}
 var STRIKES_TO_OFFLINE = 3;
+function serviceMethod() {
+  return Object.freeze({});
+}
+function defineService(definition) {
+  return definition;
+}
 function nextHealth(current, kind) {
   if (kind === "success")
     return { strikes: 0, status: "ok" };
@@ -71,80 +91,117 @@ function nextHealth(current, kind) {
 }
 function createRegistry(options) {
   const byId = new Map(options.providers.map((provider) => [provider.id, provider]));
-  async function call(serviceKey, args, callOptions = {}) {
-    const configured = [...await options.config.list(serviceKey)].filter((provider) => provider.enabled).sort((a, b) => a.priority - b.priority);
+  async function call(serviceKey, methodKey, args, callOptions = {}) {
+    const configured = [...await options.config.list(serviceKey, methodKey)].filter((attachment) => attachment.enabled).sort((a, b) => a.priority - b.priority);
     const attempts = [];
-    for (const entry of configured) {
+    for (const attachment of configured) {
       if (callOptions.signal?.aborted) {
         const cancelled = {
           ok: false,
+          fallbackUsed: attempts.length > 0,
           attempts,
-          error: new ProviderError("CALL_ABORTED", `The "${serviceKey}" call was cancelled.`)
+          error: new ProviderError("CALL_ABORTED", `The "${serviceKey}.${methodKey}" call was cancelled.`)
         };
-        options.after?.(cancelled);
+        await options.after?.(cancelled);
         return cancelled;
       }
-      const spec = byId.get(entry.providerId);
-      if (!spec) {
-        attempts.push({ providerId: entry.providerId, outcome: "skipped", error: "not registered" });
+      const instance = await options.config.provider(attachment.instanceKey);
+      if (!instance) {
+        attempts.push({ providerId: "unknown", instanceKey: attachment.instanceKey, providerMethod: attachment.providerMethod, outcome: "skipped", error: "instance not registered" });
+        continue;
+      }
+      const spec = byId.get(instance.providerId);
+      const method = spec?.methods[attachment.providerMethod];
+      if (!spec || !method) {
+        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, outcome: "skipped", error: !spec ? "provider not registered" : "method not supported" });
         continue;
       }
-      if (entry.health?.status === "offline") {
-        attempts.push({ providerId: entry.providerId, outcome: "skipped", error: "offline" });
+      if (!instance.enabled) {
+        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, outcome: "skipped", error: "instance disabled" });
         continue;
       }
-      options.before?.({ service: serviceKey, provider: entry.providerId });
+      if (attachment.health?.status === "offline") {
+        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, outcome: "skipped", error: "offline" });
+        continue;
+      }
+      await options.before?.({ service: serviceKey, method: methodKey, provider: instance.providerId, instance: instance.instanceKey });
+      const startedAt = performance.now();
       try {
-        const result = await spec.invoke({
-          config: entry.config,
-          secret: (field) => options.credentials.get(entry.secretRef, field),
+        const result = await method.invoke({
+          config: instance.config,
+          secret: (field) => options.credentials.get(instance.secretRef, field),
           signal: callOptions.signal
         }, args);
-        attempts.push({ providerId: entry.providerId, outcome: "sent" });
-        await options.config.recordHealth(serviceKey, entry.providerId, nextHealth(entry.health, "success"));
-        const sent = { ok: true, result, provider: entry.providerId, attempts };
-        options.after?.(sent);
+        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, outcome: "sent", durationMs: performance.now() - startedAt });
+        await options.config.recordHealth(serviceKey, methodKey, instance.instanceKey, attachment.providerMethod, nextHealth(attachment.health, "success"));
+        const sent = {
+          ok: true,
+          result,
+          provider: instance.providerId,
+          instance: instance.instanceKey,
+          method: attachment.providerMethod,
+          selected: { providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod },
+          fallbackUsed: attempts.length > 1,
+          attempts
+        };
+        await options.after?.(sent);
         return sent;
       } catch (error) {
         if (callOptions.signal?.aborted) {
           const cancelled = {
             ok: false,
+            fallbackUsed: attempts.length > 0,
             attempts,
-            error: new ProviderError("CALL_ABORTED", `The "${serviceKey}" call was cancelled.`)
+            error: new ProviderError("CALL_ABORTED", `The "${serviceKey}.${methodKey}" call was cancelled.`)
           };
-          options.after?.(cancelled);
+          await options.after?.(cancelled);
           return cancelled;
         }
-        const kind = spec.classify(error);
+        const kind = method.classify(error);
+        const message = error instanceof Error ? error.message : String(error);
+        const code = error instanceof ProviderError ? error.code : typeof error?.code === "string" ? error.code : undefined;
         attempts.push({
-          providerId: entry.providerId,
+          providerId: instance.providerId,
+          instanceKey: instance.instanceKey,
+          providerMethod: attachment.providerMethod,
           outcome: "failed",
           kind,
-          error: error instanceof Error ? error.message : String(error)
+          durationMs: performance.now() - startedAt,
+          failure: { kind, ...code ? { code } : {}, message },
+          error: message
         });
-        await options.config.recordHealth(serviceKey, entry.providerId, nextHealth(entry.health, kind));
+        await options.config.recordHealth(serviceKey, methodKey, instance.instanceKey, attachment.providerMethod, nextHealth(attachment.health, kind));
         if (kind === "terminal") {
           const refused = {
             ok: false,
+            fallbackUsed: attempts.length > 1,
             attempts,
             error: new ProviderError("PAYLOAD_REJECTED", "The request was refused as malformed; no provider will accept it.")
           };
-          options.after?.(refused);
+          await options.after?.(refused);
           return refused;
         }
       }
     }
     const failed = {
       ok: false,
+      fallbackUsed: attempts.length > 1,
       attempts,
-      error: new ProviderError(attempts.length === 0 ? "NO_PROVIDER" : "ALL_PROVIDERS_FAILED", attempts.length === 0 ? `No provider is configured for "${serviceKey}".` : `Every provider for "${serviceKey}" failed or was skipped.`)
+      error: new ProviderError(attempts.length === 0 ? "NO_PROVIDER" : "ALL_PROVIDERS_FAILED", attempts.length === 0 ? `No provider method is configured for "${serviceKey}.${methodKey}".` : `Every provider method for "${serviceKey}.${methodKey}" failed or was skipped.`)
     };
-    options.after?.(failed);
+    await options.after?.(failed);
     return failed;
   }
-  return { call };
+  function service(definition) {
+    return {
+      call(method, args, callOptions) {
+        return call(definition.key, method, args, callOptions);
+      }
+    };
+  }
+  return { call, service };
 }
-var VERSION = "0.1.8";
+var VERSION = "0.1.10";
 
 // src/email.ts
 var recipients = (to) => Array.isArray(to) ? [...to] : [to];
@@ -156,31 +213,28 @@ function assertMessage(message) {
     throw new ProviderError("EMAIL_NO_BODY", "An email needs html, text, or both.");
   }
 }
-var jetemail = defineProvider({
-  id: "jetemail",
-  service: "email",
-  label: "JetEmail",
-  credentials: {
-    type: "object",
-    additionalProperties: false,
-    required: ["apiKey"],
-    properties: {
-      apiKey: {
-        type: "string",
-        title: "API key",
-        writeOnly: true,
-        description: "Transactional key from the JetEmail dashboard."
-      }
+var jetemailCredentials = {
+  type: "object",
+  additionalProperties: false,
+  required: ["apiKey"],
+  properties: {
+    apiKey: {
+      type: "string",
+      title: "API key",
+      writeOnly: true,
+      description: "Transactional key from the JetEmail dashboard."
     }
-  },
-  config: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      eu: { type: "boolean", default: false, title: "EU residency" },
-      from: { type: "string", format: "email", title: "Default from address" }
-    }
-  },
+  }
+};
+var jetemailConfig = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    eu: { type: "boolean", default: false, title: "EU residency" },
+    from: { type: "string", format: "email", title: "Default from address" }
+  }
+};
+var jetemailSend = defineProviderMethod({
   async invoke(context, message) {
     assertMessage(message);
     const config = context.config;
@@ -191,7 +245,8 @@ var jetemail = defineProvider({
       signal: context.signal,
       headers: {
         "content-type": "application/json",
-        authorization: `Bearer ${await context.secret("apiKey")}`
+        authorization: `Bearer ${await context.secret("apiKey")}`,
+        ...message.idempotencyKey ? { "idempotency-key": message.idempotencyKey } : {}
       },
       body: JSON.stringify({
         from: message.from ?? config.from,
@@ -222,35 +277,78 @@ var jetemail = defineProvider({
     return "retryable";
   }
 });
-var smtp = defineProvider({
-  id: "smtp",
-  service: "email",
-  label: "SMTP",
-  multiInstance: true,
-  credentials: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      user: { type: "string", title: "Username" },
-      password: { type: "string", title: "Password", writeOnly: true }
-    }
-  },
-  config: {
-    type: "object",
-    additionalProperties: false,
-    required: ["host", "from"],
-    properties: {
-      host: { type: "string", title: "Host" },
-      port: { type: "integer", default: 587, minimum: 1, maximum: 65535 },
-      secure: {
-        type: "boolean",
-        default: false,
-        title: "Implicit TLS",
-        description: "True for port 465. Port 587 upgrades with STARTTLS and should stay false."
+function assertBatch(batch) {
+  if (!Array.isArray(batch.emails) || batch.emails.length < 1 || batch.emails.length > 100) {
+    throw new ProviderError("EMAIL_BATCH_SIZE", "An email batch must contain between 1 and 100 messages.");
+  }
+  for (const message of batch.emails)
+    assertMessage(message);
+}
+var jetemailSendBatch = defineProviderMethod({
+  async invoke(context, batch) {
+    assertBatch(batch);
+    const config = context.config;
+    const doFetch = config.fetch ?? globalThis.fetch;
+    const response = await doFetch(config.batchEndpoint ?? "https://api.jetemail.com/email-batch", {
+      method: "POST",
+      signal: context.signal,
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${await context.secret("apiKey")}`
       },
-      from: { type: "string", format: "email", title: "From address" }
+      body: JSON.stringify({
+        emails: batch.emails.map((message) => ({
+          from: message.from ?? config.from,
+          to: recipients(message.to),
+          subject: message.subject,
+          html: message.html,
+          text: message.text,
+          reply_to: message.replyTo,
+          eu: config.eu ?? false
+        }))
+      })
+    });
+    if (response.status !== 207) {
+      const detail = await response.text().catch(() => "");
+      throw Object.assign(new Error(`JetEmail batch ${response.status}: ${detail.slice(0, 200)}`), {
+        status: response.status,
+        retryAfter: response.headers.get("retry-after")
+      });
+    }
+    const payload = await response.json().catch(() => null);
+    if (!payload?.summary || !Array.isArray(payload.results) || ![payload.summary.total, payload.summary.successful, payload.summary.failed].every((value) => Number.isInteger(value) && value >= 0)) {
+      throw new ProviderError("JETEMAIL_BATCH_RESPONSE", "JetEmail returned a malformed batch response.");
     }
+    const summary = payload.summary;
+    if (summary.total !== batch.emails.length || summary.successful + summary.failed !== summary.total) {
+      throw new ProviderError("JETEMAIL_BATCH_RESPONSE", "JetEmail batch totals do not match the request.");
+    }
+    const results = payload.results.map((item) => {
+      if (!item || typeof item !== "object")
+        return { status: "failed", error: "Malformed provider result" };
+      const row = item;
+      return {
+        status: row.status === "success" ? "success" : "failed",
+        ...typeof row.id === "string" ? { id: row.id } : {},
+        ...typeof row.response === "string" ? { response: row.response.slice(0, 500) } : {},
+        ...typeof row.error === "string" ? { error: row.error.slice(0, 500) } : {}
+      };
+    });
+    return { summary, results };
   },
+  classify: jetemailSend.classify
+});
+var jetemail = defineProvider({
+  id: "jetemail",
+  label: "JetEmail",
+  credentials: jetemailCredentials,
+  config: jetemailConfig,
+  methods: {
+    send: jetemailSend,
+    sendBatch: jetemailSendBatch
+  }
+});
+var smtpSend = defineProviderMethod({
   async invoke(context, message) {
     assertMessage(message);
     const config = context.config;
@@ -289,9 +387,47 @@ var smtp = defineProvider({
     return "retryable";
   }
 });
+var smtp = defineProvider({
+  id: "smtp",
+  label: "SMTP",
+  multiInstance: true,
+  credentials: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      user: { type: "string", title: "Username" },
+      password: { type: "string", title: "Password", writeOnly: true }
+    }
+  },
+  config: {
+    type: "object",
+    additionalProperties: false,
+    required: ["host", "from"],
+    properties: {
+      host: { type: "string", title: "Host" },
+      port: { type: "integer", default: 587, minimum: 1, maximum: 65535 },
+      secure: {
+        type: "boolean",
+        default: false,
+        title: "Implicit TLS",
+        description: "True for port 465. Port 587 upgrades with STARTTLS and should stay false."
+      },
+      from: { type: "string", format: "email", title: "From address" }
+    }
+  },
+  methods: { send: smtpSend }
+});
 var emailProviders = [jetemail, smtp];
+var emailService = defineService({
+  key: "email",
+  methods: {
+    send: serviceMethod(),
+    sendBatch: serviceMethod()
+  }
+});
 export {
   smtp,
   jetemail,
+  emailService,
   emailProviders
 };

package/dist/http.d.ts

@@ -93,8 +93,8 @@ export type HttpClient = ReturnType<typeof createHttpClient>;
  * `classify` is where the venue-specific knowledge lives, and it is the part
  * that decides whether a retry helps or makes things worse.
  */
-export declare const http: import("./index").ProviderSpec<HttpRequest, HttpResponse<unknown>>;
+export declare const http: import("./index").ProviderDefinition<Record<"request", import("./index").ProviderMethodSpec<HttpRequest, HttpResponse<unknown>>>>;
 /** Binance reports a running total for the window, not a per-call cost. */
 export declare const binanceWeight: (response: Response) => number | undefined;
-export declare const httpProviders: readonly [import("./index").ProviderSpec<HttpRequest, HttpResponse<unknown>>];
+export declare const httpProviders: readonly [import("./index").ProviderDefinition<Record<"request", import("./index").ProviderMethodSpec<HttpRequest, HttpResponse<unknown>>>>];
 export {};

package/dist/http.js

@@ -38,25 +38,45 @@ function chainCredentials(...sources) {
     }
   };
 }
-function staticConfig(services) {
+function staticConfig(config) {
   const health = new Map;
   return {
     name: "static",
-    async list(serviceKey) {
-      return (services[serviceKey] ?? []).map((provider) => ({
-        ...provider,
-        health: health.get(`${serviceKey}:${provider.providerId}`) ?? provider.health
+    async provider(instanceKey) {
+      const provider = config.providers[instanceKey];
+      return provider ? { instanceKey, ...provider, config: { ...provider.config } } : undefined;
+    },
+    async list(serviceKey, methodKey) {
+      return (config.services[serviceKey]?.[methodKey] ?? []).map((attachment) => ({
+        ...attachment,
+        health: health.get(`${serviceKey}:${methodKey}:${attachment.instanceKey}:${attachment.providerMethod}`) ?? attachment.health
       }));
     },
-    async recordHealth(serviceKey, providerId, next) {
-      health.set(`${serviceKey}:${providerId}`, next);
+    async recordHealth(serviceKey, methodKey, instanceKey, providerMethod, next) {
+      health.set(`${serviceKey}:${methodKey}:${instanceKey}:${providerMethod}`, next);
     }
   };
 }
+function defineProviderMethod(method) {
+  return method;
+}
 function defineProvider(spec) {
   return spec;
 }
+function defineSingleMethodProvider(spec) {
+  const { method, invoke, classify, ...identity } = spec;
+  return defineProvider({
+    ...identity,
+    methods: { [method]: defineProviderMethod({ invoke, classify }) }
+  });
+}
 var STRIKES_TO_OFFLINE = 3;
+function serviceMethod() {
+  return Object.freeze({});
+}
+function defineService(definition) {
+  return definition;
+}
 function nextHealth(current, kind) {
   if (kind === "success")
     return { strikes: 0, status: "ok" };
@@ -71,80 +91,117 @@ function nextHealth(current, kind) {
 }
 function createRegistry(options) {
   const byId = new Map(options.providers.map((provider) => [provider.id, provider]));
-  async function call(serviceKey, args, callOptions = {}) {
-    const configured = [...await options.config.list(serviceKey)].filter((provider) => provider.enabled).sort((a, b) => a.priority - b.priority);
+  async function call(serviceKey, methodKey, args, callOptions = {}) {
+    const configured = [...await options.config.list(serviceKey, methodKey)].filter((attachment) => attachment.enabled).sort((a, b) => a.priority - b.priority);
     const attempts = [];
-    for (const entry of configured) {
+    for (const attachment of configured) {
       if (callOptions.signal?.aborted) {
         const cancelled = {
           ok: false,
+          fallbackUsed: attempts.length > 0,
           attempts,
-          error: new ProviderError("CALL_ABORTED", `The "${serviceKey}" call was cancelled.`)
+          error: new ProviderError("CALL_ABORTED", `The "${serviceKey}.${methodKey}" call was cancelled.`)
         };
-        options.after?.(cancelled);
+        await options.after?.(cancelled);
         return cancelled;
       }
-      const spec = byId.get(entry.providerId);
-      if (!spec) {
-        attempts.push({ providerId: entry.providerId, outcome: "skipped", error: "not registered" });
+      const instance = await options.config.provider(attachment.instanceKey);
+      if (!instance) {
+        attempts.push({ providerId: "unknown", instanceKey: attachment.instanceKey, providerMethod: attachment.providerMethod, outcome: "skipped", error: "instance not registered" });
+        continue;
+      }
+      const spec = byId.get(instance.providerId);
+      const method = spec?.methods[attachment.providerMethod];
+      if (!spec || !method) {
+        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, outcome: "skipped", error: !spec ? "provider not registered" : "method not supported" });
         continue;
       }
-      if (entry.health?.status === "offline") {
-        attempts.push({ providerId: entry.providerId, outcome: "skipped", error: "offline" });
+      if (!instance.enabled) {
+        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, outcome: "skipped", error: "instance disabled" });
         continue;
       }
-      options.before?.({ service: serviceKey, provider: entry.providerId });
+      if (attachment.health?.status === "offline") {
+        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, outcome: "skipped", error: "offline" });
+        continue;
+      }
+      await options.before?.({ service: serviceKey, method: methodKey, provider: instance.providerId, instance: instance.instanceKey });
+      const startedAt = performance.now();
       try {
-        const result = await spec.invoke({
-          config: entry.config,
-          secret: (field) => options.credentials.get(entry.secretRef, field),
+        const result = await method.invoke({
+          config: instance.config,
+          secret: (field) => options.credentials.get(instance.secretRef, field),
           signal: callOptions.signal
         }, args);
-        attempts.push({ providerId: entry.providerId, outcome: "sent" });
-        await options.config.recordHealth(serviceKey, entry.providerId, nextHealth(entry.health, "success"));
-        const sent = { ok: true, result, provider: entry.providerId, attempts };
-        options.after?.(sent);
+        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, outcome: "sent", durationMs: performance.now() - startedAt });
+        await options.config.recordHealth(serviceKey, methodKey, instance.instanceKey, attachment.providerMethod, nextHealth(attachment.health, "success"));
+        const sent = {
+          ok: true,
+          result,
+          provider: instance.providerId,
+          instance: instance.instanceKey,
+          method: attachment.providerMethod,
+          selected: { providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod },
+          fallbackUsed: attempts.length > 1,
+          attempts
+        };
+        await options.after?.(sent);
         return sent;
       } catch (error) {
         if (callOptions.signal?.aborted) {
           const cancelled = {
             ok: false,
+            fallbackUsed: attempts.length > 0,
             attempts,
-            error: new ProviderError("CALL_ABORTED", `The "${serviceKey}" call was cancelled.`)
+            error: new ProviderError("CALL_ABORTED", `The "${serviceKey}.${methodKey}" call was cancelled.`)
           };
-          options.after?.(cancelled);
+          await options.after?.(cancelled);
           return cancelled;
         }
-        const kind = spec.classify(error);
+        const kind = method.classify(error);
+        const message = error instanceof Error ? error.message : String(error);
+        const code = error instanceof ProviderError ? error.code : typeof error?.code === "string" ? error.code : undefined;
         attempts.push({
-          providerId: entry.providerId,
+          providerId: instance.providerId,
+          instanceKey: instance.instanceKey,
+          providerMethod: attachment.providerMethod,
           outcome: "failed",
           kind,
-          error: error instanceof Error ? error.message : String(error)
+          durationMs: performance.now() - startedAt,
+          failure: { kind, ...code ? { code } : {}, message },
+          error: message
         });
-        await options.config.recordHealth(serviceKey, entry.providerId, nextHealth(entry.health, kind));
+        await options.config.recordHealth(serviceKey, methodKey, instance.instanceKey, attachment.providerMethod, nextHealth(attachment.health, kind));
         if (kind === "terminal") {
           const refused = {
             ok: false,
+            fallbackUsed: attempts.length > 1,
             attempts,
             error: new ProviderError("PAYLOAD_REJECTED", "The request was refused as malformed; no provider will accept it.")
           };
-          options.after?.(refused);
+          await options.after?.(refused);
           return refused;
         }
       }
     }
     const failed = {
       ok: false,
+      fallbackUsed: attempts.length > 1,
       attempts,
-      error: new ProviderError(attempts.length === 0 ? "NO_PROVIDER" : "ALL_PROVIDERS_FAILED", attempts.length === 0 ? `No provider is configured for "${serviceKey}".` : `Every provider for "${serviceKey}" failed or was skipped.`)
+      error: new ProviderError(attempts.length === 0 ? "NO_PROVIDER" : "ALL_PROVIDERS_FAILED", attempts.length === 0 ? `No provider method is configured for "${serviceKey}.${methodKey}".` : `Every provider method for "${serviceKey}.${methodKey}" failed or was skipped.`)
     };
-    options.after?.(failed);
+    await options.after?.(failed);
     return failed;
   }
-  return { call };
+  function service(definition) {
+    return {
+      call(method, args, callOptions) {
+        return call(definition.key, method, args, callOptions);
+      }
+    };
+  }
+  return { call, service };
 }
-var VERSION = "0.1.8";
+var VERSION = "0.1.10";
 
 // src/http.ts
 class BudgetExhausted extends ProviderError {
@@ -227,9 +284,9 @@ function createHttpClient(config) {
     budget: () => budgetState(config.budget.host)
   };
 }
-var http = defineProvider({
+var http = defineSingleMethodProvider({
   id: "http",
-  service: "http",
+  method: "request",
   label: "HTTP",
   multiInstance: true,
   credentials: {