@shipfox/api-logs 10.0.0 → 10.2.0

package/src/core/append-logs.ts

@@ -30,6 +30,7 @@ import {
 import {allowedBudget} from './budget.js';
 import {closeStream, controlTombstone} from './close-stream.js';
 import {MalformedLogChunkError, OffsetGapError} from './errors.js';
+import {flushPendingToolRows} from './session/claude/rows.js';
 import {
   type ClaudeParseContext,
   claudeInitSessionId,
@@ -180,6 +181,7 @@ interface StoredBody {
   recordCounts: Partial<Record<LogRecord['type'], number>>;
   claudeParseContext: ClaudeParseContext | undefined;
   claudePendingResult: SessionViewLifecycleRow | null | undefined;
+  claudePendingToolRows: readonly SessionViewRow[] | undefined;
 }
 
 /**
@@ -303,6 +305,12 @@ function buildStoredBody(
     }
   }
 
+  if (isStreamFinal && parseContext?.claude !== undefined) {
+    for (const row of flushPendingToolRows(parseContext.claude)) {
+      storedRecords.push(storedAgentSessionRow(row));
+    }
+  }
+
   const body = Buffer.from(storedRecords.map((record) => `${JSON.stringify(record)}\n`).join(''));
   const recordCounts: Partial<Record<LogRecord['type'], number>> = {};
   for (const record of storedRecords) {
@@ -314,6 +322,7 @@ function buildStoredBody(
     recordCounts,
     claudeParseContext: parseContext?.claude,
     claudePendingResult: parseContext?.claude === undefined ? undefined : pendingResult,
+    claudePendingToolRows: parseContext?.claude?.pendingToolRows,
   };
 }
 
@@ -451,18 +460,20 @@ export async function appendLogs(
     }
 
     const parseHarness =
-      sessionHarness === 'claude' || stream.claudePendingResult !== null
+      sessionHarness === 'claude' ||
+      stream.claudePendingResult !== null ||
+      stream.claudePendingToolRows.length > 0
         ? 'claude'
         : sessionHarness;
     const stored = buildStoredBody(
       parsed.records,
       parseHarness,
       parseHarness === 'claude'
-        ? {
+        ? createClaudeParseContext(stream.claudePendingToolRows, {
             hasInit: stream.claudeHasInit,
             sessionId: stream.claudeSessionId,
             turn: stream.claudeTurn,
-          }
+          })
         : undefined,
       parseHarness === 'claude' ? stream.claudePendingResult : undefined,
       declaredTotalBytes !== undefined,
@@ -488,6 +499,7 @@ export async function appendLogs(
           sessionId: stored.claudeParseContext.sessionId,
           turn: stored.claudeParseContext.turn,
           pendingResult: stored.claudePendingResult ?? null,
+          pendingToolRows: stored.claudePendingToolRows ?? [],
         });
       }
     }

package/src/core/close-stream.ts

@@ -47,7 +47,23 @@ export async function closeStream(
   });
   if (!closedResult) return null;
 
-  const {stream: closed, pendingClaudeResult} = closedResult;
+  const {stream: closed, pendingClaudeResult, pendingClaudeToolRows} = closedResult;
+  if (pendingClaudeToolRows.length > 0) {
+    const data = Buffer.from(
+      `${pendingClaudeToolRows
+        .map((row) =>
+          JSON.stringify({v: 1, ts: row.timestamp, type: 'agent_session', row} satisfies LogRecord),
+        )
+        .join('\n')}\n`,
+    );
+    await insertChunk(tx, {
+      streamId: closed.id,
+      streamOffset: closed.committedLength,
+      byteLen: data.length,
+      data,
+      origin: 'control',
+    });
+  }
   if (pendingClaudeResult !== null) {
     const record: LogRecord = {
       v: 1,

package/src/core/entities/attempt-stream.ts

@@ -1,4 +1,4 @@
-import type {SessionViewLifecycleRow} from '@shipfox/api-logs-dto';
+import type {SessionViewLifecycleRow, SessionViewRow} from '@shipfox/api-logs-dto';
 
 /** Lifecycle state of an attempt's log stream. */
 export type StreamState = 'open' | 'closed';
@@ -35,6 +35,7 @@ export interface AttemptStream {
   claudeSessionId: string | null;
   claudeTurn: number;
   claudePendingResult: SessionViewLifecycleRow | null;
+  claudePendingToolRows: SessionViewRow[];
   truncated: boolean;
   objectKey: string | null;
   createdAt: Date;

package/src/core/session/claude/rows.ts

@@ -13,6 +13,7 @@ import {
   formatNumber,
   isMeta,
   metaItem,
+  numberField,
   stringField,
   stringifyValue,
   toJson,
@@ -34,6 +35,127 @@ export const PURE_PROGRESS_CLAUDE_SYSTEM_SUBTYPES = new Set<string>([
 ]);
 const OUTPUT_REPROMPT_PREFIX = 'The previous turn ended without setting required workflow outputs:';
 
+type SystemEventMapping = {
+  label: string | ((message: Record<string, unknown>) => string);
+  tone:
+    | SessionViewLifecycleRow['tone']
+    | ((message: Record<string, unknown>) => SessionViewLifecycleRow['tone']);
+  detail?: (message: Record<string, unknown>) => string | null;
+  meta?: (message: Record<string, unknown>) => readonly SessionViewRowMeta[];
+};
+
+export const SYSTEM_EVENT_MAPPINGS: Record<string, SystemEventMapping> = {
+  permission_denied: {
+    label: 'Permission denied',
+    tone: 'error',
+    detail: (message) => stringField(message, 'tool_name') ?? null,
+    meta: (message) =>
+      [
+        metaItem(
+          'reason',
+          stringField(message, 'decision_reason') ?? stringField(message, 'message'),
+        ),
+      ].filter(isMeta),
+  },
+  api_retry: {
+    label: 'API retry',
+    tone: 'warning',
+    detail: (message) => {
+      const attempt = numberField(message, 'attempt');
+      const maxRetries = numberField(message, 'max_retries');
+      return attempt == null || maxRetries == null
+        ? null
+        : `attempt ${formatNumber(attempt)}/${formatNumber(maxRetries)}`;
+    },
+    meta: (message) =>
+      [
+        numberMeta(message, 'error_status', 'status'),
+        numberMeta(message, 'retry_delay_ms', 'retry delay', 'ms'),
+      ].filter(isMeta),
+  },
+  informational: {
+    label: (message) => titleCase(stringField(message, 'level') ?? 'informational'),
+    tone: (message) => (stringField(message, 'level') === 'warning' ? 'warning' : 'default'),
+    detail: (message) => stringField(message, 'content') ?? null,
+  },
+  compact_boundary: {
+    label: 'Context compacted',
+    tone: 'default',
+    meta: (message) => {
+      const compactMetadata = asLooseObject(field(message, 'compact_metadata')) ?? {};
+      return [
+        metaItem('trigger', stringField(compactMetadata, 'trigger')),
+        numberMeta(compactMetadata, 'pre_tokens', 'tokens before', 'tokens'),
+        numberMeta(compactMetadata, 'post_tokens', 'tokens after', 'tokens'),
+        numberMeta(compactMetadata, 'duration_ms', 'duration', 'ms'),
+      ].filter(isMeta);
+    },
+  },
+  hook_response: {
+    label: (message) => {
+      const outcome = stringField(message, 'outcome');
+      return outcome === 'error'
+        ? 'Hook failed'
+        : outcome === 'cancelled'
+          ? 'Hook cancelled'
+          : outcome === 'success'
+            ? 'Hook completed'
+            : 'Hook response';
+    },
+    tone: (message) => {
+      const outcome = stringField(message, 'outcome');
+      return outcome === 'error' ? 'error' : outcome === 'cancelled' ? 'warning' : 'default';
+    },
+    detail: (message) =>
+      stringField(message, 'output') ??
+      stringField(message, 'stderr') ??
+      stringField(message, 'stdout') ??
+      null,
+    meta: (message) =>
+      [
+        metaItem('hook', stringField(message, 'hook_name')),
+        numberMeta(message, 'exit_code', 'exit code'),
+      ].filter(isMeta),
+  },
+  model_refusal_fallback: {
+    label: 'Model refused, fell back',
+    tone: 'warning',
+  },
+  model_refusal_no_fallback: {
+    label: 'Model refused',
+    tone: 'error',
+  },
+  mirror_error: {
+    label: 'Session mirror failed',
+    tone: 'error',
+    detail: (message) => stringField(message, 'error') ?? null,
+  },
+  worker_shutting_down: {
+    label: 'Worker shutting down',
+    tone: 'warning',
+  },
+  elicitation_complete: {
+    label: 'Elicitation complete',
+    tone: 'default',
+  },
+  notification: {
+    label: 'Notification',
+    tone: 'default',
+  },
+  task_started: {
+    label: 'Task started',
+    tone: 'default',
+  },
+  task_updated: {
+    label: 'Task updated',
+    tone: 'default',
+  },
+  task_notification: {
+    label: 'Task notification',
+    tone: 'default',
+  },
+};
+
 export function systemRow(
   timestamp: number,
   message: Record<string, unknown>,
@@ -51,40 +173,177 @@ export function systemRow(
     ),
   ].filter(isMeta);
 
-  if (!isInit)
-    return lifecycleRow(timestamp, 'Session event', sessionId ?? null, 'default', false, baseMeta);
+  if (!isInit) {
+    const mapping = subtype === undefined ? undefined : SYSTEM_EVENT_MAPPINGS[subtype];
+    const label =
+      mapping === undefined
+        ? `Session event (${subtype ?? 'unknown'})`
+        : typeof mapping.label === 'function'
+          ? mapping.label(message)
+          : mapping.label;
+    const tone =
+      mapping === undefined
+        ? 'default'
+        : typeof mapping.tone === 'function'
+          ? mapping.tone(message)
+          : mapping.tone;
+    const detail = mapping?.detail?.(message) ?? null;
+    const meta = [...baseMeta, ...(mapping?.meta?.(message) ?? [])];
+
+    return lifecycleRow(timestamp, label, detail, tone, false, meta);
+  }
 
   const isNewSession =
     !context.hasInit || sessionId === undefined || sessionId !== context.sessionId;
+  if (isNewSession) {
+    context.pendingToolRows.length = 0;
+    context.toolCallRows.clear();
+  }
   context.hasInit = true;
   context.sessionId = sessionId ?? null;
   context.turn = isNewSession ? 1 : context.turn + 1;
 
   const label = isNewSession ? 'Session started' : `Turn ${context.turn} started`;
-  const meta = [metaItem('turn', isNewSession ? null : String(context.turn)), ...baseMeta].filter(
-    isMeta,
+  const meta = [
+    metaItem('session', isNewSession ? sessionId : null),
+    metaItem('turn', isNewSession ? null : String(context.turn)),
+    ...baseMeta,
+  ].filter(isMeta);
+
+  return lifecycleRow(timestamp, label, null, 'default', false, meta);
+}
+
+export function authStatusRow(
+  timestamp: number,
+  message: Record<string, unknown>,
+): SessionViewLifecycleRow {
+  const error = stringField(message, 'error');
+  const output = stringList(field(message, 'output')).join('\n');
+  const isAuthenticating = booleanField(message, 'isAuthenticating');
+
+  return lifecycleRow(
+    timestamp,
+    error
+      ? 'Authentication failed'
+      : isAuthenticating
+        ? 'Authenticating'
+        : 'Authentication complete',
+    (error ?? output) || null,
+    error ? 'error' : 'default',
+    false,
+  );
+}
+
+const RATE_LIMIT_STATUS_MAPPINGS: Record<
+  string,
+  {label: string; tone: SessionViewLifecycleRow['tone']}
+> = {
+  rejected: {label: 'Rate limit exceeded', tone: 'error'},
+  allowed_warning: {label: 'Rate limit warning', tone: 'warning'},
+  allowed: {label: 'Rate limit available', tone: 'default'},
+};
+
+export function rateLimitRow(
+  timestamp: number,
+  message: Record<string, unknown>,
+): SessionViewLifecycleRow {
+  const rateLimitInfo = asLooseObject(field(message, 'rate_limit_info')) ?? {};
+  const status = stringField(rateLimitInfo, 'status');
+  const rateLimitType = stringField(rateLimitInfo, 'rateLimitType');
+  const utilization = numberField(rateLimitInfo, 'utilization');
+  const mapping = status === undefined ? undefined : RATE_LIMIT_STATUS_MAPPINGS[status];
+  const meta = [
+    metaItem('utilization', utilization == null ? null : `${formatNumber(utilization * 100)}%`),
+    mapping === undefined ? metaItem('status', status ?? null) : null,
+  ].filter(isMeta);
+
+  return lifecycleRow(
+    timestamp,
+    mapping?.label ?? 'Rate limit updated',
+    rateLimitType == null ? null : humanizeEnumValue(rateLimitType),
+    mapping?.tone ?? 'warning',
+    false,
+    meta,
   );
+}
+
+export function toolUseSummary(
+  message: Record<string, unknown>,
+  context: ClaudeParseContext,
+): boolean {
+  const summary = stringField(message, 'summary');
+  if (summary === undefined) return false;
+
+  const precedingToolUseIds = stringList(field(message, 'preceding_tool_use_ids'));
+  const toolUseId = stringField(message, 'tool_use_id');
+  const candidateIds =
+    precedingToolUseIds.length > 0
+      ? precedingToolUseIds
+      : toolUseId === undefined
+        ? []
+        : [toolUseId];
+
+  for (const id of [...candidateIds].reverse()) {
+    const row = context.toolCallRows.get(id);
+    if (row === undefined) continue;
+
+    row.summary = row.summary === undefined ? summary : `${row.summary}\n\n${summary}`;
+    return true;
+  }
 
-  return lifecycleRow(timestamp, label, sessionId ?? null, 'default', false, meta);
+  return false;
+}
+
+export function flushPendingToolRows(context: ClaudeParseContext): readonly SessionViewRow[] {
+  if (context.pendingToolRows.length === 0) return [];
+
+  const rows = context.pendingToolRows;
+  context.pendingToolRows = [];
+  context.toolCallRows.clear();
+  return rows;
+}
+
+function titleCase(value: string): string {
+  return value.length === 0 ? value : `${value[0]?.toUpperCase()}${value.slice(1)}`;
+}
+
+function humanizeEnumValue(value: string): string {
+  return titleCase(value.replaceAll('_', ' '));
+}
+
+function stringList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+
+  return value.filter((item): item is string => typeof item === 'string' && item.length > 0);
 }
 
 export function assistantRows(
   timestamp: number,
   message: Record<string, unknown>,
+  context: ClaudeParseContext,
 ): readonly SessionViewRow[] {
   const sdkMessage = asLooseObject(message.message) ?? message;
   const rows: SessionViewRow[] = [];
   const textParts: string[] = [];
   const thinkingParts: string[] = [];
+  let queueRows = context.toolCallRows.size > 0;
+
+  const pushRow = (row: SessionViewRow) => {
+    if (queueRows) {
+      context.pendingToolRows.push(row);
+    } else {
+      rows.push(row);
+    }
+  };
 
   const pushText = () => {
     if (textParts.length === 0) return;
-    rows.push(messageRow(timestamp, 'assistant', 'assistant', textParts.join('\n\n'), false));
+    pushRow(messageRow(timestamp, 'assistant', 'assistant', textParts.join('\n\n'), false));
     textParts.length = 0;
   };
   const pushThinking = () => {
     if (thinkingParts.length === 0) return;
-    rows.push(thinkingRow(timestamp, thinkingParts.join('\n\n')));
+    pushRow(thinkingRow(timestamp, thinkingParts.join('\n\n')));
     thinkingParts.length = 0;
   };
 
@@ -93,7 +352,14 @@ export function assistantRows(
     if (type === 'tool_use' || type === 'tool-use' || type === 'toolCall') {
       pushText();
       pushThinking();
-      rows.push(toolCallRow(timestamp, block));
+      const row = toolCallRow(timestamp, block);
+      if (row.id === null) {
+        pushRow(row);
+      } else {
+        queueRows = true;
+        context.pendingToolRows.push(row);
+        context.toolCallRows.set(row.id, row);
+      }
       continue;
     }
 
@@ -112,7 +378,7 @@ export function assistantRows(
   pushText();
   pushThinking();
 
-  if (rows.length > 0) return rows;
+  if (rows.length > 0 || queueRows) return rows;
 
   const text = stringField(sdkMessage, 'content') ?? stringField(message, 'result');
   return [messageRow(timestamp, 'assistant', 'assistant', text ?? toJson(message), false)];
@@ -121,11 +387,14 @@ export function assistantRows(
 export function userRows(
   timestamp: number,
   message: Record<string, unknown>,
+  context: ClaudeParseContext,
 ): readonly SessionViewRow[] {
   const sdkMessage = asLooseObject(message.message) ?? message;
   const role = isPlatformMessage(sdkMessage) ? 'platform' : 'user';
   const rows: SessionViewRow[] = [];
   const textParts: string[] = [];
+  const hadPendingToolCall = context.toolCallRows.size > 0;
+  let matchedToolResult = false;
   const pushText = () => {
     if (textParts.length === 0) return;
     rows.push(messageRow(timestamp, role, role, textParts.join('\n\n'), false));
@@ -136,7 +405,11 @@ export function userRows(
     const type = stringField(block, 'type');
     if (type === 'tool_result' || type === 'tool-result') {
       pushText();
-      rows.push(toolResultRow(timestamp, block));
+      const row = toolResultRow(timestamp, block);
+      if (row.toolCallId !== null && context.toolCallRows.has(row.toolCallId)) {
+        matchedToolResult = true;
+      }
+      rows.push(row);
       continue;
     }
 
@@ -146,10 +419,19 @@ export function userRows(
 
   pushText();
 
-  if (rows.length > 0) return rows;
+  if (rows.length === 0) {
+    const content = stringField(sdkMessage, 'content');
+    rows.push(messageRow(timestamp, role, role, content ?? toJson(message), false));
+  }
 
-  const content = stringField(sdkMessage, 'content');
-  return [messageRow(timestamp, role, role, content ?? toJson(message), false)];
+  if (hadPendingToolCall) {
+    if (matchedToolResult) {
+      context.pendingToolRows.push(...rows);
+      return [];
+    }
+    return [...flushPendingToolRows(context), ...rows];
+  }
+  return rows;
 }
 
 export function resultRow(