@dxos/functions 0.8.4-main.5acf9ea → 0.8.4-main.5ea62a8

package/package.json

@@ -1,37 +1,37 @@
 {
   "name": "@dxos/functions",
-  "version": "0.8.4-main.5acf9ea",
+  "version": "0.8.4-main.5ea62a8",
   "description": "Functions API and runtime.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "license": "MIT",
   "author": "info@dxos.org",
-  "sideEffects": true,
+  "sideEffects": false,
   "type": "module",
   "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/types/src/index.d.ts",
+      "browser": "./dist/lib/browser/index.mjs",
+      "node": "./dist/lib/node-esm/index.mjs"
+    },
     "./bundler": {
+      "source": "./src/bundler/index.ts",
       "types": "./dist/types/src/bundler/index.d.ts",
       "browser": "./dist/lib/browser/bundler/index.mjs",
-      "node": "./dist/lib/node-esm/bundler/index.mjs",
-      "source": "./src/bundler/index.ts"
+      "node": "./dist/lib/node-esm/bundler/index.mjs"
     },
     "./edge": {
+      "source": "./src/edge/index.ts",
       "types": "./dist/types/src/edge/index.d.ts",
       "browser": "./dist/lib/browser/edge/index.mjs",
-      "node": "./dist/lib/node-esm/edge/index.mjs",
-      "source": "./src/edge/index.ts"
-    },
-    ".": {
-      "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs",
-      "source": "./src/index.ts"
+      "node": "./dist/lib/node-esm/edge/index.mjs"
     },
     "./testing": {
+      "source": "./src/testing/index.ts",
       "types": "./dist/types/src/testing/index.d.ts",
       "browser": "./dist/lib/browser/testing/index.mjs",
-      "node": "./dist/lib/node-esm/testing/index.mjs",
-      "source": "./src/testing/index.ts"
+      "node": "./dist/lib/node-esm/testing/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -51,44 +51,45 @@
     "src"
   ],
   "dependencies": {
-    "@effect/platform": "0.89.0",
+    "@effect/platform": "0.90.2",
     "@preact/signals-core": "^1.9.0",
     "cron": "^3.1.6",
     "cron-schedule": "^5.0.4",
-    "effect": "3.17.0",
+    "effect": "3.17.7",
     "esbuild-wasm": "^0.16.14",
     "express": "^4.19.2",
     "get-port-please": "^3.1.1",
     "i18next": "^24.2.1",
     "iso-did": "^1.6.0",
     "ws": "^8.14.2",
-    "@dxos/ai": "0.8.4-main.5acf9ea",
-    "@dxos/async": "0.8.4-main.5acf9ea",
-    "@dxos/crypto": "0.8.4-main.5acf9ea",
-    "@dxos/client": "0.8.4-main.5acf9ea",
-    "@dxos/echo": "0.8.4-main.5acf9ea",
-    "@dxos/context": "0.8.4-main.5acf9ea",
-    "@dxos/debug": "0.8.4-main.5acf9ea",
-    "@dxos/echo-db": "0.8.4-main.5acf9ea",
-    "@dxos/echo-protocol": "0.8.4-main.5acf9ea",
-    "@dxos/echo-pipeline": "0.8.4-main.5acf9ea",
-    "@dxos/echo-schema": "0.8.4-main.5acf9ea",
-    "@dxos/edge-client": "0.8.4-main.5acf9ea",
-    "@dxos/effect": "0.8.4-main.5acf9ea",
-    "@dxos/errors": "0.8.4-main.5acf9ea",
-    "@dxos/keys": "0.8.4-main.5acf9ea",
-    "@dxos/invariant": "0.8.4-main.5acf9ea",
-    "@dxos/live-object": "0.8.4-main.5acf9ea",
-    "@dxos/log": "0.8.4-main.5acf9ea",
-    "@dxos/node-std": "0.8.4-main.5acf9ea",
-    "@dxos/protocols": "0.8.4-main.5acf9ea",
-    "@dxos/schema": "0.8.4-main.5acf9ea",
-    "@dxos/util": "0.8.4-main.5acf9ea"
+    "@dxos/ai": "0.8.4-main.5ea62a8",
+    "@dxos/async": "0.8.4-main.5ea62a8",
+    "@dxos/context": "0.8.4-main.5ea62a8",
+    "@dxos/client": "0.8.4-main.5ea62a8",
+    "@dxos/crypto": "0.8.4-main.5ea62a8",
+    "@dxos/debug": "0.8.4-main.5ea62a8",
+    "@dxos/echo-db": "0.8.4-main.5ea62a8",
+    "@dxos/echo-pipeline": "0.8.4-main.5ea62a8",
+    "@dxos/echo-schema": "0.8.4-main.5ea62a8",
+    "@dxos/echo": "0.8.4-main.5ea62a8",
+    "@dxos/echo-protocol": "0.8.4-main.5ea62a8",
+    "@dxos/edge-client": "0.8.4-main.5ea62a8",
+    "@dxos/effect": "0.8.4-main.5ea62a8",
+    "@dxos/errors": "0.8.4-main.5ea62a8",
+    "@dxos/invariant": "0.8.4-main.5ea62a8",
+    "@dxos/keys": "0.8.4-main.5ea62a8",
+    "@dxos/kv-store": "0.8.4-main.5ea62a8",
+    "@dxos/live-object": "0.8.4-main.5ea62a8",
+    "@dxos/log": "0.8.4-main.5ea62a8",
+    "@dxos/protocols": "0.8.4-main.5ea62a8",
+    "@dxos/schema": "0.8.4-main.5ea62a8",
+    "@dxos/util": "0.8.4-main.5ea62a8",
+    "@dxos/node-std": "0.8.4-main.5ea62a8"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.8.4-main.5acf9ea"
+    "@dxos/agent": "0.8.4-main.5ea62a8"
   },
   "publishConfig": {
     "access": "public"

package/src/bundler/bundler.test.ts

@@ -4,7 +4,7 @@
 
 // @ts-ignore
 import wasmUrl from 'esbuild-wasm/esbuild.wasm?url';
-import { beforeAll, describe, expect, test } from 'vitest';
+import { assert, beforeAll, describe, expect, test } from 'vitest';
 
 import { isNode } from '@dxos/util';
 
@@ -20,8 +20,8 @@ describe('Bundler', () => {
   test('Basic', async () => {
     const bundler = new Bundler({ platform: 'node', sandboxedModules: [], remoteModules: {} });
     const result = await bundler.bundle({ source: 'const x = 100' }); // TODO(burdon): Test import.
-    expect(result.bundle).to.exist;
-    expect(result.error).to.not.exist;
+    assert(!('error' in result), 'error should not exist');
+    expect(result.asset).toBeDefined();
   });
 
   test('Import', async () => {
@@ -33,8 +33,8 @@ describe('Bundler', () => {
       const query = Filter.typename('dxos.org/type/Example');
     `,
     });
-    expect(result.bundle).to.exist;
-    expect(result.error).to.not.exist;
+    assert(!('error' in result), 'error should not exist');
+    expect(result.asset).toBeDefined();
   });
 
   // TODO(dmaretskyi): Flaky on CI.
@@ -46,14 +46,13 @@ describe('Bundler', () => {
       invariant(true);
     `,
     });
-    expect(result.bundle).to.exist;
-    expect(result.error).to.not.exist;
+    assert(!('error' in result), 'error should not exist');
+    expect(result.asset).toBeDefined();
   });
 
   test('Error', async () => {
     const bundler = new Bundler({ platform: 'node', sandboxedModules: [], remoteModules: {} });
     const result = await bundler.bundle({ source: "import missing from './module'; missing();" });
-    expect(result.bundle).to.not.exist;
-    expect(result.error).to.exist;
+    assert('error' in result, 'error should exist');
   });
 });

package/src/bundler/bundler.ts

@@ -3,8 +3,8 @@
 //
 
 import { FetchHttpClient, HttpClient } from '@effect/platform';
-import { Duration, Effect, pipe, Schedule } from 'effect';
-import { type BuildOptions, type Loader, build, initialize, type BuildResult, type Plugin } from 'esbuild-wasm';
+import { Duration, Effect, Schedule, pipe } from 'effect';
+import { type BuildOptions, type BuildResult, type Loader, type Plugin, build, initialize } from 'esbuild-wasm';
 
 import { subtleCrypto } from '@dxos/crypto';
 import { runAndForwardErrors } from '@dxos/effect';
@@ -18,26 +18,26 @@ export type Import = {
 };
 
 export type BundleOptions = {
-  /**
-   * Path to the source file on the local file system.
-   * If provided, the path will be used instead of the `source` code.
-   */
-  path?: string;
-
   /**
    * Source code to bundle.
-   * Required if `path` is not provided.
    */
-  source?: string;
+  source: string;
 };
 
-export type BundleResult = {
-  timestamp: number;
-  sourceHash?: Buffer;
-  imports?: Import[];
-  bundle?: string;
-  error?: any;
-};
+export type BundleResult =
+  | {
+      timestamp: number;
+      sourceHash: Buffer;
+      error: unknown;
+    }
+  | {
+      timestamp: number;
+      sourceHash: Buffer;
+      imports: Import[];
+      entryPoint: string;
+      asset: Uint8Array;
+      bundle: string;
+    };
 
 export type BundlerOptions = {
   platform: BuildOptions['platform'];
@@ -58,16 +58,9 @@ export const initializeBundler = async (options: { wasmUrl: string }) => {
 export class Bundler {
   constructor(private readonly _options: BundlerOptions) {}
 
-  async bundle({ path, source }: BundleOptions): Promise<BundleResult> {
+  async bundle({ source }: BundleOptions): Promise<BundleResult> {
     const { sandboxedModules: providedModules, ...options } = this._options;
-
-    const createResult = async (result?: Partial<BundleResult>) => {
-      return {
-        timestamp: Date.now(),
-        sourceHash: source ? Buffer.from(await subtleCrypto.digest('SHA-256', Buffer.from(source))) : undefined,
-        ...result,
-      };
-    };
+    const sourceHash = Buffer.from(await subtleCrypto.digest('SHA-256', Buffer.from(source)));
 
     if (this._options.platform === 'browser') {
       invariant(initialized, 'Compiler not initialized.');
@@ -83,7 +76,10 @@ export class Bundler {
         conditions: ['workerd', 'browser'],
         metafile: true,
         write: false,
-        entryPoints: [path ?? 'memory:main.tsx'],
+        entryPoints: {
+          // Gets mapped to `userFunc.js` by esbuild.
+          userFunc: 'memory:main.tsx',
+        },
         bundle: true,
         format: 'esm',
         plugins: [
@@ -136,12 +132,17 @@ export class Bundler {
 
       log('compile complete', result.metafile);
 
-      return await createResult({
+      const entryPoint = 'userFunc.js';
+      return {
+        timestamp: Date.now(),
+        sourceHash,
         imports: this.analyzeImports(result),
+        entryPoint,
+        asset: result.outputFiles![0].contents,
         bundle: result.outputFiles![0].text,
-      });
+      };
     } catch (err) {
-      return await createResult({ error: err });
+      return { timestamp: Date.now(), sourceHash, error: err };
     }
   }
 
@@ -153,7 +154,6 @@ export class Bundler {
     const parsedImports = allMatches(IMPORT_REGEX, result.outputFiles[0].text);
     return Object.values(result.metafile!.outputs)[0].imports.map((entry): Import => {
       const namedImports: string[] = [];
-
       const parsedImport = parsedImports.find((capture) => capture?.[4] === entry.path);
       if (parsedImport?.[2]) {
         NAMED_IMPORTS_REGEX.lastIndex = 0;
@@ -207,10 +207,9 @@ const IMPORT_REGEX =
 const NAMED_IMPORTS_REGEX = /[ \n\t]*{((?:[ \n\t]*[^ \n\t"'{}]+[ \n\t]*,?)+)}[ \n\t]*/gm;
 
 const allMatches = (regex: RegExp, str: string) => {
-  regex.lastIndex = 0;
-
   let match;
   const matches = [];
+  regex.lastIndex = 0;
   while ((match = regex.exec(str))) {
     matches.push(match);
   }

package/src/edge/functions.ts

@@ -14,21 +14,24 @@ import { type UploadFunctionResponseBody } from '@dxos/protocols';
 
 export type UploadWorkerArgs = {
   client: Client;
-  source: string;
   version: string;
   name?: string;
   functionId?: string;
   ownerPublicKey: PublicKey;
+  entryPoint: string;
+  assets: Record<string, Uint8Array>;
 };
 
 export const uploadWorkerFunction = async ({
   client,
   version,
-  source,
   name,
   functionId,
   ownerPublicKey,
+  entryPoint,
+  assets,
 }: UploadWorkerArgs): Promise<UploadFunctionResponseBody> => {
+  log('uploading function', { functionId, name, version, ownerPublicKey });
   const edgeUrl = client.config.values.runtime?.services?.edge?.url;
   invariant(edgeUrl, 'Edge is not configured.');
   const edgeClient = new EdgeHttpClient(edgeUrl);
@@ -36,15 +39,15 @@ export const uploadWorkerFunction = async ({
   edgeClient.setIdentity(edgeIdentity);
   const response = await edgeClient.uploadFunction(
     { functionId },
-    { name, version, script: source, ownerPublicKey: ownerPublicKey.toHex() },
+    { name, version, ownerPublicKey: ownerPublicKey.toHex(), entryPoint, assets },
   );
 
   // TODO(burdon): Edge service log.
-  log.info('Uploaded', {
+  log('uploaded', {
     identityKey: edgeIdentity.identityKey,
     functionId,
     name,
-    source: source.length,
+    version,
     response,
   });
 

package/src/examples/fib.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect, Schema } from 'effect';
+
+import { defineFunction } from '../handler';
+
+export default defineFunction({
+  name: 'example.org/function/fib',
+  description: 'Function that calculates a Fibonacci number',
+  inputSchema: Schema.Struct({
+    iterations: Schema.optional(Schema.Number).annotations({
+      description: 'Number of iterations',
+      default: 100_000,
+    }),
+  }),
+  outputSchema: Schema.Struct({
+    result: Schema.String,
+  }),
+  handler: Effect.fn(function* ({ data: { iterations = 100_000 } }) {
+    let a = 0n;
+    let b = 1n;
+    for (let i = 0; i < iterations; i++) {
+      a += b;
+      b = a - b;
+    }
+    return { result: a.toString() };
+  }),
+});

package/src/examples/reply.ts

@@ -0,0 +1,18 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Console, Effect, Schema } from 'effect';
+
+import { defineFunction } from '../handler';
+
+export default defineFunction({
+  name: 'example.org/function/reply',
+  description: 'Function that echoes the input',
+  inputSchema: Schema.Any,
+  outputSchema: Schema.Any,
+  handler: Effect.fn(function* ({ data }) {
+    yield* Console.log('reply', { data });
+    return data;
+  }),
+});

package/src/examples/sleep.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Effect, Schema } from 'effect';
+
+import { defineFunction } from '../handler';
+
+export default defineFunction({
+  name: 'example.org/function/sleep',
+  description: 'Function that sleeps for a given amount of time',
+  inputSchema: Schema.Struct({
+    duration: Schema.optional(Schema.Number).annotations({
+      description: 'Milliseconds to sleep',
+      default: 100_000,
+    }),
+  }),
+  outputSchema: Schema.Void,
+  handler: Effect.fn(function* ({ data: { duration = 100_000 } }) {
+    yield* Effect.sleep(duration);
+  }),
+});

package/src/executor/executor.ts

@@ -4,7 +4,7 @@
 
 import { Effect, Schema } from 'effect';
 
-import type { SpaceId } from '@dxos/client/echo';
+import { type SpaceId } from '@dxos/client/echo';
 import { runAndForwardErrors } from '@dxos/effect';
 
 import type { FunctionContext, FunctionDefinition } from '../handler';
@@ -13,27 +13,27 @@ import type { ServiceContainer, Services } from '../services';
 export class FunctionExecutor {
   constructor(private readonly _services: ServiceContainer) {}
 
+  /**
+   * Invoke function.
+   */
   // TODO(dmaretskyi): Invocation context: queue, space, etc...
   async invoke<F extends FunctionDefinition<any, any>>(
-    fnDef: F,
+    functionDef: F,
     input: F extends FunctionDefinition<infer I, infer _O> ? I : never,
   ): Promise<F extends FunctionDefinition<infer _I, infer O> ? O : never> {
     // Assert input matches schema
-    const assertInput = fnDef.inputSchema.pipe(Schema.asserts);
+    const assertInput = functionDef.inputSchema.pipe(Schema.asserts);
     (assertInput as any)(input);
 
     const context: FunctionContext = {
+      space: undefined,
       getService: this._services.getService.bind(this._services),
       getSpace: async (_spaceId: SpaceId) => {
         throw new Error('Not available. Use the database service instead.');
       },
-      space: undefined,
-      get ai(): never {
-        throw new Error('Not available. Use the ai service instead.');
-      },
     };
 
-    const result = fnDef.handler({ context, data: input });
+    const result = functionDef.handler({ context, data: input });
 
     let data: unknown;
     if (Effect.isEffect(result)) {
@@ -46,7 +46,7 @@ export class FunctionExecutor {
     }
 
     // Assert output matches schema
-    const assertOutput = fnDef.outputSchema?.pipe(Schema.asserts);
+    const assertOutput = functionDef.outputSchema?.pipe(Schema.asserts);
     (assertOutput as any)(data);
 
     return data as any;

package/src/handler.ts

@@ -2,16 +2,14 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema, type Context, type Effect } from 'effect';
+import { type Context, type Effect, Schema } from 'effect';
 
-import { type AiServiceClient } from '@dxos/ai';
-// import { type Space } from '@dxos/client/echo';
-import type { EchoDatabase } from '@dxos/echo-db';
+import { type EchoDatabase } from '@dxos/echo-db';
 import { type HasId } from '@dxos/echo-schema';
-import { type SpaceId, type DXN } from '@dxos/keys';
+import { type DXN, type SpaceId } from '@dxos/keys';
 import { type QueryResult } from '@dxos/protocols';
 
-import type { Services } from './services';
+import { type Services } from './services';
 
 // TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
 // https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
@@ -44,8 +42,6 @@ export interface FunctionContext {
    */
   space: SpaceAPI | undefined;
 
-  ai: AiServiceClient;
-
   /**
    * Resolves a service available to the function.
    * @throws if the service is not available.
@@ -87,7 +83,8 @@ const __assertFunctionSpaceIsCompatibleWithTheClientSpace = () => {
   // const _: SpaceAPI = {} as Space;
 };
 
-export type FunctionDefinition<T = {}, O = any> = {
+export type FunctionDefinition<T = any, O = any> = {
+  // TODO(dmaretskyi): Use `key` for FQN and `name` for human-readable-name.
   name: string;
   description?: string;
   inputSchema: Schema.Schema<T, any>;
@@ -95,7 +92,6 @@ export type FunctionDefinition<T = {}, O = any> = {
   handler: FunctionHandler<T, O>;
 };
 
-// TODO(dmaretskyi): Bind input type to function handler.
 export const defineFunction = <T, O>({
   name,
   description,
@@ -118,3 +114,9 @@ export const defineFunction = <T, O>({
     handler,
   };
 };
+
+export namespace FunctionDefinition {
+  export type Any = FunctionDefinition<any, any>;
+  export type Input<T extends FunctionDefinition> = T extends FunctionDefinition<infer I, any> ? I : never;
+  export type Output<T extends FunctionDefinition> = T extends FunctionDefinition<any, infer O> ? O : never;
+}

package/src/schema.ts

@@ -32,6 +32,17 @@ export interface ScriptType extends Schema.Schema.Type<typeof ScriptType> {}
  * Function deployment.
  */
 export const FunctionType = Schema.Struct({
+  /**
+   * Global registry ID.
+   * NOTE: The `key` property refers to the original registry entry.
+   */
+  // TODO(burdon): Create Format type for DXN-like ids, such as this and schema type.
+  // TODO(dmaretskyi): Consider making it part of ECHO meta.
+  // TODO(dmaretskyi): Make required.
+  key: Schema.optional(Schema.String).annotations({
+    description: 'Unique registration key for the blueprint',
+  }),
+
   // TODO(burdon): Rename to id/uri?
   name: Schema.NonEmptyString,
   version: Schema.String,

package/src/services/credentials.ts

@@ -2,9 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Context, Effect, Layer } from 'effect';
+import { HttpClient, HttpClientRequest } from '@effect/platform';
+import { type Config, Context, Effect, Layer, Redacted } from 'effect';
 
-type CredentialQuery = {
+import { Query } from '@dxos/echo';
+import { DataType } from '@dxos/schema';
+
+import { DatabaseService } from './database';
+
+export type CredentialQuery = {
   service?: string;
 };
 
@@ -32,14 +38,69 @@ export class CredentialsService extends Context.Tag('@dxos/functions/Credentials
     getCredential: (query: CredentialQuery) => Promise<ServiceCredential>;
   }
 >() {
-  static configuredLayer = (credentials: ServiceCredential[]) =>
-    Layer.succeed(CredentialsService, new ConfiguredCredentialsService(credentials));
-
   static getCredential = (query: CredentialQuery): Effect.Effect<ServiceCredential, never, CredentialsService> =>
     Effect.gen(function* () {
       const credentials = yield* CredentialsService;
       return yield* Effect.promise(() => credentials.getCredential(query));
     });
+
+  static getApiKey = (query: CredentialQuery): Effect.Effect<Redacted.Redacted<string>, never, CredentialsService> =>
+    Effect.gen(function* () {
+      const credential = yield* CredentialsService.getCredential(query);
+      if (!credential.apiKey) {
+        throw new Error(`API key not found for service: ${query.service}`);
+      }
+      return Redacted.make(credential.apiKey);
+    });
+
+  static configuredLayer = (credentials: ServiceCredential[]) =>
+    Layer.succeed(CredentialsService, new ConfiguredCredentialsService(credentials));
+
+  static layerConfig = (credentials: { service: string; apiKey: Config.Config<Redacted.Redacted<string>> }[]) =>
+    Layer.effect(
+      CredentialsService,
+      Effect.gen(function* () {
+        const serviceCredentials = yield* Effect.forEach(credentials, ({ service, apiKey }) =>
+          Effect.gen(function* () {
+            return {
+              service,
+              apiKey: Redacted.value(yield* apiKey),
+            };
+          }),
+        );
+
+        return new ConfiguredCredentialsService(serviceCredentials);
+      }),
+    );
+
+  static layerFromDatabase = () =>
+    Layer.effect(
+      CredentialsService,
+      Effect.gen(function* () {
+        const dbService = yield* DatabaseService;
+        const queryCredentials = async (query: CredentialQuery): Promise<ServiceCredential[]> => {
+          const { objects: accessTokens } = await dbService.db.query(Query.type(DataType.AccessToken)).run();
+          return accessTokens
+            .filter((accessToken) => accessToken.source === query.service)
+            .map((accessToken) => ({
+              service: accessToken.source,
+              apiKey: accessToken.token,
+            }));
+        };
+        return {
+          getCredential: async (query) => {
+            const credentials = await queryCredentials(query);
+            if (credentials.length === 0) {
+              throw new Error(`Credential not found for service: ${query.service}`);
+            }
+            return credentials[0];
+          },
+          queryCredentials: async (query) => {
+            return queryCredentials(query);
+          },
+        };
+      }),
+    );
 }
 
 export class ConfiguredCredentialsService implements Context.Tag.Service<CredentialsService> {
@@ -62,3 +123,15 @@ export class ConfiguredCredentialsService implements Context.Tag.Service<Credent
     return credential;
   }
 }
+
+/**
+ * Maps the request to include the API key from the credential.
+ */
+export const withAuthorization = (query: CredentialQuery, kind?: 'Bearer' | 'Basic') =>
+  HttpClient.mapRequestEffect(
+    Effect.fnUntraced(function* (request) {
+      const key = yield* CredentialsService.getApiKey(query).pipe(Effect.map(Redacted.value));
+      const authorization = kind ? `${kind} ${key}` : key;
+      return HttpClientRequest.setHeader(request, 'Authorization', authorization);
+    }),
+  );