log claude model in backfill

Author: bgmcmullen

collectivus-plugin-kernel-types.d.ts

@@ -1422,6 +1422,14 @@ export interface AiGatewayProjectedMessage {
   prompt_id?: string
   provider_type?: string
   provider_subtype?: string
+  /**
+   * Per-message model id. Live capture sets one model per exchange (one
+   * request, one model) on the exchange, but a backfilled exchange spans a
+   * whole session that can switch models mid-stream, so backfill stamps the
+   * model per assistant message. The gateway prefers this over the exchange
+   * `model` when present.
+   */
+  model?: string
   entrypoint?: string
   user_type?: string
   permission_mode?: string

hypaware-core/plugins-workspace/ai-gateway/src/message_projector.js

@@ -649,7 +649,10 @@ function expandMessageParts(ctx) {
     conversation_id: ctx.conversationId,
     user_id: ctx.projection.user_id,
     provider: ctx.projection.provider,
-    model: ctx.projection.model,
+    // Per-message model wins when present (backfill stamps it per assistant
+    // line so mixed-model sessions stay accurate); live capture leaves it
+    // unset and falls back to the one-model-per-exchange value.
+    model: stringValue(ctx.message.model) ?? ctx.projection.model,
     system_text: ctx.projection.system_text,
     tools: ctx.projection.tools,
     conversation_started_at: ctx.conversationStarted,

hypaware-core/plugins-workspace/claude/src/backfill.js

@@ -391,6 +391,10 @@ function projectedMessageFromEntry(entry, agentMeta) {
   if (entry.prompt_id) message.prompt_id = entry.prompt_id
   if (entry.provider_type) message.provider_type = entry.provider_type
   if (entry.provider_subtype) message.provider_subtype = entry.provider_subtype
+  // Per-message model: live capture sets one model per exchange, but a
+  // backfilled session can switch models mid-stream, so stamp it per assistant
+  // line and let the gateway prefer it over the exchange model.
+  if (entry.model) message.model = entry.model
   if (entry.entrypoint) message.entrypoint = entry.entrypoint
   if (entry.user_type) message.user_type = entry.user_type
   if (entry.permission_mode) message.permission_mode = entry.permission_mode

hypaware-core/plugins-workspace/claude/src/transcripts.js

@@ -449,6 +449,7 @@ function transcriptEntryFromRow(row) {
     prompt_id: stringValue(row.promptId) ?? stringValue(row.prompt_id),
     provider_type: stringValue(row.type),
     provider_subtype: stringValue(row.subtype),
+    model: transcriptModel(message),
     entrypoint: stringValue(row.entrypoint),
     client_version: stringValue(row.version) ?? stringValue(row.claude_version),
     user_type: stringValue(row.userType) ?? stringValue(row.user_type),
@@ -524,6 +525,18 @@ function readKey(obj, key) {
   return /** @type {Record<string, unknown>} */ (obj)[key]
 }
 
+/**
+ * The model id from an assistant transcript line's `message.model`. Claude
+ * Code stamps `<synthetic>` on assistant lines it generates locally (interrupt
+ * notices, injected errors) that never hit a model — that is a sentinel, not a
+ * model id, so it is dropped to undefined.
+ * @param {unknown} message
+ */
+function transcriptModel(message) {
+  const model = stringValue(readKey(message, 'model'))
+  return model === '<synthetic>' ? undefined : model
+}
+
 /**
  * @param {unknown} value
  * @returns {value is Record<string, unknown>}

hypaware-core/plugins-workspace/claude/src/types.d.ts

@@ -34,6 +34,14 @@ export interface TranscriptEntry {
   prompt_id: string | undefined
   provider_type: string | undefined
   provider_subtype: string | undefined
+  /**
+   * The model Claude Code stamps on each assistant transcript line. Backfill
+   * surfaces it per message so the gateway `model` column matches live
+   * capture, including sessions that switch models mid-stream. The
+   * `<synthetic>` sentinel (locally-generated assistant lines that never hit a
+   * model) is dropped to undefined.
+   */
+  model: string | undefined
   entrypoint: string | undefined
   client_version: string | undefined
   user_type: string | undefined

test/plugins/claude-backfill.test.js

@@ -365,6 +365,71 @@ test('assistant token usage is folded into attributes.usage like live capture',
   }
 })
 
+test('assistant model is surfaced per message, switches mid-session, and drops <synthetic>', async () => {
+  const env = await stageEnv()
+  try {
+    await writeTranscript(env, 'repo-a', 'sess-1', [
+      {
+        sessionId: 'sess-1',
+        uuid: 'u-user-1',
+        parentUuid: null,
+        type: 'user',
+        message: { role: 'user', content: 'hello' },
+        timestamp: '2026-05-20T10:00:00.000Z',
+      },
+      {
+        sessionId: 'sess-1',
+        uuid: 'u-asst-1',
+        parentUuid: 'u-user-1',
+        type: 'assistant',
+        // The model Claude Code stamps onto each assistant transcript line.
+        message: { role: 'assistant', content: [{ type: 'text', text: 'hi' }], model: 'claude-opus-4-8' },
+        timestamp: '2026-05-20T10:00:05.000Z',
+      },
+      {
+        sessionId: 'sess-1',
+        uuid: 'u-asst-2',
+        parentUuid: 'u-asst-1',
+        type: 'assistant',
+        // A mid-session model switch must be preserved per message, not
+        // collapsed to one value for the whole session.
+        message: { role: 'assistant', content: [{ type: 'text', text: 'still here' }], model: 'claude-fable-5' },
+        timestamp: '2026-05-20T10:00:06.000Z',
+      },
+      {
+        sessionId: 'sess-1',
+        uuid: 'u-asst-3',
+        parentUuid: 'u-asst-2',
+        type: 'assistant',
+        // `<synthetic>` is a sentinel for locally-generated assistant lines
+        // that never hit a model — it must not land in the model column.
+        message: { role: 'assistant', content: [{ type: 'text', text: '[interrupted]' }], model: '<synthetic>' },
+        timestamp: '2026-05-20T10:00:07.000Z',
+      },
+    ])
+    const provider = createClaudeBackfillProvider({ homeDir: env.homeDir, stateFile: env.stateFile })
+    const [item] = await collectItems(provider.run(runContext().ctx))
+    assert.ok(item)
+
+    const rows = await materialize(item)
+    const asstRows = rowsByRole(rows, 'assistant')
+    /** @param {string} text */
+    const byText = (text) => {
+      const row = asstRows.find((r) => r.content_text === text)
+      assert.ok(row, `assistant row for "${text}" present`)
+      return row
+    }
+    assert.equal(byText('hi').model, 'claude-opus-4-8')
+    assert.equal(byText('still here').model, 'claude-fable-5')
+    // The <synthetic> line records no model.
+    assert.equal(byText('[interrupted]').model ?? null, null)
+    // A user turn carries no model.
+    assert.equal(rowsByRole(rows, 'user')[0].model ?? null, null)
+  } finally {
+    await env.cleanup()
+  }
+})
+
 test('token usage merges with subagent spawn provenance', async () => {
   const env = await stageEnv()
   try {