@shipfox/api-logs 10.1.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

@@ -44,7 +44,7 @@ type SystemEventMapping = {
   meta?: (message: Record<string, unknown>) => readonly SessionViewRowMeta[];
 };
 
-const SYSTEM_EVENT_MAPPINGS: Record<string, SystemEventMapping> = {
+export const SYSTEM_EVENT_MAPPINGS: Record<string, SystemEventMapping> = {
   permission_denied: {
     label: 'Permission denied',
     tone: 'error',
@@ -91,6 +91,32 @@ const SYSTEM_EVENT_MAPPINGS: Record<string, SystemEventMapping> = {
       ].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',
@@ -169,6 +195,10 @@ export function systemRow(
 
   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;
@@ -183,27 +213,137 @@ export function systemRow(
   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 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;
   };
 
@@ -212,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;
     }
 
@@ -231,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)];
@@ -240,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));
@@ -255,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;
     }
 
@@ -265,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(