@ixo/oracle-runtime-workers 0.38.0 → 0.40.1

package/src/core/tool-access.ts

@@ -6,13 +6,8 @@ import type {
   PluginTool,
 } from '../plugin-api/types';
 import type { CapabilityRequirement } from './manifest';
-import type {
-  RegisteredSubAgent,
-  SubAgentRegistry,
-  ToolRegistry,
-} from './registries';
+import type { RegisteredSubAgent } from './registries';
 import { computeSubAgentToolName } from './subagent-as-tool';
-import { NOOP_LOGGER } from './utils';
 
 /** `ctx.ucan.hasCapability` bound to the turn's delegation. */
 export type HasCapability = (resource: string, action: string) => boolean;
@@ -53,8 +48,8 @@ export interface TurnToolAccess<
   /**
    * Plugins that contributed tools or sub-agents of which none is left.
    * Treated like a plugin whose `requires` are unmet (left out of the
-   * prompt, refused by `load_capability`, never preloaded) except that they
-   * are hidden outright: `list_capabilities` does not list them.
+   * prompt, refused by `load_capability`, not offered to the router) except
+   * that they are hidden outright: `list_capabilities` does not list them.
    */
   hiddenPlugins: ReadonlySet<string>;
 }
@@ -145,30 +140,6 @@ export function resolveTurnToolAccess<
   return { tools, subAgents, withheldToolNames, hiddenPlugins };
 }
 
-/**
- * `hiddenPlugins` from the boot-time contributions alone, for the
- * capability router, which predicts before the turn's request-time tools are
- * collected. A plugin whose request-time tools would make it usable may be
- * left out here (the router does not offer it; `load_capability` still
- * can); one whose request-time tools are all withheld may be offered, and
- * the turn's build voids that preload (`createMainAgent`).
- */
-export async function bootHiddenPlugins(input: {
-  registries: { tools: ToolRegistry; subAgents: SubAgentRegistry };
-  buildCtx: PluginContext;
-  has: HasCapability;
-}): Promise<ReadonlySet<string>> {
-  const { registries, buildCtx, has } = input;
-  return resolveTurnToolAccess({
-    tools: await registries.tools.collectBoot(buildCtx),
-    subAgents: registries.subAgents.collectBoot(buildCtx),
-    buildCtx,
-    has,
-    // A failing sub-agent is reported by the turn's build, once.
-    logger: NOOP_LOGGER,
-  }).hiddenPlugins;
-}
-
 /**
  * The manifest as this turn may show it: `examples` naming a withheld tool
  * removed, so neither the Tier-1 prompt nor `load_capability` teaches the

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

@@ -1,5 +1,6 @@
 import { ToolMessage } from '@langchain/core/messages';
 import { Command } from '@langchain/langgraph';
+import { withoutStructuredCopy } from './mcp-result';
 import { capToolResult, type ResultCapConfig } from './middlewares/result-cap';
 import { tool } from '@langchain/core/tools';
 import type { StructuredTool } from 'langchain';
@@ -125,7 +126,7 @@ export function wrapPluginTool(
       );
       if (pluginName !== undefined)
         requireToolPlane(ctx, pluginName, pluginTool);
-      const output = await pluginTool.handler(args, ctx);
+      const output = withoutStructuredCopy(await pluginTool.handler(args, ctx));
       // A tool's own message (a result that says the tool did not run) is
       // returned whole, never capped into text.
       if (

package/src/do/contracts.ts

@@ -1,3 +1,11 @@
+import type {
+  CheckClaimDispatch,
+  CheckDispatch,
+} from '@ixo/action-interactions';
+import type {
+  InteractionCommand,
+  InteractionOutcome,
+} from '../action-interactions/store';
 import type {
   ChannelAttachment,
   ChannelControlInput,
@@ -63,6 +71,7 @@ import type { DomainContextProvenance } from '../core/domain-context';
 
 /** Bindings every oracle Worker must declare (see the example `wrangler.jsonc`). */
 export interface OracleWorkerEnv {
+  ACTION_INTERACTIONS_ENABLED?: string;
   TOPIC_DELIVERABLES_ENABLED?: string;
   ACTION_PROPOSALS_RPC_TESTNET?: string;
   ACTION_PROPOSALS_RPC_DEVNET?: string;
@@ -271,6 +280,8 @@ export interface OracleWorkerEnv {
   LLM_STREAM_IDLE_TIMEOUT_MS?: string;
   LLM_BYO_STREAM_IDLE_TIMEOUT_MS?: string;
   LLM_STREAM_RETRIES?: string;
+  /** Most tokens one platform model call may generate, reasoning included (default 16384; 0 = the model's limit). */
+  LLM_MAX_OUTPUT_TOKENS?: string;
   /** LangGraph steps one turn may take before `GraphRecursionError` (default 600; Node hard-codes 200). */
   TURN_RECURSION_LIMIT?: string;
   /** Turn budget: tool attempts (default 120) and deadline in ms (600000). */
@@ -295,7 +306,12 @@ export interface OracleWorkerEnv {
   MODEL_CONTEXT_TOKENS?: string;
   MODEL_CONTEXT_OVERRIDES?: string;
   CONTEXT_SUMMARIZE_FRACTION?: string;
+  CONTEXT_SUMMARIZE_MAX_TOKENS?: string;
   CONTEXT_PRUNE_FRACTION?: string;
+  CONTEXT_PRUNE_MAX_TOKENS?: string;
+  CONTEXT_STALE_RESULT_TURNS?: string;
+  CONTEXT_CACHE_COLD_MS?: string;
+  CONTEXT_PLUGIN_IDLE_TURNS?: string;
   CONTEXT_RESULT_CAP_FRACTION?: string;
   CONTEXT_RESULT_CAP_MAX_CHARS?: string;
   CONTEXT_REQUEST_FRACTION?: string;
@@ -327,9 +343,14 @@ export interface OracleWorkerEnv {
   /**
    * Capability router (needs a `DECISION_PROVIDER`). `off` (default) never
    * evaluates; `shadow` evaluates and logs the verdict without preloading;
-   * `on` preloads the predicted on-demand plugin's tools for the turn.
+   * `on` loads the predicted plugins on the thread before the first model
+   * call.
    */
   CAPABILITY_ROUTER?: CapabilityRouterMode;
+  /** The score a preload needs on a warm turn (default 0.8; above 1, never). */
+  CAPABILITY_ROUTER_WARM_THRESHOLD?: string;
+  /** The score a preload needs on a cold turn (default 0.7). */
+  CAPABILITY_ROUTER_COLD_THRESHOLD?: string;
   /** Applies exclusively to authenticated channel admission; Portal/Matrix turns never route. */
   CHANNEL_SEMANTIC_ROUTING?: 'off' | 'shadow' | 'on';
   CHANNEL_SEMANTIC_ROUTING_BINDINGS?: string;
@@ -770,6 +791,29 @@ export interface StorageStatus {
  * piped straight to the client.
  */
 export interface UserOracleObject extends Rpc.DurableObjectBranded {
+  readActionInteractionTask(
+    identity: TurnIdentity,
+    sessionId: string,
+    taskId: string,
+  ): Promise<InteractionOutcome<string>>;
+  checkDispatch(
+    identity: TurnIdentity,
+    input: CheckDispatch,
+  ): Promise<InteractionOutcome<string>>;
+  checkClaimDispatch(
+    identity: TurnIdentity,
+    input: CheckClaimDispatch,
+  ): Promise<InteractionOutcome<string>>;
+  actionInteraction(
+    identity: TurnIdentity,
+    command: InteractionCommand,
+  ): Promise<InteractionOutcome<string>>;
+  readActionInteraction(
+    identity: TurnIdentity,
+    sessionId: string,
+    id?: string,
+    references?: boolean,
+  ): Promise<InteractionOutcome<string>>;
   recordHubActionOutcome(outcome: ActionOutcomeV1): Promise<void>;
   topicDeliverable(
     identity: TurnIdentity,

package/src/do/transcript.ts

@@ -140,6 +140,45 @@ export function visibleText(message: BaseMessage): string {
   return contentToText(visibleContent(message));
 }
 
+/**
+ * Whether a stored message is one the user sees in the transcript. System and
+ * tool messages never are, nor a failed reply, nor anything the runtime wrote
+ * for the model about an attachment: the extracted text of a file (an AI
+ * message with an `attachment`) and `view_attachment` re-attaching a payload,
+ * nor a chat gateway's delivery notice.
+ */
+export function visibleToUser(message: BaseMessage): boolean {
+  if (message.type === 'system' || message.type === 'tool') return false;
+  const kw = (message.additional_kwargs ?? {}) as Record<string, unknown>;
+  if (kw.isError) return false;
+  if (message.type === 'ai' && Boolean(kw.attachment)) return false;
+  // A chat gateway's delivery notice: the model's, never a user message.
+  return !isAttachmentViewMessage(message) && !isDeliveryNoticeMessage(message);
+}
+
+/**
+ * The latest turns as the user saw them, oldest first and each as
+ * `user: …` or `assistant: …` cut to `maxChars`, from messages listed newest
+ * first. Only what `visibleToUser` lets through, without summaries and rows
+ * with no visible text.
+ */
+export function recentTurnTexts(
+  newestFirst: readonly BaseMessage[],
+  limit: number,
+  maxChars: number,
+): string[] {
+  const turns: string[] = [];
+  for (const message of newestFirst) {
+    if (turns.length === limit) break;
+    if (isSummarizationMessage(message) || !visibleToUser(message)) continue;
+    const text = visibleText(message).trim();
+    if (!text) continue;
+    const speaker = message.type === 'human' ? 'user' : 'assistant';
+    turns.push(`${speaker}: ${text.slice(0, maxChars)}`);
+  }
+  return turns.reverse();
+}
+
 /**
  * The summarization middleware's bookkeeping message — never shown to users.
  * LangChain 1.4 writes it as a HUMAN message tagged
@@ -171,18 +210,8 @@ export async function transformTranscript(
   for (const message of messages) {
     const toolMsg = message.type === 'tool' ? (message as ToolMessage) : null;
     const kw = (message.additional_kwargs ?? {}) as Record<string, unknown>;
-    const isExtractionContext = message.type === 'ai' && Boolean(kw.attachment);
 
-    if (
-      message.type !== 'system' &&
-      message.type !== 'tool' &&
-      !kw.isError &&
-      !isExtractionContext &&
-      // `view_attachment` re-attaching an offloaded payload — model-facing.
-      !isAttachmentViewMessage(message) &&
-      // A chat gateway's delivery notice — the model's, never a user message.
-      !isDeliveryNoticeMessage(message)
-    ) {
+    if (visibleToUser(message)) {
       const reasoning = reasoningToText(kw.reasoning);
       const attachments =
         message.type === 'human'

package/src/do/turn-metadata.ts

@@ -62,6 +62,16 @@ export interface PriorMetadataState {
   sessionRunId?: string;
   currentEntityDid?: string;
   loadedPlugins?: string[];
+  /** The plugins whose operating guides the prompt carried (`operating-guides.ts`). */
+  promptGuides?: string[];
+  /** The plugins whose usage the thread's messages carry (`operating-guides.ts`). */
+  capabilityUsage?: string[];
+}
+
+function strings(value: unknown): string[] | undefined {
+  return Array.isArray(value)
+    ? value.filter((entry): entry is string => typeof entry === 'string')
+    : undefined;
 }
 
 function priorString(
@@ -75,15 +85,17 @@ function priorString(
 export function priorMetadataState(
   prior: Record<string, unknown>,
 ): PriorMetadataState {
-  const loaded = prior['loadedPlugins'];
+  const loaded = strings(prior['loadedPlugins']);
+  const promptGuides = strings(prior['promptGuides']);
+  const capabilityUsage = strings(prior['capabilityUsage']);
   return {
     editorRoomId: priorString(prior, 'editorRoomId'),
     spaceId: priorString(prior, 'spaceId'),
     sessionRunId: priorString(prior, 'sessionRunId'),
     currentEntityDid: priorString(prior, 'currentEntityDid'),
-    ...(Array.isArray(loaded)
-      ? { loadedPlugins: loaded.filter((p) => typeof p === 'string') }
-      : {}),
+    ...(loaded ? { loadedPlugins: loaded } : {}),
+    ...(promptGuides ? { promptGuides } : {}),
+    ...(capabilityUsage ? { capabilityUsage } : {}),
   };
 }