Surface Claude model metadata in provider and chat UI

- Resolve live Claude model capabilities so effort, fast mode, and runtime mode selections map from instance metadata
- Add subagent transcript inspection in the chat activity UI and update transcript slicing behavior
- Extend shared contracts and analytics/session logic to carry the new provider metadata

Author: badcuban

apps/server/src/provider/Drivers/ClaudeDriver.ts

@@ -376,6 +376,10 @@ export const ClaudeDriver: ProviderDriver<ClaudeSettings, ClaudeDriverEnv> = {
       const adapter = yield* makeClaudeAdapter(effectiveConfig, {
         instanceId,
         environment: processEnv,
+        resolveModelMetadata: (model) =>
+          snapshot.getSnapshot.pipe(
+            Effect.map((provider) => provider.models.find((candidate) => candidate.slug === model)),
+          ),
         ...(eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}),
         onAccountRateLimitsUpdated: (rateLimitInfo) =>
           Effect.gen(function* () {

apps/server/src/provider/Layers/ClaudeAdapter.test.ts

@@ -24,7 +24,7 @@ import {
   ThreadId,
   ProviderInstanceId,
 } from "@threadlines/contracts";
-import { createModelSelection } from "@threadlines/shared/model";
+import { createModelCapabilities, createModelSelection } from "@threadlines/shared/model";
 import { assert, describe, it } from "@effect/vitest";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
@@ -272,6 +272,7 @@ function makeHarness(config?: {
   readonly instanceId?: ProviderInstanceId;
   readonly environment?: NodeJS.ProcessEnv;
   readonly onChatAuthStateChanged?: ClaudeAdapterLiveOptions["onChatAuthStateChanged"];
+  readonly resolveModelMetadata?: ClaudeAdapterLiveOptions["resolveModelMetadata"];
 }) {
   const query = new FakeClaudeQuery();
   let createInput:
@@ -301,6 +302,7 @@ function makeHarness(config?: {
     ...(config?.onChatAuthStateChanged
       ? { onChatAuthStateChanged: config.onChatAuthStateChanged }
       : {}),
+    ...(config?.resolveModelMetadata ? { resolveModelMetadata: config.resolveModelMetadata } : {}),
   };
 
   return {
@@ -455,6 +457,34 @@ describe("mapClaudeSubagentTranscript", () => {
     const limited = mapClaudeSubagentTranscript(many, { limit: 3 });
     assert.equal(limited.entries.length, 3);
     assert.equal(limited.truncated, true);
+    assert.equal(limited.offset, 0);
+    assert.equal(limited.totalEntries, 5);
+
+    const latest = mapClaudeSubagentTranscript(many, { limit: 2, fromEnd: true });
+    assert.deepStrictEqual(latest, {
+      entries: [
+        { role: "assistant", text: "step", toolUses: [] },
+        { role: "assistant", text: "step", toolUses: [] },
+      ],
+      truncated: true,
+      offset: 3,
+      totalEntries: 5,
+    });
+
+    const earlier = mapClaudeSubagentTranscript(many, { limit: 2, offset: 1 });
+    assert.deepStrictEqual(earlier, {
+      entries: [
+        { role: "assistant", text: "step", toolUses: [] },
+        { role: "assistant", text: "step", toolUses: [] },
+      ],
+      truncated: true,
+      offset: 1,
+      totalEntries: 5,
+    });
+
+    const zeroLimit = mapClaudeSubagentTranscript(many, { limit: 0 });
+    assert.equal(zeroLimit.entries.length, 5);
+    assert.equal(zeroLimit.truncated, false);
   });
 });
 
@@ -807,6 +837,91 @@ describe("ClaudeAdapterLive", () => {
     );
   });
 
+  it.effect("forwards Claude Opus 5 effort and fast mode on the canonical model id", () => {
+    const harness = makeHarness();
+    return Effect.gen(function* () {
+      const adapter = yield* ClaudeAdapter;
+      yield* adapter.startSession({
+        threadId: THREAD_ID,
+        provider: ProviderDriverKind.make("claudeAgent"),
+        modelSelection: createModelSelection(
+          ProviderInstanceId.make("claudeAgent"),
+          "claude-opus-5",
+          [
+            { id: "effort", value: "max" },
+            { id: "fastMode", value: true },
+            { id: "thinking", value: false },
+          ],
+        ),
+        runtimeMode: "full-access",
+      });
+
+      const createInput = harness.getLastCreateQueryInput();
+      assert.equal(createInput?.options.model, "claude-opus-5");
+      assert.equal(createInput?.options.effort, "max");
+      assert.deepEqual(createInput?.options.settings, {
+        fastMode: true,
+      });
+    }).pipe(
+      Effect.provideService(Random.Random, makeDeterministicRandomService()),
+      Effect.provide(harness.layer),
+    );
+  });
+
+  it.effect("forwards live-discovered Claude model options through instance metadata", () => {
+    const harness = makeHarness({
+      resolveModelMetadata: () =>
+        Effect.succeed({
+          capabilities: createModelCapabilities({
+            optionDescriptors: [
+              {
+                id: "effort",
+                label: "Reasoning",
+                type: "select",
+                options: [
+                  { id: "low", label: "Low" },
+                  { id: "max", label: "Max" },
+                ],
+              },
+              {
+                id: "fastMode",
+                label: "Fast Mode",
+                type: "boolean",
+              },
+            ],
+          }),
+          supportedRuntimeModes: ["approval-required", "auto", "full-access"],
+        }),
+    });
+    return Effect.gen(function* () {
+      const adapter = yield* ClaudeAdapter;
+      yield* adapter.startSession({
+        threadId: THREAD_ID,
+        provider: ProviderDriverKind.make("claudeAgent"),
+        modelSelection: createModelSelection(
+          ProviderInstanceId.make("claudeAgent"),
+          "claude-opus-6",
+          [
+            { id: "effort", value: "max" },
+            { id: "fastMode", value: true },
+          ],
+        ),
+        runtimeMode: "auto",
+      });
+
+      const createInput = harness.getLastCreateQueryInput();
+      assert.equal(createInput?.options.model, "claude-opus-6");
+      assert.equal(createInput?.options.effort, "max");
+      assert.equal(createInput?.options.permissionMode, "auto");
+      assert.deepEqual(createInput?.options.settings, {
+        fastMode: true,
+      });
+    }).pipe(
+      Effect.provideService(Random.Random, makeDeterministicRandomService()),
+      Effect.provide(harness.layer),
+    );
+  });
+
   it.effect("forwards max effort for Claude Sonnet 5", () => {
     const harness = makeHarness();
     return Effect.gen(function* () {

apps/server/src/provider/Layers/ClaudeAdapter.ts

@@ -31,6 +31,7 @@ import {
   type ClaudeSettings,
   EventId,
   MessageId,
+  type ModelCapabilities,
   type ModelSelection,
   type ProviderApprovalDecision,
   ProviderDriverKind,
@@ -47,6 +48,7 @@ import {
   type ThreadTokenUsageSnapshot,
   type ProviderUserInputAnswers,
   type RuntimeSessionExitKind,
+  type ServerProviderModel,
   type RuntimeContentStreamKind,
   RuntimeItemId,
   RuntimeRequestId,
@@ -387,6 +389,11 @@ export interface ClaudeAdapterLiveOptions {
     readonly prompt: AsyncIterable<SDKUserMessage>;
     readonly options: ClaudeQueryOptions;
   }) => ClaudeQueryRuntime;
+  readonly resolveModelMetadata?: (
+    model: string,
+  ) => Effect.Effect<
+    Pick<ServerProviderModel, "capabilities" | "supportedRuntimeModes"> | undefined
+  >;
   readonly nativeEventLogPath?: string;
   readonly nativeEventLogger?: EventNdjsonLogger;
   /**
@@ -495,11 +502,11 @@ interface ClaudeFlagSettingsSnapshot {
 
 function deriveClaudeFlagSettings(
   modelSelection: ModelSelection | undefined,
+  capabilities: ModelCapabilities,
 ): ClaudeFlagSettingsSnapshot {
-  const caps = getClaudeModelCapabilities(modelSelection?.model);
-  const descriptors = getProviderOptionDescriptors({ caps });
+  const descriptors = getProviderOptionDescriptors({ caps: capabilities });
   const rawEffort = getModelSelectionStringOptionValue(modelSelection, "effort");
-  const effort = resolveClaudeEffort(caps, rawEffort) ?? null;
+  const effort = resolveClaudeEffort(capabilities, rawEffort) ?? null;
   const fastModeSupported = descriptors.some(
     (descriptor) => descriptor.type === "boolean" && descriptor.id === "fastMode",
   );
@@ -1935,28 +1942,35 @@ function capTranscriptText(value: string, maxChars: number): string {
  */
 export function mapClaudeSubagentTranscript(
   jsonl: string,
-  options?: { readonly limit?: number },
+  options?: {
+    readonly limit?: number;
+    readonly offset?: number;
+    readonly fromEnd?: boolean;
+  },
 ): ProviderSubagentTranscriptResult {
   const limit =
     options?.limit !== undefined && options.limit > 0
       ? options.limit
       : SUBAGENT_TRANSCRIPT_DEFAULT_LIMIT;
+  const requestedOffset = options?.offset ?? 0;
   const entries: Array<ProviderSubagentTranscriptEntry> = [];
-  let truncated = false;
-
-  const push = (entry: ProviderSubagentTranscriptEntry): boolean => {
-    if (entries.length >= limit) {
-      truncated = true;
-      return false;
+  let totalEntries = 0;
+  const push = (entry: ProviderSubagentTranscriptEntry): void => {
+    const entryIndex = totalEntries;
+    totalEntries += 1;
+    if (options?.fromEnd) {
+      entries.push(entry);
+      if (entries.length > limit) {
+        entries.shift();
+      }
+      return;
+    }
+    if (entryIndex >= requestedOffset && entries.length < limit) {
+      entries.push(entry);
     }
-    entries.push(entry);
-    return true;
   };
 
   for (const line of jsonl.split("\n")) {
-    if (truncated) {
-      break;
-    }
     const record = line.trim();
     if (record.length === 0) {
       continue;
@@ -2053,7 +2067,15 @@ export function mapClaudeSubagentTranscript(
     }
   }
 
-  return { entries, truncated };
+  const offset = options?.fromEnd
+    ? Math.max(0, totalEntries - limit)
+    : Math.min(requestedOffset, totalEntries);
+  return {
+    entries,
+    truncated: offset > 0 || offset + entries.length < totalEntries,
+    offset,
+    totalEntries,
+  };
 }
 
 /** Non-null `parent_tool_use_id` marks a message forwarded from inside a
@@ -2519,6 +2541,12 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
         prompt: input.prompt,
         options: input.options,
       }) as ClaudeQueryRuntime);
+  const resolveModelMetadata =
+    options?.resolveModelMetadata ??
+    (() =>
+      Effect.succeed<
+        Pick<ServerProviderModel, "capabilities" | "supportedRuntimeModes"> | undefined
+      >(undefined));
 
   const sessions = new Map<ThreadId, ClaudeSessionContext>();
   const runtimeEventQueue = yield* Queue.unbounded<ProviderRuntimeEvent>();
@@ -5397,13 +5425,20 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
       const extraArgs = parseCliArgs(claudeSettings.launchArgs).flags;
       const modelSelection =
         input.modelSelection?.instanceId === boundInstanceId ? input.modelSelection : undefined;
-      const apiModelId = modelSelection ? resolveClaudeApiModelId(modelSelection) : undefined;
+      const modelMetadata = modelSelection
+        ? yield* resolveModelMetadata(modelSelection.model)
+        : undefined;
+      const modelCapabilities =
+        modelMetadata?.capabilities ?? getClaudeModelCapabilities(modelSelection?.model);
+      const apiModelId = modelSelection
+        ? resolveClaudeApiModelId(modelSelection, modelCapabilities)
+        : undefined;
       const fallbackModel = resolveClaudeFallbackModelOption(claudeSettings.fallbackModel, [
         modelSelection?.model,
         apiModelId,
       ]);
       const fallbackModelIds = splitClaudeFallbackModelOption(fallbackModel);
-      const flagSettings = deriveClaudeFlagSettings(modelSelection);
+      const flagSettings = deriveClaudeFlagSettings(modelSelection, modelCapabilities);
       const effectiveEffort = flagSettings.effortLevel;
       const runtimeModeToPermission: Record<string, PermissionMode> = {
         "auto-accept-edits": "acceptEdits",
@@ -5416,7 +5451,9 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
       // else falls back to in-app approval prompts instead of erroring.
       const autoModeClamped =
         requestedPermissionMode === "auto" &&
-        !claudeModelSupportsAutoRuntimeMode(modelSelection?.model);
+        !(modelMetadata
+          ? (modelMetadata.supportedRuntimeModes?.includes("auto") ?? true)
+          : claudeModelSupportsAutoRuntimeMode(modelSelection?.model));
       const permissionMode = autoModeClamped ? "acceptEdits" : requestedPermissionMode;
       const settings = {
         ...(flagSettings.alwaysThinkingEnabled !== null
@@ -5668,6 +5705,11 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
       input.modelSelection !== undefined && input.modelSelection.instanceId === boundInstanceId
         ? input.modelSelection
         : undefined;
+    const modelMetadata = modelSelection
+      ? yield* resolveModelMetadata(modelSelection.model)
+      : undefined;
+    const modelCapabilities =
+      modelMetadata?.capabilities ?? getClaudeModelCapabilities(modelSelection?.model);
 
     if (context.turnState) {
       // Auto-close a stale synthetic turn (from background agent responses
@@ -5676,7 +5718,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
     }
 
     if (modelSelection?.model) {
-      const apiModelId = resolveClaudeApiModelId(modelSelection);
+      const apiModelId = resolveClaudeApiModelId(modelSelection, modelCapabilities);
       if (context.currentApiModelId !== apiModelId) {
         yield* Effect.tryPromise({
           try: () => context.query.setModel(apiModelId),
@@ -5695,7 +5737,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
     // apply must not block the user's turn, and an un-updated snapshot means
     // the next turn retries.
     if (modelSelection !== undefined) {
-      const desiredFlagSettings = deriveClaudeFlagSettings(modelSelection);
+      const desiredFlagSettings = deriveClaudeFlagSettings(modelSelection, modelCapabilities);
       if (!claudeFlagSettingsEqual(desiredFlagSettings, context.currentFlagSettings)) {
         const applyFlagSettings = context.query.applyFlagSettings?.bind(context.query);
         if (applyFlagSettings === undefined) {
@@ -5952,10 +5994,11 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (
             requestError(`Failed to read the subagent transcript: ${cause.message}`),
           ),
         );
-      return mapClaudeSubagentTranscript(
-        transcript,
-        input.limit !== undefined ? { limit: input.limit } : {},
-      );
+      return mapClaudeSubagentTranscript(transcript, {
+        ...(input.limit !== undefined ? { limit: input.limit } : {}),
+        ...(input.offset !== undefined ? { offset: input.offset } : {}),
+        ...(input.fromEnd !== undefined ? { fromEnd: input.fromEnd } : {}),
+      });
     });
 
   const rewindFilesForRollback = Effect.fn("rewindFilesForRollback")(function* (