@animalabs/connectome-host 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## Unreleased
 
+## 0.5.1
+
+### Added
+
+- **llm-calls logging for every provider**: `LoggingProviderAdapter`, a
+  provider-agnostic decorator over any `ProviderAdapter`, wraps the
+  openai-codex, openrouter, and openai-responses transports — which
+  previously had NO wire visibility (found post-deploy on Mica: zero
+  llm-calls files, requests undiagnosable). Full raw request + response
+  summary + usage + timing + error per call, size-guarded against
+  pathological payloads. Anthropic/Bedrock keep their purpose-built
+  logging classes.
+
 ## 0.5.0 — 2026-07-26
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@animalabs/connectome-host",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "General-purpose agent TUI host with recipe-based configuration",
   "type": "module",
   "scripts": {

package/src/index.ts

@@ -25,6 +25,7 @@ import {
   OpenRouterAdapter,
 } from '@animalabs/membrane';
 import { LoggingAnthropicAdapter } from './logging-adapter.js';
+import { LoggingProviderAdapter } from './logging-provider-wrapper.js';
 import { LoggingBedrockAdapter } from './logging-bedrock-adapter.js';
 import { CodexSubscriptionAdapter } from './codex-subscription-adapter.js';
 import { CallLedger } from './call-ledger.js';
@@ -835,11 +836,22 @@ async function main() {
     ? new LoggingBedrockAdapter({}, llmLogPath)
     : undefined;
   const adapter = provider === 'openai-responses'
-    ? new OpenAIResponsesAPIAdapter({
-        apiKey: config.openaiApiKey!,
-        baseURL: process.env.OPENAI_BASE_URL || undefined,
-      })
-    : bedrockAdapter ?? openrouterAdapter ?? codexAdapter ?? new LoggingAnthropicAdapter(
+    ? new LoggingProviderAdapter(
+        new OpenAIResponsesAPIAdapter({
+          apiKey: config.openaiApiKey!,
+          baseURL: process.env.OPENAI_BASE_URL || undefined,
+        }),
+        llmLogPath,
+      )
+    // Codex/openrouter/openai adapters get the provider-agnostic logging
+    // decorator (llm-calls.jsonl); anthropic and bedrock keep their
+    // purpose-built logging classes below. The bare `codexAdapter` /
+    // `openrouterAdapter` instances stay un-wrapped for auth commands and
+    // dispose() — only the membrane sees the wrapper.
+    : bedrockAdapter
+      ?? (openrouterAdapter ? new LoggingProviderAdapter(openrouterAdapter, llmLogPath) : undefined)
+      ?? (codexAdapter ? new LoggingProviderAdapter(codexAdapter, llmLogPath) : undefined)
+      ?? new LoggingAnthropicAdapter(
         {
           // Anthropic OAuth wins over API-key auth when both are present.
           // Subscription tokens additionally require this beta header.

package/src/logging-provider-wrapper.ts

@@ -0,0 +1,165 @@
+// Provider-agnostic ProviderAdapter decorator that appends each LLM call's
+// request, response, usage, timing, and any error to the same
+// `llm-calls.<iso>.jsonl` file the Anthropic and Bedrock paths use.
+//
+// Exists because llm-call logging grew adapter-by-adapter (Anthropic subclass,
+// Bedrock wrapper) and the remaining providers — openai-codex (Mica),
+// openrouter (K3) — had NO wire visibility at all: a post-deploy "did her
+// requests actually work?" check on Mica (2026-07-26) found zero llm-calls
+// files because the codex path never logged. This decorator wraps ANY
+// ProviderAdapter, so a new provider gets logging by construction rather than
+// by remembering to build a logging twin.
+//
+// Contents: full raw request and a summarized-but-complete response record
+// (stop reason, usage, per-block shape, full text) on every call, plus the
+// raw provider response. Retention/rotation/S3 shipping is the host box's
+// llm-logs sync job's problem — this file just writes lines.
+//
+// OOM note (learned on the Anthropic path, which once logged raw+normalized+
+// summary and contributed to production OOMs): we serialize the record ONCE,
+// and a size guard drops the raw bodies for pathological payloads (giant
+// image batches) rather than buffering multi-hundred-MB lines.
+//
+// Decorator safety: adapters whose complete() internally delegates to their
+// own stream() (codex does) self-call the INNER method, not the wrapper —
+// each membrane-level call logs exactly once.
+//
+// Each line: { type: 'call'|'error', provider, kind: 'complete'|'stream',
+//   timestamp, durationMs, requestSummary, response?, rawRequest?,
+//   rawResponse?, error?, truncated? }
+
+import type {
+  ProviderAdapter,
+  ProviderRequest,
+  ProviderResponse,
+  ProviderRequestOptions,
+  StreamCallbacks,
+} from '@animalabs/membrane';
+import { appendFileSync } from 'node:fs';
+
+/** Above this many serialized bytes, drop raw bodies and keep summaries. */
+const MAX_RECORD_BYTES = 16 * 1024 * 1024;
+
+function summarizeRequest(request: ProviderRequest): Record<string, unknown> {
+  const msgs = (request.messages ?? []) as Array<{ role?: string; content?: unknown }>;
+  const last = msgs[msgs.length - 1];
+  const lastPreview = typeof last?.content === 'string'
+    ? last.content.slice(0, 200)
+    : Array.isArray(last?.content)
+      ? (last.content as Array<{ type?: string; text?: string }>)
+          .map((b) => (b.type === 'text' ? (b.text ?? '').slice(0, 120) : `[${b.type}]`))
+          .join(' | ').slice(0, 300)
+      : undefined;
+  return {
+    model: request.model,
+    maxTokens: request.maxTokens,
+    messageCount: msgs.length,
+    systemChars: typeof request.system === 'string'
+      ? request.system.length
+      : Array.isArray(request.system)
+        ? JSON.stringify(request.system).length
+        : 0,
+    toolNames: (request.tools as Array<{ name?: string }> | undefined)?.map((t) => t.name) ?? null,
+    toolCount: (request.tools as unknown[] | undefined)?.length ?? 0,
+    lastMessageRole: last?.role,
+    lastMessagePreview: lastPreview,
+  };
+}
+
+function summarizeResponse(response: ProviderResponse): Record<string, unknown> {
+  const content = (response.content ?? []) as Array<{ type?: string; text?: string; name?: string }>;
+  return {
+    stopReason: response.stopReason
+      ?? (response.raw as { stop_reason?: string } | undefined)?.stop_reason
+      ?? null,
+    usage: response.usage ?? null,
+    blocks: content.map((b) => ({
+      type: b.type,
+      ...(b.type === 'text' ? { chars: (b.text ?? '').length, text: b.text } : {}),
+      ...(b.type === 'tool_use' ? { name: b.name } : {}),
+    })),
+  };
+}
+
+export class LoggingProviderAdapter implements ProviderAdapter {
+  readonly name: string;
+
+  constructor(
+    private readonly inner: ProviderAdapter,
+    private readonly logPath: string,
+  ) {
+    this.name = inner.name;
+  }
+
+  supportsModel(modelId: string): boolean {
+    return this.inner.supportsModel(modelId);
+  }
+
+  private log(record: Record<string, unknown>): void {
+    try {
+      let line = JSON.stringify(record);
+      if (line.length > MAX_RECORD_BYTES) {
+        const { rawRequest: _rq, rawResponse: _rr, ...rest } = record;
+        line = JSON.stringify({ ...rest, truncated: 'raw bodies dropped (record exceeded size guard)' });
+      }
+      appendFileSync(this.logPath, line + '\n');
+    } catch {
+      // Logging must never break inference.
+    }
+  }
+
+  private record(
+    kind: 'complete' | 'stream',
+    request: ProviderRequest,
+    started: number,
+    response?: ProviderResponse,
+    error?: unknown,
+  ): void {
+    this.log({
+      type: error === undefined ? 'call' : 'error',
+      provider: this.name,
+      kind,
+      timestamp: new Date(started).toISOString(),
+      durationMs: Date.now() - started,
+      requestSummary: summarizeRequest(request),
+      rawRequest: request,
+      ...(response !== undefined
+        ? { response: summarizeResponse(response), rawResponse: response.raw ?? null }
+        : {}),
+      ...(error !== undefined
+        ? { error: error instanceof Error ? `${error.name}: ${error.message}` : String(error) }
+        : {}),
+    });
+  }
+
+  async complete(
+    request: ProviderRequest,
+    options?: ProviderRequestOptions,
+  ): Promise<ProviderResponse> {
+    const started = Date.now();
+    try {
+      const response = await this.inner.complete(request, options);
+      this.record('complete', request, started, response);
+      return response;
+    } catch (error) {
+      this.record('complete', request, started, undefined, error);
+      throw error;
+    }
+  }
+
+  async stream(
+    request: ProviderRequest,
+    callbacks: StreamCallbacks,
+    options?: ProviderRequestOptions,
+  ): Promise<ProviderResponse> {
+    const started = Date.now();
+    try {
+      const response = await this.inner.stream(request, callbacks, options);
+      this.record('stream', request, started, response);
+      return response;
+    } catch (error) {
+      this.record('stream', request, started, undefined, error);
+      throw error;
+    }
+  }
+}