@tangle-network/starter-foundry 0.7.3 → 0.13.2

package/registry/layers/agent-base/tangle/manifest.json

@@ -0,0 +1,103 @@
+{
+  "id": "tangle",
+  "slot": "agent-base",
+  "description": "Tangle floor for every agent-runtime bundle: sandbox-sdk + tcloud + router.tangle.tools as the LLM endpoint. Mandatory for all agent-runtime families \u2014 never opt out, never alternate.",
+  "appliesTo": [
+    "agent-runtime-account-executive-ts",
+    "agent-runtime-architect-ts",
+    "agent-runtime-auditor-ts",
+    "agent-runtime-biology-research-ts",
+    "agent-runtime-business-partner-ts",
+    "agent-runtime-career-coach-ts",
+    "agent-runtime-chef-ts",
+    "agent-runtime-chemistry-research-ts",
+    "agent-runtime-cmo-advisor-ts",
+    "agent-runtime-college-counselor-ts",
+    "agent-runtime-cs-research-ts",
+    "agent-runtime-cs-tutor-ts",
+    "agent-runtime-customer-success-ts",
+    "agent-runtime-data-analyst-ts",
+    "agent-runtime-designer-ts",
+    "agent-runtime-devops-ts",
+    "agent-runtime-doctor-ts",
+    "agent-runtime-engineering-manager-ts",
+    "agent-runtime-essay-coach-ts",
+    "agent-runtime-financial-analyst-ts",
+    "agent-runtime-fitness-coach-ts",
+    "agent-runtime-friend-ts",
+    "agent-runtime-game-designer-ts",
+    "agent-runtime-grant-writer-ts",
+    "agent-runtime-history-tutor-ts",
+    "agent-runtime-illustrator-ts",
+    "agent-runtime-language-tutor-ts",
+    "agent-runtime-legal-counsel-ts",
+    "agent-runtime-math-research-ts",
+    "agent-runtime-math-tutor-ts",
+    "agent-runtime-mediator-ts",
+    "agent-runtime-meditation-coach-ts",
+    "agent-runtime-ml-research-ts",
+    "agent-runtime-music-producer-ts",
+    "agent-runtime-novelist-coach-ts",
+    "agent-runtime-nutritionist-ts",
+    "agent-runtime-pentester-ts",
+    "agent-runtime-pharmacist-ts",
+    "agent-runtime-photographer-ts",
+    "agent-runtime-physics-research-ts",
+    "agent-runtime-product-manager-ts",
+    "agent-runtime-real-estate-ts",
+    "agent-runtime-recruiter-ts",
+    "agent-runtime-relationship-coach-ts",
+    "agent-runtime-research",
+    "agent-runtime-sales-engineer-ts",
+    "agent-runtime-screenwriter-ts",
+    "agent-runtime-security-engineer-ts",
+    "agent-runtime-tax-ts",
+    "agent-runtime-therapist-ts",
+    "agent-runtime-travel-planner-ts",
+    "agent-runtime-veterinarian-ts",
+    "agent-runtime-wealth-manager-ts",
+    "multi-agent-creative-studio-ts",
+    "multi-agent-legal-ops-ts",
+    "multi-agent-product-ops-ts",
+    "multi-agent-research-lab-ts",
+    "multi-agent-startup-team-ts",
+    "agent-eval-harness-ts",
+    "agent-research-harness-ts"
+  ],
+  "provides": [
+    "tangle:base",
+    "tangle:sandbox",
+    "tangle:tcloud",
+    "tangle:router"
+  ],
+  "defaults": {
+    "tangleBase": true,
+    "llmRouterUrl": "https://router.tangle.tools",
+    "sandboxProvider": "tangle",
+    "tcloudAvailable": true,
+    "tangleSandbox": "@tangle-network/sandbox",
+    "tcloudSdk": "@tangle-network/tcloud"
+  },
+  "files": [
+    {
+      "source": "files/lib/tangle.ts",
+      "target": "src/lib/tangle.ts"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "src/lib/tangle.ts"
+    }
+  ],
+  "contextHints": {
+    "commands": [],
+    "entrypoints": [
+      "src/lib/tangle.ts"
+    ],
+    "extensionPoints": [
+      "src/lib/tools/",
+      "templates/"
+    ]
+  }
+}

package/registry/layers/agent-channels/discord/files/channels/discord.env.example

@@ -0,0 +1,14 @@
+# Discord channel adapter
+# DISCORD_BOT_TOKEN: https://discord.com/developers/applications → your app →
+#   Bot → Reset Token. Used as the Authorization: Bot <token> header.
+DISCORD_BOT_TOKEN=
+
+# DISCORD_PUBLIC_KEY: same dashboard → General Information → Public Key (hex).
+#   Used to verify Ed25519 signatures on every inbound interaction. Discord
+#   rejects your endpoint immediately if you don't verify these.
+DISCORD_PUBLIC_KEY=
+
+# After deploy, set Interactions Endpoint URL in the Discord dashboard to:
+#   <your-https-url>/channels/discord
+# Discord will PING the URL once; the adapter returns null for PING so the
+# server should respond with HTTP 200 + body {"type":1}.

package/registry/layers/agent-channels/discord/files/channels/discord.ts

@@ -0,0 +1,127 @@
+// MIT — adapted from nanoclaw (https://github.com/qwibitai/nanoclaw)
+//
+// Discord channel adapter. Verifies Ed25519 signatures on every inbound
+// interaction (Discord requirement — unverified requests get an immediate
+// 401), parses interaction or MESSAGE_CREATE payloads, and sends replies
+// via the REST API.
+//
+// Setup:
+//  1. https://discord.com/developers/applications → New Application.
+//  2. Bot tab → reset token → DISCORD_BOT_TOKEN.
+//  3. General Information → Public Key → DISCORD_PUBLIC_KEY (hex).
+//  4. Set Interactions Endpoint URL to <your-https-url>/channels/discord.
+//     Discord PINGs that URL once with type=1; we respond with type=1.
+
+import { createPublicKey, verify } from 'node:crypto'
+
+const API = 'https://discord.com/api/v10'
+const SIG_HEADER = 'x-signature-ed25519'
+const TS_HEADER = 'x-signature-timestamp'
+
+export interface DiscordInbound {
+  chatId: string
+  text: string
+  sender: string
+}
+
+interface DiscordInteraction {
+  type: number
+  data?: { name?: string; options?: Array<{ name: string; value: unknown }> }
+  channel_id?: string
+  member?: { user?: { id: string; username: string; global_name?: string } }
+  user?: { id: string; username: string; global_name?: string }
+}
+
+interface DiscordMessageCreate {
+  t?: 'MESSAGE_CREATE'
+  d?: {
+    channel_id: string
+    content: string
+    author: { id: string; username: string; global_name?: string; bot?: boolean }
+  }
+}
+
+function botToken(): string {
+  const t = process.env.DISCORD_BOT_TOKEN
+  if (!t) throw new Error('DISCORD_BOT_TOKEN not set')
+  return t
+}
+
+function publicKey(): string {
+  const k = process.env.DISCORD_PUBLIC_KEY
+  if (!k) throw new Error('DISCORD_PUBLIC_KEY not set')
+  return k
+}
+
+/** Verify the Ed25519 signature Discord stamps on every interaction.
+ *  Public key is a 32-byte hex string; signature is a 64-byte hex string;
+ *  payload is `${timestamp}${rawBody}`. */
+function verifyEd25519(rawBody: string, sigHex: string, ts: string, pubKeyHex: string): boolean {
+  if (sigHex.length !== 128 || pubKeyHex.length !== 64) return false
+  // Wrap raw 32-byte Ed25519 public key in a SubjectPublicKeyInfo DER prefix
+  // so node:crypto's KeyObject API will accept it. Prefix is fixed for Ed25519.
+  const prefix = Buffer.from('302a300506032b6570032100', 'hex')
+  const der = Buffer.concat([prefix, Buffer.from(pubKeyHex, 'hex')])
+  const key = createPublicKey({ key: der, format: 'der', type: 'spki' })
+  const data = Buffer.from(`${ts}${rawBody}`, 'utf8')
+  const sig = Buffer.from(sigHex, 'hex')
+  return verify(null, data, key, sig)
+}
+
+/** Parse an inbound Discord webhook (interaction or gateway forward).
+ *  Returns null for PING (Discord verification handshake — caller responds
+ *  with `{type:1}`), bot-authored messages, and non-text events. */
+export async function receive(req: Request): Promise<DiscordInbound | null> {
+  const sig = req.headers.get(SIG_HEADER)
+  const ts = req.headers.get(TS_HEADER)
+  const raw = await req.text()
+  if (!sig || !ts || !verifyEd25519(raw, sig, ts, publicKey())) {
+    throw new Error('discord: signature verification failed')
+  }
+  const body = JSON.parse(raw) as DiscordInteraction & DiscordMessageCreate
+  if (body.type === 1) return null // PING
+  if (body.type === 2 && body.data && body.channel_id) {
+    const u = body.member?.user ?? body.user
+    const text = (body.data.options ?? [])
+      .map((o) => `${o.name}=${String(o.value)}`)
+      .join(' ')
+      .trim()
+    return {
+      chatId: body.channel_id,
+      text: text ? `/${body.data.name} ${text}` : `/${body.data.name ?? 'cmd'}`,
+      sender: u?.global_name ?? u?.username ?? u?.id ?? 'unknown',
+    }
+  }
+  if (body.t === 'MESSAGE_CREATE' && body.d && !body.d.author.bot) {
+    return {
+      chatId: body.d.channel_id,
+      text: body.d.content,
+      sender: body.d.author.global_name ?? body.d.author.username,
+    }
+  }
+  return null
+}
+
+/** Send a message to a Discord channel. Throws on non-2xx so the agent's
+ *  HTTP layer can log it (Discord's body carries `code` + `message`). */
+export async function send(chatId: string, text: string): Promise<void> {
+  const res = await fetch(`${API}/channels/${chatId}/messages`, {
+    method: 'POST',
+    headers: {
+      authorization: `Bot ${botToken()}`,
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify({ content: text }),
+  })
+  if (!res.ok) {
+    const body = await res.text().catch(() => '')
+    throw new Error(`discord postMessage ${res.status}: ${body.slice(0, 200)}`)
+  }
+}
+
+export const channelMeta = {
+  id: 'discord' as const,
+  envVars: ['DISCORD_BOT_TOKEN', 'DISCORD_PUBLIC_KEY'] as const,
+  inbound: 'webhook' as const,
+  outbound: 'POST' as const,
+}

package/registry/layers/agent-channels/discord/manifest.json

@@ -0,0 +1,95 @@
+{
+  "id": "discord",
+  "slot": "agent-channels",
+  "description": "Discord channel adapter \u2014 interactions webhook (Ed25519-verified) + REST send. Composes with any agent-runtime bundle. Set DISCORD_BOT_TOKEN and DISCORD_PUBLIC_KEY at deploy. Discord requires every interaction POST to be verified against the application's public key; reject-loud on failure per Discord's security spec.",
+  "appliesTo": [
+    "agent-runtime-account-executive-ts",
+    "agent-runtime-architect-ts",
+    "agent-runtime-auditor-ts",
+    "agent-runtime-biology-research-ts",
+    "agent-runtime-business-partner-ts",
+    "agent-runtime-career-coach-ts",
+    "agent-runtime-chef-ts",
+    "agent-runtime-chemistry-research-ts",
+    "agent-runtime-cmo-advisor-ts",
+    "agent-runtime-college-counselor-ts",
+    "agent-runtime-cs-research-ts",
+    "agent-runtime-cs-tutor-ts",
+    "agent-runtime-customer-success-ts",
+    "agent-runtime-data-analyst-ts",
+    "agent-runtime-designer-ts",
+    "agent-runtime-devops-ts",
+    "agent-runtime-doctor-ts",
+    "agent-runtime-engineering-manager-ts",
+    "agent-runtime-essay-coach-ts",
+    "agent-runtime-financial-analyst-ts",
+    "agent-runtime-fitness-coach-ts",
+    "agent-runtime-friend-ts",
+    "agent-runtime-game-designer-ts",
+    "agent-runtime-grant-writer-ts",
+    "agent-runtime-history-tutor-ts",
+    "agent-runtime-illustrator-ts",
+    "agent-runtime-language-tutor-ts",
+    "agent-runtime-legal-counsel-ts",
+    "agent-runtime-math-research-ts",
+    "agent-runtime-math-tutor-ts",
+    "agent-runtime-mediator-ts",
+    "agent-runtime-meditation-coach-ts",
+    "agent-runtime-ml-research-ts",
+    "agent-runtime-music-producer-ts",
+    "agent-runtime-novelist-coach-ts",
+    "agent-runtime-nutritionist-ts",
+    "agent-runtime-pentester-ts",
+    "agent-runtime-pharmacist-ts",
+    "agent-runtime-photographer-ts",
+    "agent-runtime-physics-research-ts",
+    "agent-runtime-product-manager-ts",
+    "agent-runtime-real-estate-ts",
+    "agent-runtime-recruiter-ts",
+    "agent-runtime-relationship-coach-ts",
+    "agent-runtime-research",
+    "agent-runtime-sales-engineer-ts",
+    "agent-runtime-screenwriter-ts",
+    "agent-runtime-security-engineer-ts",
+    "agent-runtime-tax-ts",
+    "agent-runtime-therapist-ts",
+    "agent-runtime-travel-planner-ts",
+    "agent-runtime-veterinarian-ts",
+    "agent-runtime-wealth-manager-ts",
+    "multi-agent-creative-studio-ts",
+    "multi-agent-legal-ops-ts",
+    "multi-agent-product-ops-ts",
+    "multi-agent-research-lab-ts",
+    "multi-agent-startup-team-ts"
+  ],
+  "provides": [
+    "channel:discord"
+  ],
+  "requires": [
+    "secure:webhook-in"
+  ],
+  "defaults": {
+    "channelDiscordAvailable": true
+  },
+  "files": [
+    {
+      "source": "files/channels/discord.ts",
+      "target": "channels/discord.ts"
+    },
+    {
+      "source": "files/channels/discord.env.example",
+      "target": "channels/discord.env.example"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "channels/discord.ts"
+    }
+  ],
+  "contextHints": {
+    "extensionPoints": [
+      "channels/discord.ts"
+    ]
+  }
+}

package/registry/layers/agent-channels/gmail/files/channels/gmail.env.example

@@ -0,0 +1,54 @@
+# Gmail channel adapter — OAuth 2.0 (installed-app flow)
+#
+# Why three vars: Google's refresh-token flow requires all three. The agent
+# never sees a user-facing consent screen at runtime; the refresh token is
+# minted once during setup and kept in the secret store.
+#
+# ── One-time setup ─────────────────────────────────────────────────────────
+# 1. Open https://console.cloud.google.com/apis/credentials
+# 2. Create (or pick) a GCP project. Enable the Gmail API:
+#       https://console.cloud.google.com/apis/library/gmail.googleapis.com
+# 3. Configure the OAuth consent screen (External or Internal). Add the scope
+#       https://www.googleapis.com/auth/gmail.modify
+#    (Modify is required because receive() removes the UNREAD label after
+#    fetch. If you only need send(), gmail.send is narrower; mix-and-match
+#    won't work for this adapter.)
+# 4. Create an OAuth 2.0 Client ID, type "Desktop app". Copy the client id
+#    and secret into GMAIL_CLIENT_ID / GMAIL_CLIENT_SECRET below.
+# 5. Mint the refresh token. Easiest path is the OAuth 2.0 Playground:
+#       https://developers.google.com/oauthplayground/
+#    a. Click the gear icon → check "Use your own OAuth credentials" → paste
+#       the client id + secret.
+#    b. In the left panel, scroll to "Gmail API v1" and select
+#       https://www.googleapis.com/auth/gmail.modify
+#    c. Click "Authorize APIs" → sign in with the Gmail account the agent
+#       will speak as → grant consent.
+#    d. Click "Exchange authorization code for tokens". Copy the
+#       refresh_token value into GMAIL_REFRESH_TOKEN below.
+#    Alternative: run a 30-line CLI helper that listens on localhost,
+#    redirects to Google's auth screen, and prints the refresh token. Skipped
+#    here to keep the adapter self-contained — paste-from-Playground works.
+#
+# ── Vars ───────────────────────────────────────────────────────────────────
+GMAIL_CLIENT_ID=
+GMAIL_CLIENT_SECRET=
+GMAIL_REFRESH_TOKEN=
+
+# ── Operational notes ──────────────────────────────────────────────────────
+# • Default path is PULL: call receive() on a timer (every 30–60s is fine for
+#   most inboxes). It returns one message at a time so the agent's runloop
+#   stays simple. Mark-read is part of receive(), so no double-processing.
+#
+# • Push path (Pub/Sub watch) is out of scope for this adapter:
+#     https://developers.google.com/gmail/api/guides/push
+#   It needs a GCP Pub/Sub topic + push subscription + verified domain for
+#   the webhook. If you wire it later, the receive() shape can absorb the
+#   PubsubMessage payload — Gmail's push only delivers a historyId, so you
+#   still call users.history.list to enumerate new messages.
+#
+# • Quota: Gmail API is 1,000,000,000 quota units/day per project (~one query
+#   = 5 units, send = 100). Polling every 30s = 2880 calls/day per agent —
+#   negligible at any reasonable scale.
+#
+# • Domain-wide delegation (Workspace service accounts) is not supported by
+#   this adapter; use the installed-app refresh-token flow above.

package/registry/layers/agent-channels/gmail/files/channels/gmail.ts

@@ -0,0 +1,206 @@
+// MIT — original implementation. Gmail API + Google OAuth 2.0 (installed-app
+// refresh-token flow). Default path is pull-based: poll for unread, fetch,
+// mark read, normalize. Push-based (Pub/Sub watch) is documented in the
+// .env.example but not wired here — the gap is honest: it requires GCP
+// project setup beyond what an .env can express.
+
+const OAUTH_TOKEN_URL = 'https://oauth2.googleapis.com/token'
+const GMAIL_API = 'https://gmail.googleapis.com/gmail/v1/users/me'
+
+export interface GmailInbound {
+  /** Gmail message id — use as the chat/correlation key for replies. */
+  chatId: string
+  text: string
+  sender: string
+  /** RFC 822 Message-Id header, useful for threading replies via In-Reply-To. */
+  messageId?: string
+  /** Original Subject header — populates Subject on the reply if you choose. */
+  subject?: string
+  /** Thread id, for sending into the same Gmail thread. */
+  threadId?: string
+}
+
+interface TokenCache {
+  accessToken: string
+  expiresAt: number
+}
+
+let tokenCache: TokenCache | null = null
+
+function creds() {
+  const clientId = process.env.GMAIL_CLIENT_ID
+  const clientSecret = process.env.GMAIL_CLIENT_SECRET
+  const refreshToken = process.env.GMAIL_REFRESH_TOKEN
+  if (!clientId || !clientSecret || !refreshToken) {
+    throw new Error(
+      'gmail channel: GMAIL_CLIENT_ID, GMAIL_CLIENT_SECRET, GMAIL_REFRESH_TOKEN must all be set',
+    )
+  }
+  return { clientId, clientSecret, refreshToken }
+}
+
+/** Exchange the refresh token for an access token. Caches until ~60s before expiry. */
+async function accessToken(): Promise<string> {
+  if (tokenCache && tokenCache.expiresAt > Date.now() + 60_000) return tokenCache.accessToken
+  const { clientId, clientSecret, refreshToken } = creds()
+  const body = new URLSearchParams({
+    client_id: clientId,
+    client_secret: clientSecret,
+    refresh_token: refreshToken,
+    grant_type: 'refresh_token',
+  })
+  const res = await fetch(OAUTH_TOKEN_URL, {
+    method: 'POST',
+    headers: { 'content-type': 'application/x-www-form-urlencoded' },
+    body,
+  })
+  if (!res.ok) {
+    const detail = await res.text().catch(() => '')
+    throw new Error(`gmail oauth refresh ${res.status}: ${detail.slice(0, 200)}`)
+  }
+  const json = (await res.json()) as { access_token: string; expires_in: number }
+  tokenCache = {
+    accessToken: json.access_token,
+    expiresAt: Date.now() + json.expires_in * 1000,
+  }
+  return tokenCache.accessToken
+}
+
+interface MessagePayload {
+  headers?: Array<{ name: string; value: string }>
+  parts?: MessagePayload[]
+  body?: { data?: string; size?: number }
+  mimeType?: string
+}
+
+interface GmailMessage {
+  id: string
+  threadId: string
+  payload?: MessagePayload
+  snippet?: string
+}
+
+function decodeBase64Url(s: string): string {
+  const pad = s.length % 4 === 0 ? '' : '='.repeat(4 - (s.length % 4))
+  const b64 = s.replace(/-/g, '+').replace(/_/g, '/') + pad
+  // Buffer is available in Node + Workers (via polyfill); fall back to atob.
+  if (typeof Buffer !== 'undefined') return Buffer.from(b64, 'base64').toString('utf8')
+  return atob(b64)
+}
+
+function encodeBase64Url(s: string): string {
+  const b64 = typeof Buffer !== 'undefined' ? Buffer.from(s, 'utf8').toString('base64') : btoa(s)
+  return b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
+}
+
+function header(payload: MessagePayload | undefined, name: string): string | undefined {
+  return payload?.headers?.find((h) => h.name.toLowerCase() === name.toLowerCase())?.value
+}
+
+function extractText(payload: MessagePayload | undefined): string {
+  if (!payload) return ''
+  if (payload.mimeType === 'text/plain' && payload.body?.data) return decodeBase64Url(payload.body.data)
+  for (const part of payload.parts ?? []) {
+    if (part.mimeType === 'text/plain' && part.body?.data) return decodeBase64Url(part.body.data)
+  }
+  // Fallback: first text/* part, even if html.
+  for (const part of payload.parts ?? []) {
+    if (part.mimeType?.startsWith('text/') && part.body?.data) return decodeBase64Url(part.body.data)
+  }
+  return ''
+}
+
+async function gmailGet(path: string): Promise<Response> {
+  const token = await accessToken()
+  return fetch(`${GMAIL_API}${path}`, { headers: { authorization: `Bearer ${token}` } })
+}
+
+async function gmailPost(path: string, body: unknown): Promise<Response> {
+  const token = await accessToken()
+  return fetch(`${GMAIL_API}${path}`, {
+    method: 'POST',
+    headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+}
+
+/** Pull-based receive. Polls for the oldest unread message, fetches it,
+ *  marks it read, and returns the normalized event. Returns null when the
+ *  inbox has no unread mail — caller is expected to retry on a timer. */
+export async function receive(_input?: unknown): Promise<GmailInbound | null> {
+  const listRes = await gmailGet('/messages?q=is%3Aunread&maxResults=1')
+  if (!listRes.ok) {
+    const detail = await listRes.text().catch(() => '')
+    throw new Error(`gmail messages.list ${listRes.status}: ${detail.slice(0, 200)}`)
+  }
+  const list = (await listRes.json()) as { messages?: Array<{ id: string }> }
+  const head = list.messages?.[0]
+  if (!head) return null
+
+  const getRes = await gmailGet(`/messages/${head.id}?format=full`)
+  if (!getRes.ok) {
+    const detail = await getRes.text().catch(() => '')
+    throw new Error(`gmail messages.get ${getRes.status}: ${detail.slice(0, 200)}`)
+  }
+  const msg = (await getRes.json()) as GmailMessage
+
+  // Mark read by removing the UNREAD label. If this fails we still return
+  // the event — but we surface the failure so the caller can de-dupe.
+  const modRes = await gmailPost(`/messages/${head.id}/modify`, { removeLabelIds: ['UNREAD'] })
+  if (!modRes.ok) {
+    const detail = await modRes.text().catch(() => '')
+    throw new Error(`gmail messages.modify ${modRes.status}: ${detail.slice(0, 200)}`)
+  }
+
+  const from = header(msg.payload, 'From') ?? ''
+  return {
+    chatId: msg.id,
+    text: extractText(msg.payload) || msg.snippet || '',
+    sender: from,
+    messageId: header(msg.payload, 'Message-Id'),
+    subject: header(msg.payload, 'Subject'),
+    threadId: msg.threadId,
+  }
+}
+
+/** Send a plain-text reply. `target` is the original Gmail message id from
+ *  receive() — we look up the From + Subject + Message-Id and reply in-thread. */
+export async function send(target: string, text: string): Promise<void> {
+  const getRes = await gmailGet(`/messages/${target}?format=metadata&metadataHeaders=From&metadataHeaders=Subject&metadataHeaders=Message-Id`)
+  if (!getRes.ok) {
+    const detail = await getRes.text().catch(() => '')
+    throw new Error(`gmail send: lookup ${getRes.status}: ${detail.slice(0, 200)}`)
+  }
+  const orig = (await getRes.json()) as GmailMessage
+  const to = header(orig.payload, 'From')
+  if (!to) throw new Error(`gmail send: original message ${target} has no From header`)
+  const origSubject = header(orig.payload, 'Subject') ?? ''
+  const subject = origSubject.toLowerCase().startsWith('re:') ? origSubject : `Re: ${origSubject}`
+  const inReplyTo = header(orig.payload, 'Message-Id')
+
+  const lines = [
+    `To: ${to}`,
+    `Subject: ${subject}`,
+    'Content-Type: text/plain; charset="UTF-8"',
+    'MIME-Version: 1.0',
+  ]
+  if (inReplyTo) {
+    lines.push(`In-Reply-To: ${inReplyTo}`)
+    lines.push(`References: ${inReplyTo}`)
+  }
+  const rfc5322 = `${lines.join('\r\n')}\r\n\r\n${text}`
+  const raw = encodeBase64Url(rfc5322)
+
+  const sendRes = await gmailPost('/messages/send', { raw, threadId: orig.threadId })
+  if (!sendRes.ok) {
+    const detail = await sendRes.text().catch(() => '')
+    throw new Error(`gmail messages.send ${sendRes.status}: ${detail.slice(0, 200)}`)
+  }
+}
+
+export const channelMeta = {
+  id: 'gmail' as const,
+  envVars: ['GMAIL_CLIENT_ID', 'GMAIL_CLIENT_SECRET', 'GMAIL_REFRESH_TOKEN'] as const,
+  inbound: 'pull' as const,
+  outbound: 'POST' as const,
+}