@ixo/oracle-runtime-workers 0.22.0 → 0.24.0

package/src/action-proposals/topic-verify.ts

@@ -0,0 +1,279 @@
+import { withTopicReadBudget } from './topic-budget';
+import { canonicalizeIxoJson } from '@ixo/ixo-transaction/action-proposals';
+import {
+  digestTopicEffect,
+  type TopicActionProposal,
+  type ExpectedTopicEffect,
+  type TopicReceiptReferences,
+} from '@ixo/ixo-transaction/topic-proposals';
+import { assertCreatePlanUnchanged } from '@ixo/ixo-transaction/topic-create-plan';
+import {
+  TopicMatrixEventSchema,
+  assertTopicRoomUnchanged,
+  readTopicEvent,
+  type TopicMatrixReader,
+} from './topic-matrix';
+import { readTopicAuthority } from './topic-history';
+import { TopicChainReader } from './topic-chain';
+import {
+  digestTopicProposalEffect,
+  type TopicProposalStore,
+} from './topic-store';
+import {
+  ActionProposalConflict,
+  TRANSACTION_CARD_BOUND_MISMATCH,
+  TRANSACTION_REJECTIONS,
+} from './store';
+import { TopicReadUnavailable } from './topic-errors';
+import { verifyTopicGrantTransaction } from './verify';
+export type TopicVerificationContext = {
+  reader: TopicMatrixReader;
+  blocksync: string | undefined;
+  rpc: string | undefined;
+  fetcher?: typeof fetch;
+  onAttempt?: () => void;
+  /** An outer wall budget (the alarm tick's) every read here also obeys. */
+  signal?: AbortSignal;
+};
+export async function assertTopicDependencies(
+  proposal: TopicActionProposal,
+  ctx: TopicVerificationContext,
+) {
+  return withTopicReadBudget(
+    ctx.reader,
+    ctx.fetcher ?? fetch,
+    (reader, fetcher) =>
+      assertTopicDependenciesWithinBudget(proposal, {
+        ...ctx,
+        reader,
+        fetcher,
+      }),
+    ctx.signal,
+  );
+}
+async function assertTopicDependenciesWithinBudget(
+  proposal: TopicActionProposal,
+  ctx: TopicVerificationContext,
+) {
+  const room = await assertTopicRoomUnchanged(
+    proposal,
+    ctx.reader,
+    ctx.blocksync,
+    ctx.fetcher,
+  );
+  if (proposal.action.name === 'create_topic') {
+    try {
+      await assertCreatePlanUnchanged(proposal.action.plan);
+    } catch (error) {
+      // The plan builder's own refusals describe the plan's internals; what
+      // the owner is told is that the reviewed plan no longer builds the same.
+      console.warn(
+        `[topic-actions] ${proposal.id} creation plan check: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      throw new ActionProposalConflict(
+        'The reviewed topic creation plan changed',
+      );
+    }
+    return;
+  }
+  if (!ctx.rpc)
+    throw new TopicReadUnavailable('Trusted chain endpoint unavailable');
+  const action = proposal.action;
+  // The room state just read is the state the authority is judged on: one
+  // state read, not two.
+  const topic = await readTopicAuthority(
+    ctx.reader,
+    action.roomId,
+    action.topicId,
+    action.owner.matrixUserId,
+    room.state,
+  );
+  const chain = new TopicChainReader(ctx.rpc, action.chainId, ctx.fetcher);
+  const collection = await chain.collection(
+    action.entityDid,
+    action.collectionId,
+    action.signerAddress,
+  );
+  // One authorization query per grant, all at once: the ten second budget
+  // has to cover the topic history and the collection reads as well.
+  const authorizations = await Promise.all(
+    action.grants.map((grant) =>
+      chain.authorization(action.adminAddress, grant.address, grant.role),
+    ),
+  );
+  const current: TopicActionProposal['action']['dependencies'] = [
+    ...topic.dependencies,
+    ...collection.dependencies,
+    ...authorizations.map((a) => a.dependency),
+  ];
+  for (const dep of action.dependencies.filter((d) => d.kind !== 'matrix'))
+    if (
+      !current.some(
+        (d) =>
+          d.kind === dep.kind && d.key === dep.key && d.digest === dep.digest,
+      )
+    )
+      // A fact the card was sealed on moved: a conflict the Portal can show
+      // and retry after a re-read, not a server fault.
+      throw new ActionProposalConflict('Topic or chain authority changed');
+}
+export async function verifyTopicReference(
+  proposal: TopicActionProposal,
+  effect: ExpectedTopicEffect,
+  reference: TopicReceiptReferences['references'][number],
+  ctx: TopicVerificationContext,
+) {
+  if (effect.kind === 'chain') {
+    if (reference.kind !== 'chain' || !ctx.rpc)
+      throw new ActionProposalConflict('Expected a chain reference');
+    const verified = await verifyTopicGrantTransaction(
+      effect,
+      reference.transactionHash,
+      ctx.rpc,
+      ctx.fetcher,
+    );
+    return {
+      kind: 'chain' as const,
+      chainId: effect.chainId,
+      ...verified,
+      messageDigest: await digestTopicEffect(effect),
+    };
+  }
+  if (reference.kind !== 'matrix')
+    throw new ActionProposalConflict('Expected a Matrix reference');
+  const event = await readTopicEvent(
+    ctx.reader,
+    effect.roomId,
+    reference.eventId,
+  );
+  if (
+    event.event_id !== reference.eventId ||
+    event.room_id !== effect.roomId ||
+    event.sender !== effect.sender ||
+    event.type !== effect.eventType ||
+    event.state_key !== effect.stateKey ||
+    canonicalizeIxoJson(event.content) !== canonicalizeIxoJson(effect.content)
+  )
+    throw new ActionProposalConflict(
+      'Matrix receipt does not match the reviewed effect',
+    );
+  if (reference.step === 'snapshot') {
+    const state = await ctx.reader.state(effect.roomId);
+    const { z } = await import('zod');
+    const events = z.array(TopicMatrixEventSchema).parse(state);
+    if (
+      !events.some(
+        (e) =>
+          e.event_id === event.event_id &&
+          e.state_key === effect.stateKey &&
+          e.type === effect.eventType,
+      )
+    )
+      throw new ActionProposalConflict(
+        'Topic snapshot was replaced before verification',
+      );
+    if (proposal.action.name === 'create_topic') {
+      const current = await readTopicAuthority(
+        ctx.reader,
+        effect.roomId,
+        proposal.action.plan.identity.topicId,
+        effect.sender,
+      );
+      if (
+        current.authority.revision !==
+          proposal.action.plan.identity.operationId ||
+        current.authority.contractBodyHash !== proposal.action.plan.bodyHash
+      )
+        throw new ActionProposalConflict(
+          'Created topic is not canonically readable',
+        );
+    }
+  }
+  return {
+    kind: 'matrix' as const,
+    roomId: effect.roomId,
+    eventId: event.event_id,
+    sender: event.sender,
+    eventType: event.type,
+    ...(event.state_key !== undefined ? { stateKey: event.state_key } : {}),
+    contentDigest: await digestTopicProposalEffect(event.content),
+    verifiedAt: new Date().toISOString(),
+  };
+}
+export async function reconcileTopicReferences(
+  store: TopicProposalStore,
+  p: TopicActionProposal,
+  input: TopicReceiptReferences,
+  ctx: TopicVerificationContext,
+  verificationClaimed = false,
+) {
+  let newReference = false;
+  for (const reference of input.references) {
+    newReference ||= !(await store.hasReference(
+      p.ownerDid,
+      p.id,
+      reference.step,
+    ));
+    await store.recordReference(p.ownerDid, p.id, reference);
+  }
+  const claimed =
+    verificationClaimed || (await store.claimVerification(p.ownerDid, p.id));
+  if (!claimed && !newReference)
+    return (await store.get(p.ownerDid, p.id)) ?? p;
+  ctx.onAttempt?.();
+  return withTopicReadBudget(
+    ctx.reader,
+    ctx.fetcher ?? fetch,
+    (reader, fetcher) =>
+      reconcileWithinBudget(store, p, input, { ...ctx, reader, fetcher }),
+    ctx.signal,
+  ).catch(async () => (await store.get(p.ownerDid, p.id)) ?? p);
+}
+async function reconcileWithinBudget(
+  store: TopicProposalStore,
+  p: TopicActionProposal,
+  input: TopicReceiptReferences,
+  ctx: TopicVerificationContext,
+) {
+  let current = p;
+  const all = [
+    ...input.references,
+    ...(await store.references(p.ownerDid, p.id)).filter(
+      (r) => !input.references.some((s) => s.step === r.step),
+    ),
+  ];
+  for (const reference of all) {
+    const effect = await store.recordReference(p.ownerDid, p.id, reference);
+    try {
+      const receipt = await verifyTopicReference(
+        current,
+        effect,
+        reference,
+        ctx,
+      );
+      current = await store.verifyStep(
+        p.ownerDid,
+        p.id,
+        reference.step,
+        receipt,
+      );
+    } catch (error) {
+      if (reference.kind === 'chain' && error instanceof Error) {
+        if (error.message === TRANSACTION_CARD_BOUND_MISMATCH)
+          // The transaction carries THIS card's memo and other messages: an
+          // effect the owner bound to the card went wrong. It stays listed
+          // and the card is blocked, never re-permitted over it.
+          await store.blockExecution(p.ownerDid, p.id, error.message);
+        else if (TRANSACTION_REJECTIONS.has(error.message))
+          // Provably another transaction (the chain holds it under another
+          // card's memo or none): set aside so the owner can record the
+          // right one.
+          await store.rejectReference(p.ownerDid, p.id, reference);
+      }
+      // A read that failed or a transaction not indexed yet is retried on
+      // the cooldown.
+      current = (await store.get(p.ownerDid, p.id)) ?? current;
+    }
+  }
+  return current;
+}

package/src/action-proposals/verify.ts

@@ -0,0 +1,223 @@
+import protobuf from 'protobufjs/minimal.js';
+import { boundedBytes } from '../core/domain-context/transport';
+import {
+  TxRaw,
+  TxBody,
+} from '@ixo/impactxclient-sdk/module/codegen/cosmos/tx/v1beta1/tx.js';
+import { MsgSend } from '@ixo/impactxclient-sdk/module/codegen/cosmos/bank/v1beta1/tx.js';
+import { MsgTransferToken } from '@ixo/impactxclient-sdk/module/codegen/ixo/token/v1beta1/tx.js';
+import type { ExpectedTopicEffect } from '@ixo/ixo-transaction/topic-proposals';
+import type { ActionProposal } from '@ixo/ixo-transaction/action-proposals';
+import { z } from 'zod';
+
+const TxResponse = z.object({
+  result: z.object({
+    hash: z.string().regex(/^[a-fA-F0-9]{64}$/),
+    height: z.string().regex(/^[1-9]\d*$/),
+    tx: z.string().min(1).max(1_000_000),
+    tx_result: z.object({ code: z.number().int().nonnegative() }),
+  }),
+});
+const StatusResponse = z.object({
+  result: z.object({ node_info: z.object({ network: z.string().min(1) }) }),
+});
+const decode64 = (value: string) =>
+  Uint8Array.from(atob(value), (c) => c.charCodeAt(0));
+const hex = (bytes: Uint8Array) =>
+  Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+const equal = (a: Uint8Array, b: Uint8Array) =>
+  a.length === b.length && a.every((v, i) => v === b[i]);
+export type VerifiedActionTransaction = {
+  transactionHash: string;
+  height: number;
+  code: number;
+  verifiedAt: string;
+};
+
+/**
+ * How long a chain RPC's answer to `/status` is trusted per isolate: the
+ * network an origin serves does not change between lookups, and `/status`
+ * would otherwise be half of all verification traffic.
+ */
+export const CHAIN_NETWORK_CACHE_MS = 5 * 60_000;
+const chainNetworks = new Map<string, { network: string; at: number }>();
+/** Tests only: forget every cached `/status` answer. */
+export function resetChainNetworkCache(): void {
+  chainNetworks.clear();
+}
+/**
+ * The network (chain id) an RPC origin serves, from `/status`, cached per
+ * isolate for `CHAIN_NETWORK_CACHE_MS`. Only a parsed answer is cached; a
+ * failed read is retried on the next lookup.
+ */
+export async function chainNetwork(
+  origin: string,
+  readStatus: () => Promise<unknown>,
+  now = Date.now(),
+): Promise<string> {
+  const cached = chainNetworks.get(origin);
+  if (cached && now - cached.at < CHAIN_NETWORK_CACHE_MS) return cached.network;
+  const network = StatusResponse.parse(await readStatus()).result.node_info
+    .network;
+  chainNetworks.set(origin, { network, at: now });
+  return network;
+}
+
+/**
+ * The node does not hold the transaction (yet): not indexed, or not
+ * broadcast. CometBFT answers `/tx` for an unknown hash with a JSON-RPC
+ * error whose text says "not found" (HTTP 200 or 500 by version).
+ */
+export const TRANSACTION_NOT_FOUND = 'Transaction not found';
+function isTransactionNotFound(text: string): boolean {
+  try {
+    const body = JSON.parse(text) as {
+      error?: { message?: unknown; data?: unknown };
+    };
+    return (
+      !!body.error &&
+      /not found/i.test(`${body.error.message ?? ''} ${body.error.data ?? ''}`)
+    );
+  } catch {
+    return false;
+  }
+}
+
+export async function verifyActionTransaction(
+  proposal: ActionProposal,
+  transactionHash: string,
+  rpcOrigin: string,
+  fetcher: typeof fetch = fetch,
+  /** The caller's wall budget (the alarm's); each read also stops at 10 s. */
+  signal?: AbortSignal,
+): Promise<VerifiedActionTransaction> {
+  return verifyTransaction(
+    proposal.action.chainId,
+    proposal.action.inputs.messages.map((expected) => {
+      const value =
+        expected.typeUrl === '/cosmos.bank.v1beta1.MsgSend'
+          ? MsgSend.encode(
+              MsgSend.fromJSON(expected.value),
+              new protobuf.Writer(),
+            ).finish()
+          : expected.typeUrl === '/ixo.token.v1beta1.MsgTransferToken'
+            ? MsgTransferToken.encode(
+                MsgTransferToken.fromJSON(expected.value),
+                new protobuf.Writer(),
+              ).finish()
+            : undefined;
+      if (!value) throw new Error('Unsupported message');
+      return { typeUrl: expected.typeUrl, value };
+    }),
+    proposal.id,
+    transactionHash,
+    rpcOrigin,
+    fetcher,
+    signal,
+  );
+}
+export async function verifyTopicGrantTransaction(
+  effect: Extract<ExpectedTopicEffect, { kind: 'chain' }>,
+  transactionHash: string,
+  rpcOrigin: string,
+  fetcher: typeof fetch = fetch,
+  signal?: AbortSignal,
+): Promise<VerifiedActionTransaction> {
+  return verifyTransaction(
+    effect.chainId,
+    effect.messages.map((m) => ({
+      typeUrl: m.typeUrl,
+      value: decode64(m.valueBase64),
+    })),
+    effect.memo,
+    transactionHash,
+    rpcOrigin,
+    fetcher,
+    signal,
+  );
+}
+async function verifyTransaction(
+  chainId: string,
+  messages: { typeUrl: string; value: Uint8Array }[],
+  memo: string,
+  transactionHash: string,
+  rpcOrigin: string,
+  fetcher: typeof fetch,
+  signal?: AbortSignal,
+): Promise<VerifiedActionTransaction> {
+  const origin = new URL(rpcOrigin);
+  if (
+    origin.protocol !== 'https:' ||
+    origin.username ||
+    origin.password ||
+    origin.search ||
+    origin.hash
+  )
+    throw new Error('Expected configured HTTPS RPC origin');
+  const request = async (path: string, notFound = false) => {
+    const response = await fetcher(
+      new URL(path, `${origin.href.replace(/\/$/, '')}/`),
+      {
+        redirect: 'error',
+        signal: signal
+          ? AbortSignal.any([signal, AbortSignal.timeout(10_000)])
+          : AbortSignal.timeout(10_000),
+      },
+    );
+    if (notFound && response.status === 404)
+      throw new Error(TRANSACTION_NOT_FOUND);
+    if (!response.ok && !notFound)
+      throw new Error('Chain verification unavailable');
+    const text = new TextDecoder().decode(
+      await boundedBytes(response, 1_500_000),
+    );
+    if (notFound && isTransactionNotFound(text))
+      throw new Error(TRANSACTION_NOT_FOUND);
+    if (!response.ok) throw new Error('Chain verification unavailable');
+    return JSON.parse(text) as unknown;
+  };
+  const network = await chainNetwork(origin.href, () => request('status'));
+  if (network !== chainId) throw new Error('Chain mismatch');
+  const tx = TxResponse.parse(
+    await request(
+      `tx?hash=0x${transactionHash.toUpperCase()}&prove=false`,
+      true,
+    ),
+  ).result;
+  const bytes = decode64(tx.tx);
+  const digest = hex(
+    new Uint8Array(await crypto.subtle.digest('SHA-256', bytes)),
+  );
+  if (
+    digest !== transactionHash.toLowerCase() ||
+    tx.hash.toLowerCase() !== digest
+  )
+    throw new Error('Transaction hash mismatch');
+  const raw = TxRaw.decode(bytes);
+  if (raw.signatures.length === 0) throw new Error('Unsigned transaction');
+  const body = TxBody.decode(raw.bodyBytes);
+  // The memo binds the transaction to its card (the card id for a transfer,
+  // the frozen topic memo for a grant): a transaction signed for another
+  // card, or with no card at all, never verifies this one.
+  if (body.memo !== memo) throw new Error('Transaction memo mismatch');
+  if (body.messages.length !== messages.length)
+    throw new Error('Transaction subject mismatch');
+  for (let i = 0; i < messages.length; i++) {
+    const actual = body.messages[i]!;
+    const expected = messages[i]!;
+    if (
+      actual.typeUrl !== expected.typeUrl ||
+      !equal(actual.value, expected.value)
+    )
+      throw new Error('Transaction subject mismatch');
+  }
+  const height = Number(tx.height);
+  if (!Number.isSafeInteger(height))
+    throw new Error('Invalid transaction height');
+  return {
+    transactionHash: transactionHash.toUpperCase(),
+    height,
+    code: tx.tx_result.code,
+    verifiedAt: new Date().toISOString(),
+  };
+}

package/src/channels/auth.ts

@@ -238,7 +238,12 @@ export function channelAuthConfig(
 const BindingVerdict = z.strictObject({ active: z.boolean() });
 
 export async function assertActiveChannelBinding(
-  identity: TurnIdentity,
+  identity: Pick<TurnIdentity, 'userDid'> & {
+    channel?: Pick<
+      NonNullable<TurnIdentity['channel']>,
+      'provider' | 'bindingId' | 'bindingRevision'
+    >;
+  },
   env: Pick<
     OracleWorkerEnv,
     'ORACLE_DID' | 'AUTH_HUB_CHANNEL_SERVICE_KEY' | 'AUTH_HUB' | 'AUTH_HUB_URL'

package/src/channels/contract.ts

@@ -1,3 +1,5 @@
+import type { ActionOutcomeWire } from '@ixo/ixo-transaction/topic-proposals';
+import type { ActionOutcomeV1 } from '@ixo/action-protocol';
 import { z } from 'zod';
 import type { ReplyPlan } from '../delivery/types';
 
@@ -76,6 +78,8 @@ export interface ChannelTurnResponse {
    * message for gateways that predate plans.
    */
   plan?: ReplyPlan;
+  actionOutcomes?: ActionOutcomeWire[];
+  hubActionOutcomes?: ActionOutcomeV1[];
 }
 
 export type ChannelErrorStatus =

package/src/channels/turns.ts

@@ -640,6 +640,7 @@ export class ChannelTurns {
       channel: {
         provider: input.provider,
         bindingId: input.bindingId,
+        bindingRevision: input.bindingRevision,
         remoteMessageRef: input.remoteMessageRef,
       },
     });

package/src/core/env.ts

@@ -73,14 +73,66 @@ const secureUrlSchema = z.string().refine((raw) => isSecureUrl(raw), {
   message: 'must be an https URL (http only on localhost)',
 });
 
+/**
+ * An https base URL for a chain RPC (a path such as `/rpc/` is fine): no
+ * credentials, query or fragment, which the verifier would refuse at the
+ * first lookup otherwise.
+ */
+const rpcOriginSchema = z.string().refine(
+  (raw) => {
+    try {
+      const url = new URL(raw);
+      return (
+        url.protocol === 'https:' &&
+        !url.username &&
+        !url.password &&
+        !url.search &&
+        !url.hash
+      );
+    } catch {
+      return false;
+    }
+  },
+  { message: 'must be an https URL without credentials, query or fragment' },
+);
+/** The Portal origin action links point at: https, host only. */
+const portalOriginSchema = z.string().refine(
+  (raw) => {
+    try {
+      const url = new URL(raw);
+      return (
+        url.protocol === 'https:' &&
+        url.pathname === '/' &&
+        !url.username &&
+        !url.password &&
+        !url.search &&
+        !url.hash
+      );
+    } catch {
+      return false;
+    }
+  },
+  { message: 'must be an https origin with no path, query or fragment' },
+);
+
 export const baseEnvSchema = z.object({
+  // --- action proposals (src/action-proposals, docs/action-proposals.md) ---
+  ACTION_PROPOSALS_RPC_TESTNET: rpcOriginSchema.optional(),
+  ACTION_PROPOSALS_RPC_DEVNET: rpcOriginSchema.optional(),
+  ACTION_PROPOSALS_RPC_MAINNET: rpcOriginSchema.optional(),
+  ACTION_PROPOSALS_ENABLED: z.enum(['true', 'false']).default('false'),
+  ACTION_TOPIC_PROPOSALS_ENABLED: z.enum(['true', 'false']).default('false'),
+  ACTION_PROPOSALS_PORTAL_ORIGIN: portalOriginSchema.optional(),
   // --- identity -----------------------------------------------------------
   ORACLE_NAME: z.string().min(1),
   /** UCAN audience — the DID users address invocations/delegations to. */
   ORACLE_DID: z.string().min(1),
   /**
    * On-chain entity DID surfaced to the agent as `identity.entityDid`. Falls
-   * back to `ORACLE_DID` when unset (see `createRuntimeCore`).
+   * back to `ORACLE_DID` when unset (see `createRuntimeCore`) for rooms and
+   * feedback. The memory plugin redeclares it as required
+   * (`did:ixo:entity:<32 hex>`): the Memory Engine keys every space by it and
+   * never receives the fallback.
    */
   ORACLE_ENTITY_DID: z.string().min(1).optional(),
   NETWORK: z.enum(['mainnet', 'testnet', 'devnet']).default('mainnet'),
@@ -454,11 +506,10 @@ export function validateEnv(
 ): ValidateEnvResult {
   const result = schema.safeParse(env);
   if (result.success) {
-    return {
-      valid: true,
-      config: result.data,
-      errors: [],
-    };
+    const errors = actionProposalEnvErrors(result.data);
+    return errors.length
+      ? { valid: false, config: {}, errors }
+      : { valid: true, config: result.data, errors: [] };
   }
 
   const errors: ValidateEnvError[] = result.error.issues.map((issue) => {
@@ -470,3 +521,39 @@ export function validateEnv(
 
   return { valid: false, config: {}, errors };
 }
+
+/**
+ * Switching action proposals on without the settings they run on is a
+ * configuration error, not a runtime clarification: a card could be
+ * prepared with no link to review it at, or signed and never verified.
+ */
+function actionProposalEnvErrors(
+  config: Record<string, unknown>,
+): ValidateEnvError[] {
+  const errors: ValidateEnvError[] = [];
+  const enabled = config['ACTION_PROPOSALS_ENABLED'] === 'true';
+  if (enabled && !config['ACTION_PROPOSALS_PORTAL_ORIGIN'])
+    errors.push({
+      plugin: 'core',
+      field: 'ACTION_PROPOSALS_PORTAL_ORIGIN',
+      message: 'required when ACTION_PROPOSALS_ENABLED is true',
+    });
+  if (
+    enabled &&
+    !config['ACTION_PROPOSALS_RPC_DEVNET'] &&
+    !config['ACTION_PROPOSALS_RPC_TESTNET']
+  )
+    errors.push({
+      plugin: 'core',
+      field: 'ACTION_PROPOSALS_RPC_TESTNET',
+      message:
+        'ACTION_PROPOSALS_RPC_DEVNET or ACTION_PROPOSALS_RPC_TESTNET is required when ACTION_PROPOSALS_ENABLED is true',
+    });
+  if (config['ACTION_TOPIC_PROPOSALS_ENABLED'] === 'true' && !enabled)
+    errors.push({
+      plugin: 'core',
+      field: 'ACTION_TOPIC_PROPOSALS_ENABLED',
+      message: 'requires ACTION_PROPOSALS_ENABLED=true',
+    });
+  return errors;
+}

package/src/core/main-agent-types.ts

@@ -42,6 +42,14 @@ export const mainAgentRequestContextSchema = z.object({
     id: z.string(),
     client: z.enum(['portal', 'matrix', 'slack', 'channel']),
     requestId: z.string(),
+    runId: z.string().optional(),
+    channel: z
+      .object({
+        provider: z.string(),
+        bindingId: z.string(),
+        bindingRevision: z.number().int().positive(),
+      })
+      .optional(),
     wsId: z.string().optional(),
     roomId: z.string().optional(),
   }),

package/src/core/main-agent.ts

@@ -300,6 +300,8 @@ export async function createMainAgent(
         id: requestCtx.session.id,
         client: requestCtx.session.client,
         requestId: requestCtx.session.requestId,
+        runId: requestCtx.session.runId,
+        channel: requestCtx.session.channel,
         wsId: requestCtx.session.wsId,
         roomId: requestCtx.session.roomId,
         ...(surface ? { surface } : {}),