@martian-engineering/lossless-claw 0.8.0 → 0.8.2

package/src/transaction-mutex.ts

@@ -1,136 +0,0 @@
-/**
- * Per-database async transaction mutex.
- *
- * Hotfix for https://github.com/Martian-Engineering/lossless-claw/issues/260
- *
- * Problem: Multiple async operations (from different sessions) share one
- * synchronous DatabaseSync handle. SQLite does not support nested transactions.
- * When two async code paths both try to BEGIN while an earlier BEGIN is still
- * in-flight (awaiting async work inside the transaction), the second BEGIN
- * fails with "cannot start a transaction within a transaction".
- *
- * Solution: A per-database async mutex that serializes all explicit transaction
- * entry points. Uses a WeakMap keyed on the DatabaseSync instance so each
- * database gets its own queue, and databases are garbage-collected normally.
- */
-
-import { AsyncLocalStorage } from "node:async_hooks";
-import type { DatabaseSync } from "node:sqlite";
-
-interface MutexState {
-  /** Tail of the promise chain — each acquirer appends to this. */
-  tail: Promise<void>;
-}
-
-const mutexMap = new WeakMap<DatabaseSync, MutexState>();
-const heldLockContext = new AsyncLocalStorage<Map<DatabaseSync, number>>();
-
-let nextSavepointId = 0;
-
-function getOrCreateMutex(db: DatabaseSync): MutexState {
-  let state = mutexMap.get(db);
-  if (!state) {
-    state = { tail: Promise.resolve() };
-    mutexMap.set(db, state);
-  }
-  return state;
-}
-
-function getHeldLockDepth(db: DatabaseSync): number {
-  return heldLockContext.getStore()?.get(db) ?? 0;
-}
-
-function nextSavepointName(): string {
-  nextSavepointId += 1;
-  return `lcm_txn_savepoint_${nextSavepointId}`;
-}
-
-/**
- * Acquire exclusive async access to the database for a transaction.
- *
- * Direct lock acquisition is intentionally low-level and non-reentrant.
- * Callers that need nested transaction scopes should use
- * `withDatabaseTransaction()`, which reuses the held lock and isolates nested
- * work with SQLite savepoints.
- *
- * Usage:
- *   const release = await acquireTransactionLock(this.db);
- *   try {
- *     this.db.exec("BEGIN IMMEDIATE");
- *     // ... do work ...
- *     this.db.exec("COMMIT");
- *   } catch (err) {
- *     this.db.exec("ROLLBACK");
- *     throw err;
- *   } finally {
- *     release();
- *   }
- *
- * Returns a release function that MUST be called in a finally block.
- */
-export function acquireTransactionLock(db: DatabaseSync): Promise<() => void> {
-  const mutex = getOrCreateMutex(db);
-
-  let releaseResolve!: () => void;
-  const releasePromise = new Promise<void>((resolve) => {
-    releaseResolve = resolve;
-  });
-
-  // Capture the current tail — we wait on it
-  const waitOn = mutex.tail;
-
-  // Advance the tail — next acquirer will wait on our release
-  mutex.tail = releasePromise;
-
-  // Wait for the previous holder to release, then return our release fn
-  return waitOn.then(() => releaseResolve);
-}
-
-export type BeginTransactionStatement = "BEGIN" | "BEGIN IMMEDIATE";
-
-/**
- * Run an operation inside a serialized database transaction.
- *
- * The first scope on an async path acquires the per-database mutex and opens
- * the requested transaction mode. Nested scopes on the same database reuse the
- * held lock and isolate their work with a savepoint instead of hanging.
- */
-export async function withDatabaseTransaction<T>(
-  db: DatabaseSync,
-  beginStatement: BeginTransactionStatement,
-  operation: () => Promise<T> | T,
-): Promise<T> {
-  if (getHeldLockDepth(db) > 0) {
-    const savepointName = nextSavepointName();
-    db.exec(`SAVEPOINT ${savepointName}`);
-    try {
-      const result = await operation();
-      db.exec(`RELEASE SAVEPOINT ${savepointName}`);
-      return result;
-    } catch (error) {
-      db.exec(`ROLLBACK TO SAVEPOINT ${savepointName}`);
-      db.exec(`RELEASE SAVEPOINT ${savepointName}`);
-      throw error;
-    }
-  }
-
-  const release = await acquireTransactionLock(db);
-  try {
-    const heldLocks = new Map(heldLockContext.getStore() ?? []);
-    heldLocks.set(db, (heldLocks.get(db) ?? 0) + 1);
-
-    return await heldLockContext.run(heldLocks, async () => {
-      db.exec(beginStatement);
-      try {
-        const result = await operation();
-        db.exec("COMMIT");
-        return result;
-      } catch (error) {
-        db.exec("ROLLBACK");
-        throw error;
-      }
-    });
-  } finally {
-    release();
-  }
-}

package/src/transcript-repair.ts

@@ -1,301 +0,0 @@
-/**
- * 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: "[lossless-claw] 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

@@ -1,165 +0,0 @@
-/**
- * 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 CompletionErrorInfo = {
-  kind?: string;
-  message?: string;
-  code?: string;
-  statusCode?: number;
-  [key: string]: unknown;
-};
-
-export type CompletionResult = {
-  content: CompletionContentBlock[];
-  error?: CompletionErrorInfo;
-  [key: string]: unknown;
-};
-
-export type CompleteFn = (params: {
-  provider?: string;
-  model: string;
-  apiKey?: string;
-  providerApi?: string;
-  authProfileId?: string;
-  agentDir?: string;
-  runtimeConfig?: unknown;
-  skipModelAuth?: boolean;
-  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;
-  agentDir?: string;
-  runtimeConfig?: unknown;
-  skipModelAuth?: boolean;
-};
-
-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;
-
-  /** Whether a provider uses runtime-managed OAuth / auth profiles instead of direct API keys. */
-  isRuntimeManagedAuthProvider?: (provider: string, providerApi?: string) => boolean;
-
-  /** 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;
-  };
-}