@ixo/oracle-runtime-workers 0.26.0 → 0.27.0

package/src/memory/user-context-invalidation.ts

@@ -2,8 +2,8 @@
  * Drops a room's prefetched user context (`UserContextFetcher.invalidate`)
  * after a tool call that changed the user's memory succeeded, so the next
  * session in the room gathers again instead of reading the pre-write answer
- * for the rest of the cache TTL. It never changes the current thread: a
- * thread keeps the context it got on first contact.
+ * for the rest of the cache TTL. Channel turns adopt the refreshed context
+ * on a later turn; other clients keep their first-contact context.
  *
  * Applied as a tool middleware to the main agent and every sub-agent; a
  * failed call (thrown, or an error `ToolMessage`) leaves the cache alone.

package/src/plugins/action-proposals/evidence.ts

@@ -1,8 +1,5 @@
 import type { BaseMessage } from '@langchain/core/messages';
-import {
-  stripTurnTimeNote,
-  TURN_TIME_NOTE_KWARG,
-} from '../../core/turn-time-note';
+import { userContent } from '../../channels/replies';
 import { contentToText } from '../../do/transcript';
 
 /** How many of the user's own messages count as evidence, and how much of each. */
@@ -18,8 +15,10 @@ export const NEGATION =
 
 /**
  * The user's own words from the last few turns. The runtime's time note
- * (`Current time: … 14:05 …`) rides on every message the user sent; it is
- * stripped here so its digits can never stand in for an amount.
+ * (`Current time: … 14:05 …`) rides on every message the user sent, and a
+ * WhatsApp reply carries the quoted message; both are stripped here so
+ * neither the note's digits nor an address or amount the user merely quoted
+ * can stand in for what they typed.
  */
 export function userEvidence(messages: readonly BaseMessage[]): string[] {
   return messages
@@ -27,9 +26,9 @@ export function userEvidence(messages: readonly BaseMessage[]): string[] {
     .slice(-EVIDENCE_MESSAGES)
     .map((m) =>
       contentToText(
-        stripTurnTimeNote(
+        userContent(
           m.content,
-          m.additional_kwargs?.[TURN_TIME_NOTE_KWARG],
+          m.additional_kwargs as Record<string, unknown> | undefined,
         ),
       ).slice(0, EVIDENCE_MESSAGE_CHARS),
     );

package/src/plugins/tasks/middleware.ts

@@ -23,10 +23,7 @@ import type { BaseMessage } from '@langchain/core/messages';
 import { createMiddleware, type AgentMiddleware } from 'langchain';
 import type { Logger, OracleTasksSurface } from '../../plugin-api/types';
 import { pendingApprovalOf } from '../../tasks/store';
-import {
-  stripTurnTimeNote,
-  TURN_TIME_NOTE_KWARG,
-} from '../../core/turn-time-note';
+import { userContent } from '../../channels/replies';
 
 const APPROVE = new Set([
   'yes',
@@ -151,17 +148,15 @@ export function userDidFromContext(context: unknown): string | undefined {
 
 /**
  * Text of the latest HumanMessage — string content or joined text parts —
- * as the user sent it: without the turn time note the runtime puts in front.
+ * as the user sent it: without the turn time note the runtime puts in front,
+ * and without a quoted WhatsApp message (a quoted "yes" is not an approval).
  */
 export function lastHumanText(messages: BaseMessage[]): string | null {
   for (let i = messages.length - 1; i >= 0; i--) {
     const message = messages[i];
     if (!message || message.type !== 'human') continue;
     return textOfContent(
-      stripTurnTimeNote(
-        message.content,
-        message.additional_kwargs?.[TURN_TIME_NOTE_KWARG],
-      ),
+      userContent(message.content, message.additional_kwargs),
     );
   }
   return null;

package/src/shell/app.ts

@@ -19,6 +19,7 @@ import {
 import {
   ChannelError,
   ChannelTurnBody,
+  ChannelControlBody,
   channelRequestHash,
   readChannelBody,
 } from '../channels/contract';
@@ -247,6 +248,7 @@ export function rateLimitKey(
     | 'user'
     | 'poll'
     | 'channel'
+    | 'channel-control'
     | 'action'
     | 'artifact'
     | 'socket'
@@ -455,6 +457,74 @@ export function createShell(
     );
   });
 
+  app.post('/channels/control', async (c) => {
+    try {
+      if (parseChannelServiceDids(c.env.CHANNEL_SERVICE_DID).length === 0)
+        throw new ChannelError(
+          503,
+          'Channels are not configured',
+          'not_configured',
+        );
+      const raw = await readChannelBody(c.req.raw);
+      let json: unknown;
+      try {
+        json = JSON.parse(raw);
+      } catch {
+        throw new ChannelError(400, 'Invalid JSON request', 'invalid_request');
+      }
+      const parsed = ChannelControlBody.safeParse(json);
+      if (!parsed.success)
+        throw new ChannelError(
+          400,
+          'Invalid channel control',
+          'invalid_request',
+        );
+      const identity = await authenticateChannel(
+        c.req.raw.headers,
+        raw,
+        parsed.data,
+        channelAuthConfig(c.env),
+      );
+      if (
+        c.env.RATE_LIMIT &&
+        !(
+          await c.env.RATE_LIMIT.limit({
+            key: rateLimitKey(c.env, 'channel-control', identity.userDid),
+          })
+        ).success
+      )
+        throw new ChannelError(429, 'Too many requests', 'rate_limited');
+      await assertActiveChannelBindingCached(identity, c.env);
+      const outcome = await userStub(c.env, identity.userDid).channelControl(
+        identity,
+        parsed.data,
+        await channelRequestHash(raw),
+      );
+      return outcome.ok
+        ? c.json(outcome.result)
+        : c.json(
+            { code: outcome.code, message: outcome.message },
+            outcome.status,
+          );
+    } catch (error) {
+      if (error instanceof ChannelError)
+        return c.json(
+          { code: error.code, message: error.message },
+          error.status,
+        );
+      console.error(
+        `[channels] control failed: ${describeChannelFailure(error)}`,
+      );
+      return c.json(
+        {
+          code: 'unavailable',
+          message: 'Channel control is temporarily unavailable',
+        },
+        503,
+      );
+    }
+  });
+
   app.use('/api/internal/actions/outcomes', limitBody(64 * 1024));
   // Auth Hub's signed outcome callbacks: on whenever Hub actions are
   // configured. The signature is checked against the Hub's own did:web key

package/src/sqlite/serialization.ts

@@ -13,6 +13,7 @@
  * circular-safe variant, typed.
  */
 import { TURN_TIME_NOTE_KWARG } from '../core/turn-time-note';
+import { CHANNEL_REPLY_NOTE_KWARG } from '../channels/replies';
 
 /**
  * `additional_kwargs` key of the tool calls a mid-turn summary carries for
@@ -259,6 +260,11 @@ export interface CleanAdditionalKwargs {
   lc_source?: string;
   /** The exact time note the turn's content starts with (see core/turn-time-note.ts). */
   turn_time_note?: string;
+  /** The exact quoted-reply note after it (see channels/replies.ts). */
+  channel_reply_note?: string;
+  /** Where a channel message came from, and what it replied to, as the turn recorded them. */
+  'org.ixo.qi.origin'?: unknown;
+  'org.ixo.qi.reply'?: unknown;
   /** Tool calls of the turn a mid-turn summary condensed (newest kept, capped). */
   turn_carry?: unknown[];
   reasoning?: string;
@@ -361,6 +367,20 @@ export function cleanAdditionalKwargs(
   const turnTimeNote = additionalKwargs[TURN_TIME_NOTE_KWARG];
   if (typeof turnTimeNote === 'string')
     cleaned[TURN_TIME_NOTE_KWARG] = turnTimeNote;
+  // Kept for the same reason: without it the quoted text would read as the
+  // person's own words in the transcript, in memory indexing and in the
+  // evidence a proposal is checked against.
+  const replyNote = additionalKwargs[CHANNEL_REPLY_NOTE_KWARG];
+  if (typeof replyNote === 'string')
+    cleaned[CHANNEL_REPLY_NOTE_KWARG] = replyNote;
+  // Channel provenance, read back typed by the transcript (ChannelOrigin,
+  // ChannelReplyReference); anything malformed is dropped there.
+  for (const key of ['org.ixo.qi.origin', 'org.ixo.qi.reply'] as const)
+    if (
+      typeof additionalKwargs[key] === 'object' &&
+      additionalKwargs[key] !== null
+    )
+      cleaned[key] = additionalKwargs[key];
   // Kept so a run resumed after the summary still knows what this turn ran.
   const carry = cappedTurnCarry(additionalKwargs[TURN_CARRY_KWARG]);
   if (carry !== undefined) cleaned[TURN_CARRY_KWARG] = carry;

package/src/sqlite/sessions-store.ts

@@ -65,6 +65,9 @@ type SessionRow = {
   slack_thread_ts: string | null;
 };
 
+/** Ids per statement in `summaries`. */
+const SUMMARY_CHUNK = 50;
+
 type SessionRowWithTotal = SessionRow & { total: number };
 
 const SESSION_COLUMNS = `session_id, title, last_updated_at, created_at, oracle_name,
@@ -242,6 +245,46 @@ export class SessionsStore {
     return rooms;
   }
 
+  /**
+   * Title and times of many sessions, without their heavier columns, in
+   * statements of at most `SUMMARY_CHUNK` ids (a Durable Object binds at most
+   * 100 parameters). Sessions without a row are absent from the map.
+   */
+  async summaries(
+    sessionIds: readonly string[],
+  ): Promise<
+    Map<
+      string,
+      { title: string | null; createdAt: string; lastUpdatedAt: string }
+    >
+  > {
+    const found = new Map<
+      string,
+      { title: string | null; createdAt: string; lastUpdatedAt: string }
+    >();
+    if (sessionIds.length === 0) return found;
+    await this.setup();
+    for (let at = 0; at < sessionIds.length; at += SUMMARY_CHUNK) {
+      const chunk = sessionIds.slice(at, at + SUMMARY_CHUNK);
+      const rows = await this.db.exec<{
+        session_id: string;
+        title: string | null;
+        created_at: string;
+        last_updated_at: string;
+      }>(
+        `SELECT session_id, title, created_at, last_updated_at FROM sessions WHERE session_id IN (${chunk.map(() => '?').join(', ')})`,
+        [...chunk],
+      );
+      for (const row of rows)
+        found.set(row.session_id, {
+          title: row.title,
+          createdAt: row.created_at,
+          lastUpdatedAt: row.last_updated_at,
+        });
+    }
+    return found;
+  }
+
   async getSession(sessionId: string): Promise<SessionRecord | undefined> {
     await this.setup();
     const row = await this.db.get<SessionRow>(