@ixo/oracle-runtime-workers 0.9.0 → 0.11.0

package/src/core/middlewares/summarization.ts

@@ -1,6 +1,7 @@
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import type { BaseMessage } from '@langchain/core/messages';
 import { type AgentMiddleware, summarizationMiddleware } from 'langchain';
+import type { Logger } from '../../plugin-api/types';
 
 /**
  * IXO-flavoured prompt instructing the summarizer to preserve identifiers
@@ -56,15 +57,41 @@ const DEFAULT_KEEP_MESSAGES = 10;
 export interface SummarizationMiddlewareOptions {
   /** Model used to generate the summary (typically a small/cheap router model). */
   model: BaseChatModel;
-  /** Override the trigger threshold for messages (default: 20). */
-  triggerMessages?: number;
   /**
-   * Also trigger on approximate token count (default: 40k). Message-count
-   * triggers alone miss threads whose few messages carry huge tool outputs.
+   * Trigger threshold in messages. Default 20 when no `triggerTokens` is
+   * given (the legacy pair); `null` disables the message trigger, which is
+   * what a window-derived `triggerTokens` wants (a tool turn is ~4 messages,
+   * so 20 fires after five turns whatever the model's window).
+   */
+  triggerMessages?: number | null;
+  /**
+   * Trigger on approximate token count (chars/4). Default 40k; the main
+   * agent passes a fraction of the model's context window.
    */
   triggerTokens?: number;
   /** Override the number of recent messages to keep (default: 10). */
   keepMessages?: number;
+  /** What the summarizer itself may read (tokens); default LangChain's. */
+  summaryInputTokens?: number;
+  logger?: Pick<Logger, 'warn' | 'log'>;
+}
+
+/**
+ * LangChain's summarizer swallows a failed summary call and returns
+ * `Error generating summary: …` as the summary text — which would then
+ * REPLACE the conversation history with an error string (the model's next
+ * reply reads "I only received an error in the conversation summary").
+ */
+const FAILED_SUMMARY = /^Error generating summary:/;
+
+export function isFailedSummary(message: BaseMessage): boolean {
+  if (!isSummarizationMessage(message)) return false;
+  const { content } = message;
+  if (typeof content !== 'string') return false;
+  const body = content.startsWith(SUMMARY_PREFIX)
+    ? content.slice(SUMMARY_PREFIX.length).trimStart()
+    : content;
+  return FAILED_SUMMARY.test(body);
 }
 
 /**
@@ -86,14 +113,68 @@ export function isSummarizationMessage(message: BaseMessage): boolean {
 export const createSummarizationMiddleware = (
   options: SummarizationMiddlewareOptions,
 ): AgentMiddleware => {
-  return summarizationMiddleware({
+  const triggerMessages =
+    options.triggerMessages === null
+      ? null
+      : (options.triggerMessages ??
+        (options.triggerTokens === undefined
+          ? DEFAULT_TRIGGER_MESSAGES
+          : null));
+  const inner = summarizationMiddleware({
     model: options.model,
     summaryPrompt: SUMMARY_PROMPT,
     summaryPrefix: SUMMARY_PREFIX,
     trigger: [
-      { messages: options.triggerMessages ?? DEFAULT_TRIGGER_MESSAGES },
+      ...(triggerMessages !== null ? [{ messages: triggerMessages }] : []),
       { tokens: options.triggerTokens ?? DEFAULT_TRIGGER_TOKENS },
     ],
     keep: { messages: options.keepMessages ?? DEFAULT_KEEP_MESSAGES },
+    ...(options.summaryInputTokens !== undefined
+      ? { trimTokensToSummarize: options.summaryInputTokens }
+      : {}),
   });
+  const beforeModel = inner.beforeModel;
+  if (!beforeModel) return inner;
+  // The hook is either a bare handler or `{ hook, canJumpTo }`; keep the shape.
+  const handler =
+    typeof beforeModel === 'function' ? beforeModel : beforeModel.hook;
+  // A summary that failed keeps the history exactly as it was: the turn
+  // runs on the full context and the next turn tries again.
+  const guarded: typeof handler = async (state, runtime) => {
+    const update = await handler(state, runtime);
+    const messages =
+      update && typeof update === 'object' && 'messages' in update
+        ? (update as { messages?: unknown }).messages
+        : undefined;
+    const failed = Array.isArray(messages)
+      ? messages.find((m) => isBaseMessageLike(m) && isFailedSummary(m))
+      : undefined;
+    if (failed) {
+      options.logger?.warn(
+        `[summarization] summary failed; keeping the full history this turn: ${String(failed.content).slice(0, 300)}`,
+      );
+      return undefined;
+    }
+    if (Array.isArray(messages) && messages.length > 0)
+      options.logger?.log(
+        `[summarization] condensed the history: ${state.messages.length} messages → a summary + ${messages.length - 2} kept`,
+      );
+    return update;
+  };
+  return {
+    ...inner,
+    beforeModel:
+      typeof beforeModel === 'function'
+        ? guarded
+        : { ...beforeModel, hook: guarded },
+  };
 };
+
+function isBaseMessageLike(value: unknown): value is BaseMessage {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'content' in value &&
+    'additional_kwargs' in value
+  );
+}

package/src/core/middlewares/tool-marks.ts

@@ -0,0 +1,209 @@
+/**
+ * Write-ahead marks for tool calls, and the resume policy built on them.
+ *
+ * Before any tool executes, its call id is recorded (`started`) in the run's
+ * marks; when it returns, the mark is closed (`done`). A run that is resumed
+ * after a reset finds the marks of the previous attempt and the graph about
+ * to execute the same tool calls again (LangGraph re-runs the pending node).
+ * The policy:
+ *
+ *   - a call that never started runs normally;
+ *   - a started, unfinished **write** call is NOT executed again — the model
+ *     gets a synthetic result saying the outcome is unknown, so it can tell
+ *     the user or verify with a read;
+ *   - a started, unfinished **read** call runs again (it has no effect);
+ *   - a call that already finished is not executed again either (its result
+ *     is in the checkpoint's pending writes; reaching here means LangGraph
+ *     could not replay it) — writes get the unknown-outcome result, reads run.
+ *
+ * The middleware also injects, into the first model call after a resume, a
+ * note carrying the tail of the reply the user had already seen, so the
+ * model continues the interrupted reply instead of starting over.
+ */
+import {
+  type BaseMessage,
+  SystemMessage,
+  ToolMessage,
+} from '@langchain/core/messages';
+import { type AgentMiddleware, createMiddleware } from 'langchain';
+import type { ToolEffect, ToolMark } from '../../do/run-store';
+import type { Logger } from '../../plugin-api/types';
+import { NOOP_LOGGER } from '../utils';
+
+export type { ToolEffect };
+
+/** The mark store slice the middleware drives (see `RunStore`). */
+export interface ToolMarkStore {
+  startMark(input: {
+    runId: string;
+    toolCallId: string;
+    toolName: string;
+    effect: ToolEffect;
+  }): Promise<ToolMark | undefined>;
+  bumpMark(runId: string, toolCallId: string): Promise<void>;
+  finishMark(
+    runId: string,
+    toolCallId: string,
+    outcome: 'ok' | 'error' | 'interrupted',
+  ): Promise<void>;
+}
+
+export interface ToolMarksOptions {
+  runId: string;
+  store: ToolMarkStore;
+  /** The effect of a tool by name; unknown tools are writes (see `toolEffectOf`). */
+  effectOf: (toolName: string) => ToolEffect;
+  /**
+   * The reply text the user already received before the run was cut off.
+   * Set only on a resumed attempt; consumed by the first model call.
+   */
+  continuation?: string | null;
+  logger?: Logger;
+}
+
+/** The result handed to the model for a write call whose outcome cannot be known. */
+export function unknownOutcomeToolResult(toolName: string): string {
+  return `The runtime was restarted while ${toolName} was executing, so whether it completed is unknown and it was NOT run again (running it twice could repeat its effect). Tell the user this step may or may not have happened, and verify with a read-only call before repeating it.`;
+}
+
+/** How many trailing characters of the interrupted reply the model is shown. */
+export const CONTINUATION_TAIL_CHARS = 1200;
+
+export function continuationNote(partialText: string): string {
+  const tail =
+    partialText.length > CONTINUATION_TAIL_CHARS
+      ? `…${partialText.slice(-CONTINUATION_TAIL_CHARS)}`
+      : partialText;
+  return (
+    'Your reply to the latest user message was interrupted by a runtime restart. ' +
+    'The user has already received this beginning of it:\n\n' +
+    `"""${tail}"""\n\n` +
+    'Continue from exactly where it stopped, without repeating any of the text above, ' +
+    'without apologising and without mentioning the interruption. If the reply above ' +
+    'was already complete, respond with nothing more than a one-line closing remark.'
+  );
+}
+
+const READ_PREFIXES = [
+  'list_',
+  'get_',
+  'search_',
+  'read_',
+  'preview_',
+  'describe_',
+  'check_',
+  'explain_',
+  'validate_',
+  'view_',
+];
+const READ_NAMES = new Set([
+  'requirements',
+  'flow_status',
+  'compatible_actions',
+  'oracle_list',
+  'vfs_glob',
+  'vfs_grep',
+  'load_capability',
+  'unload_capability',
+]);
+
+/**
+ * Effect classification: an explicit declaration wins; MCP annotations count
+ * when the server sent them; otherwise a conservative name convention marks
+ * the obvious reads and everything else is a write (never re-run on resume).
+ */
+export function toolEffectOf(tool: {
+  name: string;
+  effect?: ToolEffect;
+  annotations?: { readOnlyHint?: boolean; idempotentHint?: boolean };
+}): ToolEffect {
+  if (tool.effect) return tool.effect;
+  if (tool.annotations?.readOnlyHint === true) return 'read';
+  if (READ_NAMES.has(tool.name)) return 'read';
+  // MCP tools arrive as `<server>__<tool>`; classify on the tool part.
+  const bare = tool.name.includes('__')
+    ? tool.name.slice(tool.name.lastIndexOf('__') + 2)
+    : tool.name;
+  if (READ_NAMES.has(bare)) return 'read';
+  for (const prefix of READ_PREFIXES)
+    if (bare.startsWith(prefix)) return 'read';
+  return 'write';
+}
+
+function isErrorResult(output: unknown): boolean {
+  if (ToolMessage.isInstance(output)) return output.status === 'error';
+  return false;
+}
+
+export function createToolMarksMiddleware(
+  options: ToolMarksOptions,
+): AgentMiddleware {
+  const logger = options.logger ?? NOOP_LOGGER;
+  let continuation = options.continuation ?? null;
+  return createMiddleware({
+    name: 'ToolMarksMiddleware',
+    wrapModelCall: async (request, handler) => {
+      if (!continuation || continuation.trim().length === 0)
+        return handler(request);
+      const note = continuationNote(continuation);
+      continuation = null;
+      const messages: BaseMessage[] = [
+        ...request.messages,
+        new SystemMessage(note),
+      ];
+      logger.log(
+        '[tool-marks] resumed run: continuation note added to the first model call',
+      );
+      return handler({ ...request, messages });
+    },
+    wrapToolCall: async (request, handler) => {
+      const { toolCall } = request;
+      const toolCallId = toolCall.id ?? '';
+      const toolName = toolCall.name;
+      if (!toolCallId) return handler(request);
+      const effect = options.effectOf(toolName);
+      const existing = await options.store.startMark({
+        runId: options.runId,
+        toolCallId,
+        toolName,
+        effect,
+      });
+      if (existing) {
+        if (effect === 'write') {
+          logger.warn(
+            `[tool-marks] ${toolName} (${toolCallId}) was ${existing.doneAt ? 'already executed' : 'interrupted mid-execution'} in an earlier attempt of run ${options.runId}; not run again`,
+          );
+          await options.store.finishMark(
+            options.runId,
+            toolCallId,
+            'interrupted',
+          );
+          return new ToolMessage({
+            tool_call_id: toolCallId,
+            name: toolName,
+            content: unknownOutcomeToolResult(toolName),
+            status: 'error',
+          });
+        }
+        logger.log(
+          `[tool-marks] ${toolName} (${toolCallId}) is read-only; running it again after the interruption`,
+        );
+        await options.store.bumpMark(options.runId, toolCallId);
+      }
+      try {
+        const output = await handler(request);
+        await options.store.finishMark(
+          options.runId,
+          toolCallId,
+          isErrorResult(output) ? 'error' : 'ok',
+        );
+        return output;
+      } catch (error) {
+        await options.store
+          .finishMark(options.runId, toolCallId, 'error')
+          .catch(() => undefined);
+        throw error;
+      }
+    },
+  });
+}

package/src/core/openrouter-pricing.ts

@@ -33,6 +33,14 @@ const openRouterModelsSchema = z.object({
           completion: z.string().optional(),
         })
         .optional(),
+      // The model's context window in tokens; `top_provider.context_length`
+      // is the window of the provider OpenRouter routes to by default and
+      // can be smaller than the model's nominal one — the smaller wins.
+      context_length: z.number().nullable().optional(),
+      top_provider: z
+        .object({ context_length: z.number().nullable().optional() })
+        .nullable()
+        .optional(),
     }),
   ),
 });
@@ -40,10 +48,26 @@ const openRouterModelsSchema = z.object({
 interface PriceCache {
   fetchedAt: number;
   prices: Map<string, ModelPrice>;
+  contextLengths: Map<string, number>;
 }
 
 let cache: PriceCache | null = null;
 
+function parseContextLengths(
+  data: z.infer<typeof openRouterModelsSchema>['data'],
+): Map<string, number> {
+  const out = new Map<string, number>();
+  for (const model of data) {
+    const candidates = [
+      model.context_length,
+      model.top_provider?.context_length,
+    ].filter((n): n is number => typeof n === 'number' && n > 0);
+    if (candidates.length === 0) continue;
+    out.set(model.id, Math.floor(Math.min(...candidates)));
+  }
+  return out;
+}
+
 /** Convert an OpenRouter `$/token` string to `$/million tokens`, or `null`. */
 function perMillion(pricePerToken: string | undefined): number | null {
   if (pricePerToken == null) return null;
@@ -106,7 +130,11 @@ export async function fetchOpenRouterPrices(
     if (prices.size === 0) {
       throw new Error('OpenRouter /models returned no usable pricing');
     }
-    cache = { fetchedAt: now(), prices };
+    cache = {
+      fetchedAt: now(),
+      prices,
+      contextLengths: parseContextLengths(parsed.data.data),
+    };
     return prices;
   } catch (error) {
     logger.warn(
@@ -118,6 +146,19 @@ export async function fetchOpenRouterPrices(
   }
 }
 
+/**
+ * Context windows (tokens) by OpenRouter model id, from the same cached
+ * `/models` fetch as the prices (one request serves both). Empty when the
+ * listing is unavailable — the resolver then falls back (see
+ * `context-window.ts`).
+ */
+export async function fetchOpenRouterContextLengths(
+  opts: FetchOpenRouterPricesOptions = {},
+): Promise<ReadonlyMap<string, number>> {
+  await fetchOpenRouterPrices(opts);
+  return cache?.contextLengths ?? new Map<string, number>();
+}
+
 /** Test seam: clear the in-memory price cache between cases. */
 export function resetOpenRouterPriceCache(): void {
   cache = null;

package/src/core/read-result-tool.ts

@@ -0,0 +1,77 @@
+/**
+ * `read_result` — pages through a tool result that was too large for the
+ * context (`result-cap.ts` saved it whole and showed the model a head, a
+ * tail and the handle). Chunks are byte ranges; `next` is the offset of the
+ * following chunk or `null` at the end.
+ */
+import { z } from 'zod';
+import { tool } from '../plugin-api/tool-helper';
+import type { PluginTool } from '../plugin-api/types';
+import type { ReadResultOutcome } from '../do/result-store';
+
+export interface ReadResultToolOptions {
+  read: (
+    id: string,
+    offset: number,
+    length: number,
+  ) => Promise<ReadResultOutcome>;
+  /** Longest chunk this deployment hands back (kept under the result cap). */
+  maxChars: number;
+}
+
+export const READ_RESULT_TOOL_NAME = 'read_result';
+
+export function buildReadResultTool(
+  options: ReadResultToolOptions,
+): PluginTool {
+  const maxChars = Math.max(512, Math.min(options.maxChars, 64 * 1024));
+  const defaultChars = Math.min(4_000, maxChars);
+  const schema = z.object({
+    id: z
+      .string()
+      .regex(/^[a-f0-9]{64}$/)
+      .describe('The saved result id from a "[Result truncated …]" footer.'),
+    offset: z
+      .number()
+      .int()
+      .min(0)
+      .default(0)
+      .describe('Byte offset to read from.'),
+    length: z
+      .number()
+      .int()
+      .min(256)
+      .max(maxChars)
+      .default(defaultChars)
+      .describe(`Bytes to read (max ${maxChars}).`),
+  });
+  return tool(
+    async (rawArgs) => {
+      const { id, offset, length } = schema.parse(rawArgs);
+      const outcome = await options.read(id, offset, length);
+      if (outcome.status !== 'ok')
+        return {
+          error:
+            outcome.status === 'expired'
+              ? 'This saved result has expired; run the tool again to get it back.'
+              : 'No saved result with this id in this session.',
+        };
+      return {
+        id: outcome.id,
+        offset: outcome.offset,
+        length: outcome.length,
+        size: outcome.size,
+        next: outcome.next,
+        text: outcome.text,
+      };
+    },
+    {
+      name: READ_RESULT_TOOL_NAME,
+      effect: 'read',
+      visibility: 'always',
+      description:
+        'Read a saved large tool result in chunks. Use the id from a "[Result truncated …]" footer; start at offset 0 and pass the returned `next` as the offset of the following call until `next` is null.',
+      schema,
+    },
+  );
+}

package/src/core/runtime-context.ts

@@ -81,6 +81,9 @@ export interface MatrixAdapter {
   getEventById(roomId: string, eventId: string): Promise<MatrixEvent>;
   /** See `MatrixGatewayObject.botCredentials`. */
   botCredentials(): Promise<BotCredentials>;
+  /** Group rooms: room kind and channel memory (see `plugin-api/types.ts`). Hosts without a gateway omit them. */
+  roomInfo?: RuntimeContext['matrix']['roomInfo'];
+  channelMemory?: RuntimeContext['matrix']['channelMemory'];
 }
 
 /** LLM adapter — turns role tags into chat models. */
@@ -417,6 +420,10 @@ export function buildRuntimeContext<TConfig = MergedConfig>(
       getRoomState: (roomId) => ambient.matrix.getRoomState(roomId),
       getEventById: (roomId, eventId) =>
         ambient.matrix.getEventById(roomId, eventId),
+      ...(ambient.matrix.roomInfo ? { roomInfo: ambient.matrix.roomInfo } : {}),
+      ...(ambient.matrix.channelMemory
+        ? { channelMemory: ambient.matrix.channelMemory }
+        : {}),
     },
     ucan: {
       hasCapability: (resource, action) =>

package/src/core/sub-agent-fallback.ts

@@ -1,4 +1,4 @@
-import type { StructuredTool } from 'langchain';
+import type { AgentMiddleware, StructuredTool } from 'langchain';
 import type {
   PluginContext,
   PluginSubAgent,
@@ -14,6 +14,7 @@ import type {
 } from './runtime-context';
 import { createSubagentAsTool, type AgentSpec } from './subagent-as-tool';
 import { wrapPluginTool } from './wrap-plugin-tool';
+import type { ResultCapConfig } from './middlewares/result-cap';
 
 /** Inputs for collecting and wrapping sub-agents. */
 export interface CollectSubAgentsInput {
@@ -54,6 +55,10 @@ export interface CollectSubAgentsInput {
    * in name collisions.
    */
   passthroughTools?: StructuredTool[];
+  /** Middlewares every sub-agent's inner graph gets in addition to its own (the durable-run tool marks). */
+  extraMiddleware?: AgentMiddleware[];
+  /** The turn's result cap, applied to every wrapped sub-agent tool (see `wrapPluginTool`). */
+  resultCap?: ResultCapConfig;
   /**
    * Optional pre-collected sub-agent list. When provided, the registry is not
    * queried — callers that need to filter the entries collect from the
@@ -78,6 +83,8 @@ function defaultToAgentSpec(
   sessionId: string,
   sharedFactory: ((ctx: RuntimeContext) => SharedAccessors) | undefined,
   fallbackContext: RunConfigContext | undefined,
+  extraMiddleware?: AgentMiddleware[],
+  resultCap?: ResultCapConfig,
 ): AgentSpec {
   const systemPrompt =
     typeof subAgent.systemPrompt === 'function'
@@ -89,7 +96,13 @@ function defaultToAgentSpec(
     : subAgent.tools(buildCtx);
 
   const tools: StructuredTool[] = pluginTools.map((t) =>
-    wrapPluginTool(t, { ambient, state, sharedFactory, fallbackContext }),
+    wrapPluginTool(t, {
+      ambient,
+      state,
+      sharedFactory,
+      fallbackContext,
+      ...(resultCap ? { resultCap } : {}),
+    }),
   );
 
   const model = ambient.llm.get(subAgent.model ?? 'subagent');
@@ -112,7 +125,7 @@ function defaultToAgentSpec(
     systemPrompt,
     tools,
     model,
-    middleware: subAgent.middlewares,
+    middleware: [...(extraMiddleware ?? []), ...(subAgent.middlewares ?? [])],
     userDid,
     sessionId,
     logger: ambient.logger,
@@ -142,6 +155,8 @@ export async function collectSubAgentsWithFallback(
     toAgentSpec,
     passthroughTools,
     subAgents,
+    extraMiddleware,
+    resultCap,
   } = input;
 
   const entries = subAgents ?? (await registry.collect(buildCtx, rtCtx));
@@ -160,6 +175,8 @@ export async function collectSubAgentsWithFallback(
               sessionId,
               sharedFactory,
               fallbackContext,
+              extraMiddleware,
+              resultCap,
             );
         const withPassthrough: AgentSpec = passthroughTools?.length
           ? { ...spec, passthroughTools }

package/src/core/wrap-plugin-tool.ts

@@ -1,3 +1,5 @@
+import { Command } from '@langchain/langgraph';
+import { capToolResult, type ResultCapConfig } from './middlewares/result-cap';
 import { tool } from '@langchain/core/tools';
 import type { StructuredTool } from 'langchain';
 import type {
@@ -35,6 +37,13 @@ export interface WrapPluginToolOptions {
    * `invoke`/`stream` (the Node runtime does) overrides it.
    */
   fallbackContext?: RunConfigContext;
+  /**
+   * The turn's result cap (result-cap.ts). Applied to the handler's return
+   * value HERE, before LangChain turns it into a ToolMessage, so the SSE
+   * `tool_call` frame, the model and the transcript all carry the same
+   * capped text. Graph commands (`load_capability`) pass through.
+   */
+  resultCap?: ResultCapConfig;
 }
 
 /**
@@ -72,8 +81,14 @@ export function wrapPluginTool(
   pluginTool: PluginTool,
   options: WrapPluginToolOptions,
 ): StructuredTool {
-  const { ambient, state, pluginTitle, sharedFactory, fallbackContext } =
-    options;
+  const {
+    ambient,
+    state,
+    pluginTitle,
+    sharedFactory,
+    fallbackContext,
+    resultCap,
+  } = options;
   const description = pluginTitle
     ? `[${pluginTitle}] ${pluginTool.description}`
     : pluginTool.description;
@@ -89,7 +104,13 @@ export function wrapPluginTool(
         state,
         sharedFactory,
       );
-      return pluginTool.handler(args, ctx);
+      const output = await pluginTool.handler(args, ctx);
+      if (!resultCap || output instanceof Command || output == null)
+        return output;
+      const text = typeof output === 'string' ? output : JSON.stringify(output);
+      if (typeof text !== 'string' || text.length <= resultCap.capChars)
+        return output;
+      return (await capToolResult(text, pluginTool.name, resultCap)).text;
     },
     {
       name: pluginTool.name,

package/src/do/ambient.ts

@@ -141,6 +141,23 @@ export function createMatrixAdapter(
     postEvent: (roomId, eventType, content, opts) =>
       gateway.sendEvent(roomId, eventType, JSON.stringify(content), opts ?? {}),
     botCredentials: () => gateway.botCredentials(),
+    roomInfo: (roomId) => gateway.groupChatRoomInfo(roomId),
+    channelMemory: {
+      recall: async (roomId, limit) =>
+        JSON.parse(await gateway.channelMemoryRecall(roomId, limit)),
+      search: async (roomId, query, limit) =>
+        JSON.parse(await gateway.channelMemorySearch(roomId, query, limit)),
+      pin: async (args) =>
+        JSON.parse(
+          await gateway.channelMemoryPin(
+            args.roomId,
+            args.fact,
+            args.pinnedByDid,
+            args.sourceEventId,
+          ),
+        ),
+      unpin: (roomId, factId) => gateway.channelMemoryUnpin(roomId, factId),
+    },
     getRoomState: async (roomId): Promise<RoomStateSnapshot> => {
       const raw = await gateway.getRoomState(roomId);
       return { roomId, state: JSON.parse(raw) as unknown[] };