@jonathangu/openclawbrain 0.3.0

package/src/transcript-repair.ts

@@ -0,0 +1,301 @@
+/**
+ * Tool use/result pairing repair for assembled context.
+ *
+ * Copied from openclaw core (src/agents/session-transcript-repair.ts +
+ * src/agents/tool-call-id.ts) to avoid depending on unexported internals.
+ * When the plugin SDK exports sanitizeToolUseResultPairing, this file can
+ * be removed in favor of the SDK import.
+ */
+
+// -- Types (minimal, matching AgentMessage shape) --
+
+type AgentMessageLike = {
+  role: string;
+  content?: unknown;
+  toolCallId?: string;
+  toolUseId?: string;
+  toolName?: string;
+  stopReason?: string;
+  isError?: boolean;
+  timestamp?: number;
+};
+
+type ToolCallLike = {
+  id: string;
+  name?: string;
+};
+
+// -- Extraction helpers (from tool-call-id.ts) --
+
+const TOOL_CALL_TYPES = new Set([
+  "toolCall",
+  "toolUse",
+  "tool_use",
+  "tool-use",
+  "functionCall",
+  "function_call",
+]);
+const OPENAI_FUNCTION_CALL_TYPES = new Set(["functionCall", "function_call"]);
+
+function extractToolCallId(block: { id?: unknown; call_id?: unknown }): string | null {
+  if (typeof block.id === "string" && block.id) {
+    return block.id;
+  }
+  if (typeof block.call_id === "string" && block.call_id) {
+    return block.call_id;
+  }
+  return null;
+}
+
+function normalizeAssistantReasoningBlocks<T extends AgentMessageLike>(message: T): T {
+  if (!Array.isArray(message.content)) {
+    return message;
+  }
+
+  let sawToolCall = false;
+  let reasoningAfterToolCall = false;
+  let functionCallCount = 0;
+
+  for (const block of message.content) {
+    if (!block || typeof block !== "object") {
+      return message;
+    }
+
+    const type = (block as { type?: unknown }).type;
+    if (type === "reasoning" || type === "thinking") {
+      if (sawToolCall) {
+        reasoningAfterToolCall = true;
+      }
+      continue;
+    }
+
+    if (typeof type === "string" && TOOL_CALL_TYPES.has(type)) {
+      sawToolCall = true;
+      if (OPENAI_FUNCTION_CALL_TYPES.has(type)) {
+        functionCallCount += 1;
+      }
+      continue;
+    }
+
+    return message;
+  }
+
+  // Only repair the specific OpenAI shape we need: a single function call that
+  // has one or more reasoning blocks after it. Multi-call turns may use
+  // interleaved reasoning intentionally, so leave them untouched.
+  if (!reasoningAfterToolCall || functionCallCount !== 1) {
+    return message;
+  }
+
+  const reasoning = message.content.filter((block) => {
+    const type = (block as { type?: unknown }).type;
+    return type === "reasoning" || type === "thinking";
+  });
+  const toolCalls = message.content.filter((block) => {
+    const type = (block as { type?: unknown }).type;
+    return typeof type === "string" && TOOL_CALL_TYPES.has(type);
+  });
+
+  return {
+    ...message,
+    content: [...reasoning, ...toolCalls],
+  };
+}
+
+function extractToolCallsFromAssistant(msg: AgentMessageLike): ToolCallLike[] {
+  const content = msg.content;
+  if (!Array.isArray(content)) {
+    return [];
+  }
+
+  const toolCalls: ToolCallLike[] = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") {
+      continue;
+    }
+    const rec = block as { type?: unknown; id?: unknown; call_id?: unknown; name?: unknown };
+    const id = extractToolCallId(rec);
+    if (!id) {
+      continue;
+    }
+    if (typeof rec.type === "string" && TOOL_CALL_TYPES.has(rec.type)) {
+      toolCalls.push({
+        id,
+        name: typeof rec.name === "string" ? rec.name : undefined,
+      });
+    }
+  }
+  return toolCalls;
+}
+
+function extractToolResultId(msg: AgentMessageLike): string | null {
+  if (typeof msg.toolCallId === "string" && msg.toolCallId) {
+    return msg.toolCallId;
+  }
+  if (typeof msg.toolUseId === "string" && msg.toolUseId) {
+    return msg.toolUseId;
+  }
+  return null;
+}
+
+// -- Repair logic (from session-transcript-repair.ts) --
+
+function makeMissingToolResult(params: {
+  toolCallId: string;
+  toolName?: string;
+}): AgentMessageLike {
+  return {
+    role: "toolResult",
+    toolCallId: params.toolCallId,
+    toolName: params.toolName ?? "unknown",
+    content: [
+      {
+        type: "text",
+        text: "[openclawbrain] missing tool result in session history; inserted synthetic error result for transcript repair.",
+      },
+    ],
+    isError: true,
+    timestamp: Date.now(),
+  };
+}
+
+/**
+ * Repair tool use/result pairing in an assembled message transcript.
+ *
+ * Anthropic (and Cloud Code Assist) reject transcripts where assistant tool
+ * calls are not immediately followed by matching tool results. This function:
+ * - Moves matching toolResult messages directly after their assistant toolCall turn
+ * - Inserts synthetic error toolResults for missing IDs
+ * - Drops duplicate toolResults for the same ID
+ * - Drops orphaned toolResults with no matching tool call
+ */
+export function sanitizeToolUseResultPairing<T extends AgentMessageLike>(messages: T[]): T[] {
+  const out: T[] = [];
+  const seenToolResultIds = new Set<string>();
+  let droppedDuplicateCount = 0;
+  let droppedOrphanCount = 0;
+  let moved = false;
+  let changed = false;
+
+  const pushToolResult = (msg: T) => {
+    const id = extractToolResultId(msg);
+    if (id && seenToolResultIds.has(id)) {
+      droppedDuplicateCount += 1;
+      changed = true;
+      return;
+    }
+    if (id) {
+      seenToolResultIds.add(id);
+    }
+    out.push(msg);
+  };
+
+  for (let i = 0; i < messages.length; i += 1) {
+    const msg = messages[i];
+    if (!msg || typeof msg !== "object") {
+      out.push(msg);
+      continue;
+    }
+
+    const role = msg.role;
+    if (role !== "assistant") {
+      if (role !== "toolResult") {
+        out.push(msg);
+      } else {
+        droppedOrphanCount += 1;
+        changed = true;
+      }
+      continue;
+    }
+
+    const normalizedAssistant = normalizeAssistantReasoningBlocks(msg);
+    if (normalizedAssistant !== msg) {
+      changed = true;
+    }
+
+    // Skip tool call extraction for aborted or errored assistant messages.
+    // When stopReason is "error" or "aborted", the tool_use blocks may be incomplete
+    // and should not have synthetic tool_results created.
+    const stopReason = normalizedAssistant.stopReason;
+    if (stopReason === "error" || stopReason === "aborted") {
+      out.push(normalizedAssistant as T);
+      continue;
+    }
+
+    const toolCalls = extractToolCallsFromAssistant(normalizedAssistant);
+    if (toolCalls.length === 0) {
+      out.push(normalizedAssistant as T);
+      continue;
+    }
+
+    const toolCallIds = new Set(toolCalls.map((t) => t.id));
+
+    const spanResultsById = new Map<string, T>();
+    const remainder: T[] = [];
+
+    let j = i + 1;
+    for (; j < messages.length; j += 1) {
+      const next = messages[j];
+      if (!next || typeof next !== "object") {
+        remainder.push(next);
+        continue;
+      }
+
+      const nextRole = next.role;
+      if (nextRole === "assistant") {
+        break;
+      }
+
+      if (nextRole === "toolResult") {
+        const id = extractToolResultId(next);
+        if (id && toolCallIds.has(id)) {
+          if (seenToolResultIds.has(id)) {
+            droppedDuplicateCount += 1;
+            changed = true;
+            continue;
+          }
+          if (!spanResultsById.has(id)) {
+            spanResultsById.set(id, next);
+          }
+          continue;
+        }
+      }
+
+      if (next.role !== "toolResult") {
+        remainder.push(next);
+      } else {
+        droppedOrphanCount += 1;
+        changed = true;
+      }
+    }
+
+    out.push(normalizedAssistant as T);
+
+    if (spanResultsById.size > 0 && remainder.length > 0) {
+      moved = true;
+      changed = true;
+    }
+
+    for (const call of toolCalls) {
+      const existing = spanResultsById.get(call.id);
+      if (existing) {
+        pushToolResult(existing);
+      } else {
+        const missing = makeMissingToolResult({
+          toolCallId: call.id,
+          toolName: call.name,
+        });
+        changed = true;
+        pushToolResult(missing as T);
+      }
+    }
+
+    for (const rem of remainder) {
+      out.push(rem);
+    }
+    i = j - 1;
+  }
+
+  const changedOrMoved = changed || moved;
+  return changedOrMoved ? out : messages;
+}

package/src/types.ts

@@ -0,0 +1,149 @@
+/**
+ * Core type definitions for the LCM plugin.
+ *
+ * These types define the contracts between LCM and OpenClaw core,
+ * abstracting away direct imports from core internals.
+ */
+
+import type { LcmConfig } from "./db/config.js";
+
+/**
+ * Minimal LLM completion interface needed by LCM for summarization.
+ * Matches the signature of completeSimple from @mariozechner/pi-ai.
+ */
+export type CompletionContentBlock = {
+  type: string;
+  text?: string;
+  [key: string]: unknown;
+};
+
+export type CompletionResult = {
+  content: CompletionContentBlock[];
+  [key: string]: unknown;
+};
+
+export type CompleteFn = (params: {
+  provider?: string;
+  model: string;
+  apiKey?: string;
+  providerApi?: string;
+  authProfileId?: string;
+  agentDir?: string;
+  runtimeConfig?: unknown;
+  messages: Array<{ role: string; content: unknown }>;
+  system?: string;
+  maxTokens: number;
+  temperature?: number;
+  reasoning?: string;
+}) => Promise<CompletionResult>;
+
+/**
+ * Gateway RPC call interface.
+ */
+export type CallGatewayFn = (params: {
+  method: string;
+  params?: Record<string, unknown>;
+  timeoutMs?: number;
+}) => Promise<unknown>;
+
+/**
+ * Model resolution function — resolves model aliases and defaults.
+ * When providerHint is supplied, it takes precedence over env/defaults.
+ */
+export type ResolveModelFn = (modelRef?: string, providerHint?: string) => {
+  provider: string;
+  model: string;
+};
+
+/**
+ * API key resolution function.
+ */
+export type ApiKeyLookupOptions = {
+  profileId?: string;
+  preferredProfile?: string;
+};
+
+export type GetApiKeyFn = (
+  provider: string,
+  model: string,
+  options?: ApiKeyLookupOptions,
+) => Promise<string | undefined>;
+
+export type RequireApiKeyFn = (
+  provider: string,
+  model: string,
+  options?: ApiKeyLookupOptions,
+) => Promise<string>;
+
+/**
+ * Session key utilities.
+ */
+export type ParseAgentSessionKeyFn = (sessionKey: string) => {
+  agentId: string;
+  suffix: string;
+} | null;
+
+export type IsSubagentSessionKeyFn = (sessionKey: string) => boolean;
+
+/**
+ * Dependencies injected into the LCM engine at registration time.
+ * These replace all direct imports from OpenClaw core.
+ */
+export interface LcmDependencies {
+  /** LCM configuration (from env vars + plugin config) */
+  config: LcmConfig;
+
+  /** LLM completion function for summarization */
+  complete: CompleteFn;
+
+  /** Gateway RPC call function (for subagent spawning, session ops) */
+  callGateway: CallGatewayFn;
+
+  /** Resolve model alias to provider/model pair */
+  resolveModel: ResolveModelFn;
+
+  /** Get API key for a provider/model pair */
+  getApiKey: GetApiKeyFn;
+
+  /** Require API key (throws if missing) */
+  requireApiKey: RequireApiKeyFn;
+
+  /** Parse agent session key into components */
+  parseAgentSessionKey: ParseAgentSessionKeyFn;
+
+  /** Check if a session key is a subagent key */
+  isSubagentSessionKey: IsSubagentSessionKeyFn;
+
+  /** Normalize an agent ID */
+  normalizeAgentId: (id?: string) => string;
+
+  /** Build system prompt for subagent sessions */
+  buildSubagentSystemPrompt: (params: {
+    depth: number;
+    maxDepth: number;
+    taskSummary?: string;
+  }) => string;
+
+  /** Read the latest assistant reply from a session's messages */
+  readLatestAssistantReply: (messages: unknown[]) => string | undefined;
+
+  /** Sanitize tool use/result pairing in message arrays */
+  // sanitizeToolUseResultPairing removed — now imported directly in assembler from transcript-repair.ts
+
+  /** Resolve the OpenClaw agent directory */
+  resolveAgentDir: () => string;
+
+  /** Resolve runtime session id from an agent session key */
+  resolveSessionIdFromSessionKey: (sessionKey: string) => Promise<string | undefined>;
+
+  /** Agent lane constant for subagents */
+  agentLaneSubagent: string;
+
+  /** Logger */
+  log: {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    debug: (msg: string) => void;
+  };
+}