@forgezero/providers 0.1.9 → 0.1.11

package/README.md

@@ -1,77 +1,262 @@
+<!--
+  GENERATED FILE — do not edit.
+
+  Change scripts/generate-guides.ts or its typed sources, run `bun run guides`,
+  and commit the generator and rendered files together.
+-->
+
 # @forgezero/providers
 
-**One service, several vendors, automatic failover — and a registry that knows
-which failures are worth retrying.**
+Send through whichever provider is up. Priority and failover, reordered live.
+
+## Global package root and supported runtimes
+
+Anyone calling somebody else's API who needs the failure classified rather than guessed. Provider capabilities stay independent from application-owned services, which attach named methods by priority with health tracking. Supported runtimes: bun, node, workers, deno. The global base/root import is @forgezero/providers. Every public import or command is listed below; the documentation inventory is checked in both directions against package.json exports.
+
+```text
+import * as root from '@forgezero/providers';
+```
 
-You declare a service (`email`, `chain`, `storage`) and the providers that can
-serve it, in priority order. Calls try them in turn. Where the credentials come
-from is yours: environment variables in development, a vault in production,
-nothing changes in your code.
+## Commands
 
-Zero runtime dependencies. Bun, Node 18+, Deno, Cloudflare Workers — anywhere
-`fetch` and Web Crypto exist.
+bun add @forgezero/providers @forgezero/vault — Install provider/service routing and the optional ForgeZero Vault credential adapter.
+bun test — Run the consumer project tests containing provider failure and fallback cases.
 
-```bash
-bun add @forgezero/providers
+```text
+bun add @forgezero/providers @forgezero/vault
+bun test
 ```
 
-```ts
-import { createRegistry, envCredentials, staticConfig } from '@forgezero/providers';
-import { jetemail, smtp } from '@forgezero/providers/email';
+## @forgezero/providers
+
+The registry: priority, health, and a terminal-versus-retryable verdict per failure.
+
+```text
+import * as api from '@forgezero/providers';
+```
+
+## @forgezero/providers/email
+
+JetEmail (`send`, `sendBatch`), SMTP (`send` only), and the typed email service contract; SMTP transport is injected.
+
+```text
+import * as api from '@forgezero/providers/email';
+```
+
+## @forgezero/providers/database
+
+ArangoDB in the registry for credential rotation and health — with failover off by default.
+
+```text
+import * as api from '@forgezero/providers/database';
+```
+
+## @forgezero/providers/http
+
+Outbound HTTP with a per-host weight budget reserved before the call and settled from the response.
+
+```text
+import * as api from '@forgezero/providers/http';
+```
+
+## @forgezero/providers/pool
+
+Which outbound address a request leaves by, sticky per key, over the same budget as everything else.
+
+```text
+import * as api from '@forgezero/providers/pool';
+```
+
+## @forgezero/providers/chain
+
+An EVM node behind the same failover as any other service: read logs, broadcast, and never stop scanning because one endpoint rate-limited.
+
+```text
+import * as api from '@forgezero/providers/chain';
+```
+
+## @forgezero/providers/binance
+
+Binance behind the venue adapter: three hosts, one weight budget, signed over the exact string that is sent.
+
+```text
+import * as api from '@forgezero/providers/binance';
+```
+
+## @forgezero/providers/storage
+
+S3-compatible object storage, SigV4 signed with Web Crypto and no vendor SDK.
+
+```text
+import * as api from '@forgezero/providers/storage';
+```
+
+## @forgezero/providers/translation
+
+Google AI Studio translation with strict batch alignment and classified quota failures.
+
+```text
+import * as api from '@forgezero/providers/translation';
+```
 
-const services = createRegistry({
-  credentials: envCredentials(process.env),   // or vaultCredentials(fz)
-  config: staticConfig({
-    email: [
-      { providerId: 'jetemail', priority: 1, enabled: true, secretRef: 'jetemail', config: {} },
-      { providerId: 'smtp',     priority: 2, enabled: true, secretRef: 'smtp',     config: {} }
-    ]
-  }),
-  providers: [jetemail, smtp]
+## @forgezero/providers/realtime
+
+Cloudflare KV node-directory and Durable Object fan-out clients for project-defined realtime services.
+
+```text
+import * as api from '@forgezero/providers/realtime';
+```
+
+## Email with ordered provider fallback
+
+The service owns send/sendBatch. Attach provider methods directly in priority arrays; SMTP is never presented as batch-capable.
+
+```text
+import { createService } from '@forgezero/providers';
+import { emailService, jetemail, smtp } from '@forgezero/providers/email';
+import { createVault } from '@forgezero/vault';
+import { vaultCredentials } from '@forgezero/vault/providers';
+
+const vault = createVault({ project: 'my-project', environment: 'production' });
+const email = createService(emailService, {
+  send: [
+    { provider: jetemail, method: 'send', credentials: vaultCredentials(vault, 'jetemail'), config: { from: 'ops@example.com' }, priority: 1 },
+    { provider: smtp, method: 'send', credentials: vaultCredentials(vault, 'smtp'), config: { host: 'smtp.example.com', port: 587, from: 'ops@example.com', transport }, priority: 2 }
+  ],
+  sendBatch: [
+    { provider: jetemail, method: 'sendBatch', credentials: vaultCredentials(vault, 'jetemail'), config: { from: 'ops@example.com' }, priority: 1 }
+  ]
+});
+
+const outcome = await email.call('send', message);
+```
+
+## Extend with a custom provider and service
+
+Public consumers define provider capabilities and application services independently, then attach them with the same ordered-array API.
+
+```text
+const postmark = defineProvider({
+  id: 'postmark', label: 'Postmark',
+  methods: { deliver: defineProviderMethod({ invoke, classify }) }
+});
+const notifications = defineService({
+  key: 'notifications', methods: { deliver: serviceMethod<Notice, Receipt>() }
+});
+const service = createService(notifications, {
+  deliver: [{ provider: postmark, method: 'deliver', credentials: vaultCredentials(vault, 'postmark'), priority: 1 }]
 });
+```
+
+## Vault first, systemd credential fallback
+
+Bootstrap tries the scoped Vault entry first and the identically named systemd credential second. If neither exists, the provider call fails.
+
+```text
+const credentials = chainScopedCredentials(
+  vaultCredentials(vault, 'jetemail'),
+  scopeCredentials(systemdCredentials({
+    nameFor: (reference, field) => `${reference}-${field}`
+  }), 'jetemail')
+);
+```
 
-const controller = new AbortController();
-await services.call('email', { to, subject, html }, { signal: controller.signal });
-// JetEmail first, then SMTP. Abort stops the chain and reaches provider I/O.
+## Built-in provider capabilities
+
+A provider owns capabilities; it does not own a service. A service method attaches a provider instance and one of its methods. This keeps custom providers and custom services independent.
+
+```text
+evm-rpc              request
+jetemail             send, sendBatch
+smtp                 send
+arangodb             query
+http                 request
+s3                   request
+google-ai-studio     translate
+```
+
+## EVM JSON-RPC node (evm-rpc)
+
+Import: @forgezero/providers/chain. Methods: request. Credential fields: url, bearer. Nonsecret config: chainId, maxLogRange, timeoutMs. Several endpoints per chain is the normal case, not a luxury: public RPC is rate-limited and paid gateways have outages, and a scanner that stops when one is down stops crediting deposits while the money sits on the chain. "Already known" and "nonce too low" are TERMINAL — the transaction is already in flight, so rebroadcasting through another node is how a sweep gets sent twice.
+
+```text
+importPath: '@forgezero/providers/chain'
+providerId: 'evm-rpc'
+methods: request
+credentials: url, bearer
+config: chainId, maxLogRange, timeoutMs
+```
+
+## JetEmail (jetemail)
+
+Import: @forgezero/providers/email. Methods: send, sendBatch. Credential fields: apiKey. Nonsecret config: eu, from. A 401 is RETRYABLE at the loop level — that key is bad, the next provider's may not be. Treating any 4xx as fatal is what loses the fallback.
+
+```text
+importPath: '@forgezero/providers/email'
+providerId: 'jetemail'
+methods: send, sendBatch
+credentials: apiKey
+config: eu, from
 ```
 
-## Why a 400 stops the loop and a 401 does not
+## SMTP (smtp)
 
-This is the whole reason the package exists. Every failure is classified before
-the loop decides what to do:
+Import: @forgezero/providers/email. Methods: send. Credential fields: user, password. Nonsecret config: host, port, secure, from, transport. Any number of named relays, each with its own priority slot. Also the bootstrap path: the vault opens after a ceremony, and the ceremony needs mail.
 
-| verdict | meaning | what happens |
-|---|---|---|
-| `terminal` | the request itself is wrong — a 400, a malformed address | **stop.** Every other provider will reject it too |
-| `retryable` | this vendor failed — a 401, a 500, a dropped socket | try the next one. Their key being bad says nothing about the next key |
-| `backoff` | rate limited — a 429 with `Retry-After` | wait, then continue |
+```text
+importPath: '@forgezero/providers/email'
+providerId: 'smtp'
+methods: send
+credentials: user, password
+config: host, port, secure, from, transport
+```
+
+## ArangoDB (arangodb)
+
+Import: @forgezero/providers/database. Methods: query. Credential fields: password. Nonsecret config: url, urls, readPreferredUrls, readPreferredFallback, clusterId, database, username. Failover is OFF by default. Writing to a different database because the first was slow is data loss with extra steps; this is here for credential rotation and health.
+
+```text
+importPath: '@forgezero/providers/database'
+providerId: 'arangodb'
+methods: query
+credentials: password
+config: url, urls, readPreferredUrls, readPreferredFallback, clusterId, database, username
+```
 
-A registry that retries a 400 across five vendors sends five identical rejections
-and reports "all providers down". A registry that gives up on a 401 takes your
-whole service offline because one API key expired.
+## HTTP (http)
 
-## Health that reflects reality
+Import: @forgezero/providers/http. Methods: request. Credential fields: apiKey, apiSecret. Nonsecret config: baseUrl, limit, windowMs, headroom. 418 and 429 back off rather than falling through. 418 is a venue saying "you ignored a 429 and are now banned", and hammering makes the ban longer.
 
-Missing is healthy. One or two failures is **degraded** — still attempted, amber
-in a dashboard. Three is **offline** — skipped entirely until a success clears
-it. A provider disabled by configuration never counts against health, because a
-vendor you turned off is not a vendor that is failing.
+```text
+importPath: '@forgezero/providers/http'
+providerId: 'http'
+methods: request
+credentials: apiKey, apiSecret
+config: baseUrl, limit, windowMs, headroom
+```
+
+## S3-compatible storage (s3)
 
-## Subpaths
+Import: @forgezero/providers/storage. Methods: request. Credential fields: accessKeyId, secretAccessKey, sessionToken. Nonsecret config: endpoint, region, bucket, addressing. A 403 is retryable because on S3 it usually means this key lacks a permission, not that the key is invalid. Works against AWS, R2, MinIO, Garage and Backblaze — path-style addressing by default, because that is what everything except AWS expects.
 
-| import | what it is |
-|---|---|
-| `@forgezero/providers` | the registry, `defineProvider`, `classify`, health |
-| `/email` | JetEmail and SMTP behind one `email` service |
-| `/chain` | an EVM JSON-RPC node behind the same failover — logs, balance, broadcast |
-| `/database` | ArangoDB, for credential rotation and health |
-| `/http` | outbound HTTP with a per-host weight budget reserved before the call |
-| `/pool` | which outbound address a request leaves by, sticky per key |
-| `/storage` | S3-compatible object storage, SigV4 signed with Web Crypto, no vendor SDK |
+```text
+importPath: '@forgezero/providers/storage'
+providerId: 's3'
+methods: request
+credentials: accessKeyId, secretAccessKey, sessionToken
+config: endpoint, region, bucket, addressing
+```
 
-Full documentation: **https://www.forgezero.net/docs/providers**
+## Google AI Studio (google-ai-studio)
 
-## Licence
+Import: @forgezero/providers/translation. Methods: translate. Credential fields: apiKey. Nonsecret config: model. Machine translation for a tenant that wants it — ForgeZero translates nothing at runtime. Chosen as the first adapter because the free tier needs no billing account, so the feature can be tried without a procurement conversation. A 429 is a BACKOFF rather than a failure: on the free tier it is expected traffic, and treating it as terminal abandons a catalogue most of the way through. A short answer is terminal, because one translation missing from a batch shifts every later string onto the wrong source and nothing about the result looks broken afterwards.
+
+```text
+importPath: '@forgezero/providers/translation'
+providerId: 'google-ai-studio'
+methods: translate
+credentials: apiKey
+config: model
+```
 
-MIT. Part of [ForgeZero](https://www.forgezero.net) — secrets, attested compute and
-deploys — and usable entirely on its own, with no ForgeZero account.
+Full rendered documentation: https://www.forgezero.net/docs/providers

package/dist/binance.js

@@ -38,25 +38,71 @@ function chainCredentials(...sources) {
     }
   };
 }
-function staticConfig(services) {
+function scopeCredentials(source, reference) {
+  return {
+    name: `${source.name}:${reference}`,
+    get: (field) => source.get(reference, field)
+  };
+}
+function chainScopedCredentials(...sources) {
+  return {
+    name: sources.map((source) => source.name).join("+"),
+    async get(field) {
+      let last;
+      for (const source of sources) {
+        try {
+          return await source.get(field);
+        } catch (error) {
+          last = error;
+        }
+      }
+      throw last instanceof Error ? last : new ProviderError("CREDENTIAL_MISSING", `No scoped source held field "${field}".`);
+    }
+  };
+}
+function staticConfig(config) {
+  const providers = new Map(config.providers.map((provider) => [provider.instanceKey, provider]));
+  if (providers.size !== config.providers.length) {
+    throw new ProviderError("CONFIG_DUPLICATE_INSTANCE", "Provider instance keys must be unique.");
+  }
   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 = providers.get(instanceKey);
+      return provider ? { ...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 +117,188 @@ 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;
       }
-      if (entry.health?.status === "offline") {
-        attempts.push({ providerId: entry.providerId, outcome: "skipped", error: "offline" });
+      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;
       }
-      options.before?.({ service: serviceKey, provider: entry.providerId });
+      if (!instance.enabled) {
+        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, outcome: "skipped", error: "instance disabled" });
+        continue;
+      }
+      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 };
+}
+function createService(definition, methods, options = {}) {
+  const providers = new Map;
+  const credentials = new Map;
+  const instances = [];
+  const serviceMethods = {};
+  for (const methodKey of Object.keys(definition.methods)) {
+    const attachments = methods[methodKey];
+    if (!Array.isArray(attachments)) {
+      throw new ProviderError("CONFIG_METHOD_MISSING", `Service method "${definition.key}.${methodKey}" needs an attachment array.`);
+    }
+    const priorities = new Set;
+    serviceMethods[methodKey] = attachments.map((attachment, index) => {
+      if (!Number.isInteger(attachment.priority) || attachment.priority < 1 || attachment.priority > 1000) {
+        throw new ProviderError("CONFIG_PRIORITY", `Priority for "${definition.key}.${methodKey}" must be an integer from 1 to 1000.`);
+      }
+      if (priorities.has(attachment.priority)) {
+        throw new ProviderError("CONFIG_PRIORITY_DUPLICATE", `Priorities for "${definition.key}.${methodKey}" must be unique.`);
+      }
+      priorities.add(attachment.priority);
+      if (!attachment.provider.methods[attachment.method]) {
+        throw new ProviderError("CONFIG_METHOD_UNSUPPORTED", `Provider "${attachment.provider.id}" does not support "${attachment.method}".`);
+      }
+      const existing = providers.get(attachment.provider.id);
+      if (existing && existing !== attachment.provider) {
+        throw new ProviderError("CONFIG_PROVIDER_DUPLICATE", `Provider id "${attachment.provider.id}" has more than one definition.`);
+      }
+      providers.set(attachment.provider.id, attachment.provider);
+      const internalKey = `${definition.key}:${methodKey}:${index}`;
+      credentials.set(internalKey, attachment.credentials);
+      instances.push({
+        instanceKey: internalKey,
+        providerId: attachment.provider.id,
+        enabled: attachment.enabled ?? true,
+        config: { ...attachment.config ?? {} },
+        secretRef: internalKey
+      });
+      return {
+        instanceKey: internalKey,
+        providerMethod: attachment.method,
+        priority: attachment.priority,
+        enabled: attachment.enabled ?? true
+      };
+    });
+  }
+  const registry = createRegistry({
+    providers: [...providers.values()],
+    config: staticConfig({ providers: instances, services: { [definition.key]: serviceMethods } }),
+    credentials: {
+      name: [...new Set([...credentials.values()].map((source) => source.name))].join("+"),
+      async get(reference, field) {
+        const source = credentials.get(reference);
+        if (!source)
+          throw new ProviderError("CREDENTIAL_SOURCE_MISSING", "The provider credential source is unavailable.");
+        return source.get(field);
+      }
+    },
+    ...options
+  });
+  const dynamic = registry.service(definition);
+  return {
+    async call(method, args, callOptions) {
+      const result = await dynamic.call(method, args, callOptions);
+      const { instance: _instance, selected, attempts, ...rest } = result;
+      return {
+        ...rest,
+        ...selected ? { selected: { providerId: selected.providerId, providerMethod: selected.providerMethod } } : {},
+        attempts: attempts.map(({ instanceKey: _instanceKey, ...attempt }) => attempt)
+      };
+    }
+  };
 }
-var VERSION = "0.1.9";
+var VERSION = "0.1.11";
 
 // src/http.ts
 class BudgetExhausted extends ProviderError {
@@ -227,9 +381,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: {

package/dist/chain.d.ts

@@ -96,4 +96,4 @@ export type ChainResult = {
     op: 'receipt';
     receipt: ChainReceipt | null;
 };
-export declare const evmRpc: import("./index").ProviderSpec<ChainCall, ChainResult>;
+export declare const evmRpc: import("./index").ProviderDefinition<Record<"request", import("./index").ProviderMethodSpec<ChainCall, ChainResult>>>;