@relayflows/surface 2.0.9 → 2.0.10

package/src/flow.ts

@@ -1,38 +1,33 @@
+import { helperProviders } from "./helpers/providers.js";
+import type { Helpers } from "./helpers/index.js";
+type HelperTools = Partial<Record<keyof Helpers, boolean>>;
 import type { Ctx } from "./context.js";
-
-/**
- * A reusable agent CLI/model pair, selectable by name from `f.agent(name, ...)`.
- * Both fields are required so selecting a named agent can never inherit a
- * host model — mirrors the kernel-spec dialect's `NamedAgentSpec`
- * (`packages/sdk/src/spec.ts`), which this compiles into.
- */
-export interface NamedAgentDeclaration {
-  cli: string;
-  model: string;
-}
+import { webhook, type TriggerSource } from "./triggers.js";
 
 /** Optional escalation header; the empty header is the common case. */
 export interface FlowHeader {
+  /** Relative paths to reusable authored flows composed by this body. */
+  use?: string[];
   identity?: string;
   memory?: { script?: boolean; agent?: boolean };
-  budget?: string;
-  tools?: { relayfile?: string[]; mcp?: string[] };
+  budget?: string | { tokens?: number; dollars?: number; wallclock?: string };
+  tools?: HelperTools & { relayfile?: string[]; mcp?: string[] };
   workspace?: string;
-  agents?: Record<string, NamedAgentDeclaration>;
 }
 
 export type FlowBody<Input = unknown> = (f: Ctx, input: Input) => Promise<void>;
 
 export interface ReadonlyFlowHeader {
+  readonly use?: readonly string[];
   readonly identity?: string;
   readonly memory?: Readonly<{ script?: boolean; agent?: boolean }>;
-  readonly budget?: string;
-  readonly tools?: Readonly<{
+  readonly budget?: string | Readonly<{ tokens?: number; dollars?: number; wallclock?: string }>;
+  readonly tools?: Readonly<HelperTools & {
+    slack?: boolean;
     relayfile?: readonly string[];
     mcp?: readonly string[];
   }>;
   readonly workspace?: string;
-  readonly agents?: Readonly<Record<string, Readonly<NamedAgentDeclaration>>>;
 }
 
 /** Immutable definition retained for the SDK's journal-backed runtime. */
@@ -40,15 +35,25 @@ export interface AuthoredFlowDefinition<Input = unknown> {
   readonly name: string;
   readonly header: ReadonlyFlowHeader;
   readonly body: FlowBody<Input>;
+  readonly handlers: readonly TriggerHandler[];
+}
+
+export interface TriggerHandler {
+  readonly trigger: TriggerSource;
+  readonly body: FlowBody;
 }
 
 /** Opaque authored-flow handle. Execution stays behind the journal runtime. */
 export interface FlowHandle {
   readonly name: string;
+  on<Event = Record<string, unknown>>(trigger: TriggerSource, body: FlowBody<Event>): TriggeredFlowHandle;
 }
 
+export interface TriggeredFlowHandle extends FlowHandle {}
+
 const definitions = new WeakMap<object, AuthoredFlowDefinition>();
 
+export function flow(name: string, header?: FlowHeader): FlowHandle;
 export function flow<Input = unknown>(name: string, body: FlowBody<Input>): FlowHandle;
 export function flow<Input = unknown>(
   name: string,
@@ -57,7 +62,7 @@ export function flow<Input = unknown>(
 ): FlowHandle;
 export function flow<Input = unknown>(
   name: string,
-  headerOrBody: FlowHeader | FlowBody<Input>,
+  headerOrBody: FlowHeader | FlowBody<Input> = {},
   body?: FlowBody<Input>,
 ): FlowHandle {
   const flowBody = typeof headerOrBody === "function" ? headerOrBody : body;
@@ -66,7 +71,7 @@ export function flow<Input = unknown>(
   if (name.trim().length === 0) {
     throw new TypeError("flow name must not be empty");
   }
-  if (typeof flowBody !== "function") {
+  if (flowBody !== undefined && typeof flowBody !== "function") {
     throw new TypeError(`flow "${name}" requires a body`);
   }
   assertFlowHeader(header, name);
@@ -74,9 +79,28 @@ export function flow<Input = unknown>(
   const definition: AuthoredFlowDefinition<Input> = Object.freeze({
     name,
     header: freezeHeader(header),
-    body: flowBody,
+    body: flowBody ?? (async () => { throw new TypeError(`flow "${name}" has no direct-run body`); }),
+    handlers: Object.freeze([]),
   });
-  const handle: FlowHandle = Object.freeze({ name });
+  return makeHandle(definition as AuthoredFlowDefinition);
+}
+
+function makeHandle(definition: AuthoredFlowDefinition): FlowHandle {
+  const handle = { name: definition.name } as FlowHandle;
+  Object.defineProperty(handle, "on", {
+    value: <Event>(trigger: TriggerSource, body: FlowBody<Event>): TriggeredFlowHandle => {
+      if (typeof body !== "function") throw new TypeError("trigger handler requires a body");
+      assertHeaderObject(trigger, "trigger");
+      assertKnownKeys(trigger, ["kind", "name", "filter"], "trigger");
+      if (trigger.kind !== "webhook") throw new TypeError("unsupported trigger kind");
+      const source = webhook(trigger.name, trigger.filter);
+      return makeHandle(Object.freeze({
+        ...definition,
+        handlers: Object.freeze([...definition.handlers, Object.freeze({ trigger: source, body: body as FlowBody })]),
+      }));
+    },
+  });
+  Object.freeze(handle);
   // One map holds definitions of many input types, so it is stored at the
   // default parameterisation and `getFlowDefinition<Input>` re-parameterises on
   // the way out. The cast is needed because `body` puts `Input` in a parameter
@@ -84,7 +108,7 @@ export function flow<Input = unknown>(
   // assignable to `AuthoredFlowDefinition<unknown>` even though every read
   // recovers the author's own type. Sound here because the handle-to-definition
   // pairing is 1:1 and both sides are keyed by the same authored flow.
-  definitions.set(handle, definition as AuthoredFlowDefinition);
+  definitions.set(handle, definition);
   return handle;
 }
 
@@ -92,7 +116,7 @@ export function flow<Input = unknown>(
  * Runtime bridge used by the SDK after it imports an authored `.flow.ts`.
  * The root package deliberately does not re-export this accessor.
  */
-export function getFlowDefinition<Input = unknown>(handle: FlowHandle): AuthoredFlowDefinition<Input> {
+export function getFlowDefinition<Input = unknown>(handle: Pick<FlowHandle, "name">): AuthoredFlowDefinition<Input> {
   if ((typeof handle !== "object" && typeof handle !== "function") || handle === null) {
     throw new TypeError("expected an @relayflows/surface flow handle");
   }
@@ -127,12 +151,12 @@ function isStoredDefinition(
 
 function freezeHeader(header: FlowHeader): ReadonlyFlowHeader {
   const unknownFields = Object.keys(header).filter((field) => ![
+    "use",
     "identity",
     "memory",
     "budget",
     "tools",
     "workspace",
-    "agents",
   ].includes(field));
   if (unknownFields.length > 0) {
     throw new TypeError(`flow header has unknown fields: ${unknownFields.join(", ")}`);
@@ -143,6 +167,8 @@ function freezeHeader(header: FlowHeader): ReadonlyFlowHeader {
   const tools = header.tools === undefined
     ? undefined
     : Object.freeze({
+        ...Object.fromEntries(helperProviders.filter(p => header.tools?.[p.namespace] !== undefined)
+          .map(p => [p.namespace, header.tools![p.namespace]])),
         ...(header.tools.relayfile === undefined
           ? {}
           : { relayfile: Object.freeze([...header.tools.relayfile]) }),
@@ -150,26 +176,13 @@ function freezeHeader(header: FlowHeader): ReadonlyFlowHeader {
           ? {}
           : { mcp: Object.freeze([...header.tools.mcp]) }),
       });
-  const agents = header.agents === undefined
-    ? undefined
-    : Object.freeze(
-        Object.fromEntries(
-          ownDataEntries(header.agents, "header.agents").map(([name, declaration]) => {
-            // Validated by assertFlowHeader's own ownDataEntries pass before
-            // this ever runs: exactly {cli, model}, both non-empty trimmed
-            // strings, read as data properties (never through a getter).
-            const record = declaration as NamedAgentDeclaration;
-            return [name, Object.freeze({ cli: record.cli, model: record.model })];
-          }),
-        ),
-      );
   return Object.freeze({
+    ...(header.use === undefined ? {} : { use: Object.freeze([...header.use]) }),
     ...(header.identity === undefined ? {} : { identity: header.identity }),
     ...(memory === undefined ? {} : { memory }),
-    ...(header.budget === undefined ? {} : { budget: header.budget }),
+    ...(header.budget === undefined ? {} : { budget: typeof header.budget === "string" ? header.budget : Object.freeze({ ...header.budget }) }),
     ...(tools === undefined ? {} : { tools }),
     ...(header.workspace === undefined ? {} : { workspace: header.workspace }),
-    ...(agents === undefined ? {} : { agents }),
   });
 }
 
@@ -178,12 +191,27 @@ function assertFlowHeader(value: unknown, flowName: string): asserts value is Fl
   assertHeaderObject(value, at);
   assertKnownKeys(
     value,
-    ["identity", "memory", "budget", "tools", "workspace", "agents"],
+    ["use", "identity", "memory", "budget", "tools", "workspace"],
     at,
   );
   assertOptionalString(value, "identity", at);
-  assertOptionalString(value, "budget", at);
+  if (value.budget !== undefined && typeof value.budget !== "string") {
+    assertHeaderObject(value.budget, `${at}.budget`);
+    assertKnownKeys(value.budget, ["tokens", "dollars", "wallclock"], `${at}.budget`);
+    assertOptionalString(value.budget, "wallclock", at);
+    for (const key of ["tokens", "dollars"]) {
+      if (value.budget[key] !== undefined && typeof value.budget[key] !== "number") throw new TypeError(`budget_syntax_invalid: ${key} must be a number`);
+    }
+  }
   assertOptionalString(value, "workspace", at);
+  assertOptionalStringArray(value, "use", at);
+  if (value.use !== undefined) {
+    for (const path of value.use as string[]) {
+      if (!/^(?:\.\/|\.\.\/).+\.flow\.ts$/.test(path) || /[?#\\\\]/.test(path)) {
+        throw new TypeError(`${at}.use: expected relative .flow.ts paths`);
+      }
+    }
+  }
 
   if (value.memory !== undefined) {
     assertHeaderObject(value.memory, `${at}.memory`);
@@ -200,54 +228,13 @@ function assertFlowHeader(value: unknown, flowName: string): asserts value is Fl
     assertHeaderObject(value.tools, `${at}.tools`);
     assertKnownKeys(
       value.tools,
-      ["relayfile", "mcp"],
+      ["relayfile", "mcp", ...helperProviders.map(p => p.namespace)],
       `${at}.tools`,
     );
+    for (const { namespace } of helperProviders) assertOptionalBoolean(value.tools, namespace, `${at}.tools`);
     assertOptionalStringArray(value.tools, "relayfile", `${at}.tools`);
     assertOptionalStringArray(value.tools, "mcp", `${at}.tools`);
   }
-
-  if (value.agents !== undefined) {
-    assertHeaderObject(value.agents, `${at}.agents`);
-    for (const [name, declaration] of ownDataEntries(value.agents, `${at}.agents`)) {
-      if (name !== name.trim() || name.length === 0) {
-        throw new TypeError(`${at}.agents: agent name ${JSON.stringify(name)} must be a non-empty, trimmed string`);
-      }
-      const declarationAt = `${at}.agents.${name}`;
-      assertHeaderObject(declaration, declarationAt);
-      assertKnownKeys(declaration, ["cli", "model"], declarationAt);
-      assertRequiredTrimmedString(declaration, "cli", declarationAt);
-      assertRequiredTrimmedString(declaration, "model", declarationAt);
-    }
-  }
-}
-
-/**
- * Reads every own property of `value` via its descriptor rather than
- * `Object.entries`/property access, so an accessor (getter) property is
- * REJECTED — never invoked — instead of being enumerated as if it were
- * ordinary data. `Object.entries` would call the getter, and a stateful
- * getter can legally answer validation with one value and a second,
- * unvalidated read (e.g. during freezing) with a different one — the closed
- * declaration contract must not depend on a property being well-behaved
- * across two separate reads.
- */
-function ownDataEntries(
-  value: Record<string, unknown>,
-  at: string,
-): [string, unknown][] {
-  const entries: [string, unknown][] = [];
-  for (const key of Reflect.ownKeys(value)) {
-    if (typeof key !== "string") {
-      throw new TypeError(`${at}: unknown field ${JSON.stringify(String(key))}`);
-    }
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (descriptor === undefined || !("value" in descriptor)) {
-      throw new TypeError(`${at}.${key}: expected a data property`);
-    }
-    entries.push([key, descriptor.value]);
-  }
-  return entries;
 }
 
 function assertHeaderObject(
@@ -290,27 +277,6 @@ function assertOptionalString(
   }
 }
 
-/**
- * Requires a trimmed, non-empty string — not merely non-empty-after-trim.
- * The SDK's own project-config schema only accepts already-trimmed model/cli
- * strings (`readProjectConfig`, cli/check.ts); accepting untrimmed values
- * here would let a flow author declare " claude " and have it validate at
- * authoring time but fail later at f.agent preflight, moving a defect from
- * authoring to execution instead of catching it up front.
- */
-function assertRequiredTrimmedString(
-  value: Record<string, unknown>,
-  key: string,
-  at: string,
-): void {
-  if (typeof value[key] !== "string" || value[key].length === 0) {
-    throw new TypeError(`${at}.${key}: expected a non-empty string`);
-  }
-  if (value[key] !== value[key].trim()) {
-    throw new TypeError(`${at}.${key}: must not have leading or trailing whitespace`);
-  }
-}
-
 function assertOptionalBoolean(
   value: Record<string, unknown>,
   key: string,
@@ -329,8 +295,13 @@ function assertOptionalStringArray(
   const candidate = value[key];
   if (
     candidate !== undefined
-    && (!Array.isArray(candidate) || candidate.some((item) => typeof item !== "string"))
+    && (!Array.isArray(candidate) || Array.from(candidate).some((item) => typeof item !== "string"))
   ) {
     throw new TypeError(`${at}.${key}: expected an array of strings`);
   }
+  if (key === "use" && Array.isArray(candidate)
+    && (candidate.some((item) => item.trim().length === 0)
+      || new Set(candidate).size !== candidate.length)) {
+    throw new TypeError(`${at}.${key}: expected unique nonempty paths`);
+  }
 }

package/src/helper-clients.ts

@@ -0,0 +1,30 @@
+import { githubClient as upstreamGithub, notionClient as upstreamNotion, created } from '@relayfile/relay-helpers';
+import type { RelayClientOptions } from '@relayfile/relay-helpers/transport';
+
+/** Accept the conventional owner/repo shorthand as well as upstream arguments. */
+export function githubClient(options: RelayClientOptions) {
+  const client = upstreamGithub(options);
+  return { ...client, createIssue(args: { owner?: string; repo: string; title: string; body: string; labels?: string[] }) {
+    const [owner, repo, extra] = args.repo.split('/');
+    if (!args.owner && (!owner || !repo || extra)) throw new Error('github.createIssue requires repo: "owner/repo" or an explicit owner');
+    return client.createIssue({ ...args, owner: args.owner ?? owner!, repo: args.owner ? args.repo : repo! });
+  } };
+}
+
+export function stripeClient(options: RelayClientOptions) {
+  return { createInvoice(args: { customer: string; auto_advance?: boolean; collection_method?: 'charge_automatically' | 'send_invoice'; days_until_due?: number; description?: string; metadata?: Record<string, string> }) {
+    if (!options.transport) throw new Error('Stripe requires a journal transport');
+    return created(options.transport.write({ provider: 'stripe', resource: 'invoices',
+      parameters: {}, path: '/stripe/invoices', body: args }));
+  } };
+}
+
+export function notionClient(options: RelayClientOptions) {
+  return { ...upstreamNotion(options), async appendBlock(args: { pageId: string; block: Record<string, unknown> }) {
+    if (!options.transport) throw new Error('Notion requires a journal transport');
+    // The adapter does not yet support this route. The runtime refuses it in
+    // mount mode, while mock mode can exercise authoring and effect lowering.
+    return created(options.transport.write({ provider: 'notion', resource: 'blocks',
+      parameters: { pageId: args.pageId }, path: `/notion/pages/${encodeURIComponent(args.pageId)}/blocks`, body: { children: [args.block] } }));
+  } };
+}

package/src/helpers/README.md

@@ -0,0 +1,42 @@
+Generated TypeScript helpers; do not edit the `.ts` files. Run
+`npm run gen --prefix packages/surface` from the repository root (or `npm run gen`
+inside this package). This repository has no root npm workspace, so
+`npm run gen -w @relayflows/surface` is not available.
+
+This minimal slice ships Slack's four existing journal-backed methods. Argument
+shapes come from the pinned `@relayfile/relay-helpers` declaration; return types
+come from the existing surface dispatcher contract, including `reply`'s `ref`.
+`post` extends that contract with a structured second argument (`text`, `blocks`,
+`attachments`) or `blocks`/`attachments` in its third options argument. Options
+take precedence when both forms provide the same field. `replyTo` still maps to
+the adapter's `parentRef`; no interaction callback registration is added.
+
+The pinned relay-helpers 0.4.11 package does **not** export Block Kit/OpenAPI
+types. Until it does, `scripts/slack-message-schema.json` vendors the small
+fragments used by the generator, with their upstream URL and JSON pointers.
+Slack's published OpenAPI schema requires a string `type` on blocks but leaves
+their other fields open. Attachment objects are likewise open (the generic
+chat.update message schema is used; chat.postMessage's response attachment
+schema requires a server-assigned `id`, unsuitable for authoring).
+These types do not validate individual block layouts or interaction handlers.
+The SDK preserves structured content at the adapter transport boundary because
+the pinned adapter's ergonomic `post` still accepts only text.
+
+`Ctx` extends the generated `Helpers` namespace map. A union of namespace maps
+would make only their common properties accessible, so composition uses an
+interface instead.
+
+To consume a read-only adapter checkout before release:
+`node scripts/generate-helpers.mjs --adapters-dir /path/to/relayfile-adapters`.
+Use `--out-dir /tmp/generated-helpers` to inspect output without changing source.
+CI regenerates from the installed pinned package and compares every generated
+TypeScript file byte-for-byte, including the namespace index.
+
+Follow-up for the full slice N: add GitHub, Notion, Linear, and Stripe once their
+methods have runtime dispatch support; consume mapping/discovery resources and
+generate the remaining providers. The current runtime implements only Slack.
+The uniform upstream clients expose resource `read`/`list`/`write` methods,
+not `stripe.createInvoice` or `notion.appendBlock`; those aliases need an agreed
+runtime contract before this types-only generator can expose them. GitHub's
+bespoke `createIssue` also requires `owner` in addition to `repo`, `title`, and
+`body`. No new provider methods or resource methods are advertised in this proof.

package/src/helpers/airtable.ts

@@ -0,0 +1,9 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { bindHelper, type EffectDispatcher, type JournalHelper, type UnavailableHelper } from "../effect-transport.js";
+
+export type AirtableHelper = UnavailableHelper;
+
+export const createAirtableHelper = (dispatch: EffectDispatcher): AirtableHelper =>
+  bindHelper("airtable", undefined, dispatch);

package/src/helpers/asana.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { asanaClient } from "@relayfile/relay-helpers";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type AsanaHelper = JournalHelper<ReturnType<typeof asanaClient>>;
+
+export const createAsanaHelper = (dispatch: EffectDispatcher): AsanaHelper =>
+  bindHelper("asana", asanaClient, dispatch);

package/src/helpers/azure-blob.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { azureBlobClient } from "@relayfile/relay-helpers";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type AzureBlobHelper = JournalHelper<ReturnType<typeof azureBlobClient>>;
+
+export const createAzureBlobHelper = (dispatch: EffectDispatcher): AzureBlobHelper =>
+  bindHelper("azure-blob", azureBlobClient, dispatch);

package/src/helpers/box.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { boxClient } from "@relayfile/relay-helpers";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type BoxHelper = JournalHelper<ReturnType<typeof boxClient>>;
+
+export const createBoxHelper = (dispatch: EffectDispatcher): BoxHelper =>
+  bindHelper("box", boxClient, dispatch);

package/src/helpers/calendly.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { calendlyClient } from "@relayfile/relay-helpers";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type CalendlyHelper = JournalHelper<ReturnType<typeof calendlyClient>>;
+
+export const createCalendlyHelper = (dispatch: EffectDispatcher): CalendlyHelper =>
+  bindHelper("calendly", calendlyClient, dispatch);

package/src/helpers/clickup.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { clickupClient } from "@relayfile/relay-helpers";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type ClickupHelper = JournalHelper<ReturnType<typeof clickupClient>>;
+
+export const createClickupHelper = (dispatch: EffectDispatcher): ClickupHelper =>
+  bindHelper("clickup", clickupClient, dispatch);

package/src/helpers/clients.ts

@@ -0,0 +1,48 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import * as upstream from "@relayfile/relay-helpers";
+import * as custom from "../helper-clients.js";
+import type { HelperFactory } from "../effect-transport.js";
+
+export const helperClients: Readonly<Record<string, HelperFactory>> = {
+  "asana": upstream.asanaClient,
+  "azure-blob": upstream.azureBlobClient,
+  "box": upstream.boxClient,
+  "calendly": upstream.calendlyClient,
+  "clickup": upstream.clickupClient,
+  "cloudflare": upstream.cloudflareClient,
+  "confluence": upstream.confluenceClient,
+  "daytona": upstream.daytonaClient,
+  "dropbox": upstream.dropboxClient,
+  "gcs": upstream.gcsClient,
+  "github": custom.githubClient,
+  "gitlab": upstream.gitlabClient,
+  "gmail": upstream.gmailClient,
+  "google-calendar": upstream.googleCalendarClient,
+  "google-drive": upstream.googleDriveClient,
+  "granola": upstream.granolaClient,
+  "hubspot": upstream.hubspotClient,
+  "intercom": upstream.intercomClient,
+  "jira": upstream.jiraClient,
+  "linear": upstream.linearClient,
+  "mailgun": upstream.mailgunClient,
+  "mixpanel": upstream.mixpanelClient,
+  "notion": custom.notionClient,
+  "onedrive": upstream.onedriveClient,
+  "pipedrive": upstream.pipedriveClient,
+  "postgres": upstream.postgresClient,
+  "ramp": (options) => upstream.providerClient("ramp", options),
+  "recall": upstream.recallClient,
+  "reddit": upstream.redditClient,
+  "redis": upstream.redisClient,
+  "s3": upstream.s3Client,
+  "salesforce": upstream.salesforceClient,
+  "sendgrid": upstream.sendgridClient,
+  "sharepoint": upstream.sharepointClient,
+  "shortcut": upstream.shortcutClient,
+  "stripe": custom.stripeClient,
+  "teams": upstream.teamsClient,
+  "telegram": upstream.telegramClient,
+  "zendesk": upstream.zendeskClient,
+};

package/src/helpers/cloudflare.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { cloudflareClient } from "@relayfile/relay-helpers";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type CloudflareHelper = JournalHelper<ReturnType<typeof cloudflareClient>>;
+
+export const createCloudflareHelper = (dispatch: EffectDispatcher): CloudflareHelper =>
+  bindHelper("cloudflare", cloudflareClient, dispatch);

package/src/helpers/confluence.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { confluenceClient } from "@relayfile/relay-helpers";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type ConfluenceHelper = JournalHelper<ReturnType<typeof confluenceClient>>;
+
+export const createConfluenceHelper = (dispatch: EffectDispatcher): ConfluenceHelper =>
+  bindHelper("confluence", confluenceClient, dispatch);

package/src/helpers/daytona.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { daytonaClient } from "@relayfile/relay-helpers";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type DaytonaHelper = JournalHelper<ReturnType<typeof daytonaClient>>;
+
+export const createDaytonaHelper = (dispatch: EffectDispatcher): DaytonaHelper =>
+  bindHelper("daytona", daytonaClient, dispatch);

package/src/helpers/docker-hub.ts

@@ -0,0 +1,9 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { bindHelper, type EffectDispatcher, type JournalHelper, type UnavailableHelper } from "../effect-transport.js";
+
+export type DockerHubHelper = UnavailableHelper;
+
+export const createDockerHubHelper = (dispatch: EffectDispatcher): DockerHubHelper =>
+  bindHelper("docker-hub", undefined, dispatch);

package/src/helpers/dropbox.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { dropboxClient } from "@relayfile/relay-helpers";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type DropboxHelper = JournalHelper<ReturnType<typeof dropboxClient>>;
+
+export const createDropboxHelper = (dispatch: EffectDispatcher): DropboxHelper =>
+  bindHelper("dropbox", dropboxClient, dispatch);

package/src/helpers/fathom.ts

@@ -0,0 +1,9 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { bindHelper, type EffectDispatcher, type JournalHelper, type UnavailableHelper } from "../effect-transport.js";
+
+export type FathomHelper = UnavailableHelper;
+
+export const createFathomHelper = (dispatch: EffectDispatcher): FathomHelper =>
+  bindHelper("fathom", undefined, dispatch);

package/src/helpers/gcp.ts

@@ -0,0 +1,9 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { bindHelper, type EffectDispatcher, type JournalHelper, type UnavailableHelper } from "../effect-transport.js";
+
+export type GcpHelper = UnavailableHelper;
+
+export const createGcpHelper = (dispatch: EffectDispatcher): GcpHelper =>
+  bindHelper("gcp", undefined, dispatch);

package/src/helpers/gcs.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { gcsClient } from "@relayfile/relay-helpers";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type GcsHelper = JournalHelper<ReturnType<typeof gcsClient>>;
+
+export const createGcsHelper = (dispatch: EffectDispatcher): GcsHelper =>
+  bindHelper("gcs", gcsClient, dispatch);

package/src/helpers/github.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { githubClient } from "../helper-clients.js";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type GithubHelper = JournalHelper<ReturnType<typeof githubClient>>;
+
+export const createGithubHelper = (dispatch: EffectDispatcher): GithubHelper =>
+  bindHelper("github", githubClient, dispatch);

package/src/helpers/gitlab.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { gitlabClient } from "@relayfile/relay-helpers";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type GitlabHelper = JournalHelper<ReturnType<typeof gitlabClient>>;
+
+export const createGitlabHelper = (dispatch: EffectDispatcher): GitlabHelper =>
+  bindHelper("gitlab", gitlabClient, dispatch);

package/src/helpers/gmail.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { gmailClient } from "@relayfile/relay-helpers";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type GmailHelper = JournalHelper<ReturnType<typeof gmailClient>>;
+
+export const createGmailHelper = (dispatch: EffectDispatcher): GmailHelper =>
+  bindHelper("gmail", gmailClient, dispatch);

package/src/helpers/google-calendar.ts

@@ -0,0 +1,10 @@
+// GENERATED by scripts/generate-helpers.mjs — do not edit.
+// Run `npm run gen --prefix packages/surface` from the repository root.
+
+import { googleCalendarClient } from "@relayfile/relay-helpers";
+import { bindHelper, type EffectDispatcher, type JournalHelper } from "../effect-transport.js";
+
+export type GoogleCalendarHelper = JournalHelper<ReturnType<typeof googleCalendarClient>>;
+
+export const createGoogleCalendarHelper = (dispatch: EffectDispatcher): GoogleCalendarHelper =>
+  bindHelper("google-calendar", googleCalendarClient, dispatch);