pi-background-tasks 2.5.0 → 2.6.1

package/src/core/anthropic-attribution.ts

@@ -1,7 +1,13 @@
 import { createHash } from 'node:crypto';
 import { appendFileSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { isAbsolute, join } from 'node:path';
+import type {
+  AssistantMessageEventStream as HostAssistantMessageEventStream,
+  Context as HostContext,
+  Model as HostModel,
+  SimpleStreamOptions as HostSimpleStreamOptions,
+} from '@earendil-works/pi-ai';
 
 export const CLAUDE_CODE_SESSION_HEADER = 'X-Claude-Code-Session-Id';
 
@@ -72,6 +78,7 @@ const CLAUDE_AGENT_SDK_SYSTEM_TEXT =
 const FINGERPRINT_SALT = '59cf53e54c78';
 const AUDIT_ENV = 'PIPELINE_ANTHROPIC_ATTRIBUTION_AUDIT_PATH';
 const CACHE_RETENTION_ENV = 'PI_CACHE_RETENTION';
+export const ANTHROPIC_ACCOUNT_CONFIG_PATH_ENV = 'PI_ANTHROPIC_ACCOUNT_CONFIG_PATH';
 export const ANTHROPIC_CACHE_RETENTION_ENTRY = 'pipeline-anthropic-cache-retention';
 const ANTHROPIC_CACHE_RETENTION_SCHEMA = 'pipeline.anthropic_cache_retention.v1';
 export const ANTHROPIC_ATTRIBUTION_CLAIM_CHANNEL = 'pi-anthropic-attribution:claim:v1';
@@ -146,8 +153,11 @@ interface PiModelCostLike extends PiCostRatesLike {
 export interface PiModelLike {
   readonly provider?: string;
   readonly id?: string;
+  readonly name?: string;
   readonly api?: string;
   readonly baseUrl?: string;
+  readonly input?: readonly ('text' | 'image')[];
+  readonly contextWindow?: number;
   readonly maxTokens?: number;
   readonly reasoning?: boolean;
   readonly compat?: {
@@ -394,7 +404,11 @@ interface PiAssistantDiagnosticLike {
 }
 
 type PiMessage =
-  | { readonly role: 'user'; readonly content: string | readonly PiContentBlock[] }
+  | {
+      readonly role: 'user';
+      readonly content: string | readonly PiContentBlock[];
+      readonly timestamp?: number;
+    }
   | {
       readonly role: 'assistant';
       readonly content: readonly JsonObject[];
@@ -404,6 +418,7 @@ type PiMessage =
       readonly responseId?: string;
       readonly stopReason?: string;
       readonly diagnostics?: readonly PiAssistantDiagnosticLike[];
+      readonly timestamp?: number;
     }
   | {
       readonly role: 'toolResult';
@@ -411,6 +426,7 @@ type PiMessage =
       readonly toolName?: string;
       readonly content: readonly PiContentBlock[];
       readonly isError?: boolean;
+      readonly timestamp?: number;
     };
 
 export interface PiStreamContext {
@@ -449,8 +465,12 @@ export interface PiSimpleStreamOptions {
   ) => Promise<void> | void;
 }
 
+export type HostAnthropicMessagesApiFactory =
+  typeof import('@earendil-works/pi-ai/compat').anthropicMessagesApi;
+
 export interface AnthropicTransportDependencies {
   readonly loadAccount?: () => ClaudeAttributionAccount;
+  readonly hostAnthropicMessagesApi?: HostAnthropicMessagesApiFactory;
 }
 
 export interface AssistantMessageLike {
@@ -465,14 +485,20 @@ export interface AssistantMessageLike {
     cacheRead: number;
     cacheWrite: number;
     cacheWrite1h?: number;
+    reasoning?: number;
     totalTokens: number;
     cost: { input: number; output: number; cacheRead: number; cacheWrite: number; total: number };
   };
-  stopReason: 'stop' | 'length' | 'toolUse' | 'aborted' | 'error';
+  stopReason: 'pending' | 'stop' | 'length' | 'toolUse' | 'aborted' | 'error' | 'deferred';
   timestamp: number;
+  responseModel?: string;
   responseId?: string;
+  providerThinkingLevel?: string;
+  endTurn?: boolean;
   diagnostics?: PiAssistantDiagnosticLike[];
+  deferred?: unknown;
   errorMessage?: string;
+  rawStopReason?: string;
 }
 
 type AssistantMessageEvent =
@@ -862,20 +888,43 @@ export function extractClaudeAttributionAccount(
   };
 }
 
+export function resolveClaudeAttributionConfigPath(
+  explicitConfigPath?: string,
+  env?: ProviderEnv,
+  homeDirectory = homedir(),
+): string {
+  const configuredPath = providerEnvValue(ANTHROPIC_ACCOUNT_CONFIG_PATH_ENV, env);
+  const selectedPath = explicitConfigPath ?? configuredPath ?? join(homeDirectory, '.claude.json');
+  const source =
+    explicitConfigPath !== undefined
+      ? 'explicit configPath'
+      : configuredPath !== undefined
+        ? ANTHROPIC_ACCOUNT_CONFIG_PATH_ENV
+        : 'default ~/.claude.json path';
+  if (selectedPath.trim().length === 0 || !isAbsolute(selectedPath)) {
+    throw new Error(
+      `Anthropic attribution ${source} must be a non-empty absolute file path; got ${JSON.stringify(selectedPath)}`,
+    );
+  }
+  return selectedPath;
+}
+
 export function loadClaudeAttributionAccount(
-  configPath = join(homedir(), '.claude.json'),
+  configPath?: string,
+  env?: ProviderEnv,
 ): ClaudeAttributionAccount {
+  const selectedPath = resolveClaudeAttributionConfigPath(configPath, env);
   let configText: string;
   try {
-    configText = readFileSync(configPath, 'utf8');
+    configText = readFileSync(selectedPath, 'utf8');
   } catch (error) {
     throw new Error(
-      `Anthropic attribution config ${configPath} could not be read: ${error instanceof Error ? error.message : String(error)}`,
+      `Anthropic attribution config ${selectedPath} could not be read: ${error instanceof Error ? error.message : String(error)}`,
     );
   }
   return extractClaudeAttributionAccount(
-    parseJsonValue(configText, `Anthropic attribution config ${configPath}`),
-    configPath,
+    parseJsonValue(configText, `Anthropic attribution config ${selectedPath}`),
+    selectedPath,
   );
 }
 
@@ -1414,6 +1463,10 @@ function isSha256(value: unknown): value is string {
   return typeof value === 'string' && /^[a-f0-9]{64}$/u.test(value);
 }
 
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
 function blockWithoutCacheControl(block: unknown): unknown {
   if (!isPlainObject(block)) return block;
   const output = { ...block };
@@ -1466,31 +1519,82 @@ function parseAnthropicLineageDetails(
     .find((candidate) => candidate.type === ANTHROPIC_LINEAGE_DIAGNOSTIC_TYPE);
   const details = diagnostic?.details;
   if (!isPlainObject(details)) return undefined;
+
+  const sourceModel = details['source_model'];
+  const responseId = details['response_id'];
+  const assistantContentSha256 = details['assistant_content_sha256'];
+  const conversationStaticSha256 = details['conversation_static_sha256'];
+  const requestMessageCount = details['request_message_count'];
+  const requestMessagesSha256 = details['request_messages_sha256'];
+  const cacheProfileSha256 = details['cache_profile_sha256'];
+  const cacheRetention = details['cache_retention'];
+  const compactionBoundarySha256 = details['compaction_boundary_sha256'];
+  const signatureEpochSha256 = details['signature_epoch_sha256'];
+  const signatureEpochInheritsPrior = details['signature_epoch_inherits_prior'];
+  const previousMessageId = details['previous_message_id'];
   if (
     details['schema_version'] !== ANTHROPIC_LINEAGE_SCHEMA ||
     details['projection_version'] !== ANTHROPIC_PROJECTION_VERSION ||
     details['source_provider'] !== 'anthropic' ||
     details['source_api'] !== 'anthropic-messages' ||
-    typeof details['source_model'] !== 'string' ||
-    typeof details['response_id'] !== 'string' ||
-    !isSha256(details['assistant_content_sha256']) ||
-    !isSha256(details['conversation_static_sha256']) ||
-    !Number.isSafeInteger(details['request_message_count']) ||
-    (details['request_message_count'] as number) < 0 ||
-    !isSha256(details['request_messages_sha256']) ||
-    !isSha256(details['cache_profile_sha256']) ||
-    (details['cache_retention'] !== 'none' &&
-      details['cache_retention'] !== 'short' &&
-      details['cache_retention'] !== 'long') ||
-    (details['compaction_boundary_sha256'] !== null &&
-      !isSha256(details['compaction_boundary_sha256'])) ||
-    !isSha256(details['signature_epoch_sha256']) ||
-    typeof details['signature_epoch_inherits_prior'] !== 'boolean' ||
-    (details['previous_message_id'] !== null && typeof details['previous_message_id'] !== 'string')
+    !isNonEmptyString(sourceModel) ||
+    !isNonEmptyString(responseId) ||
+    !isSha256(assistantContentSha256) ||
+    !isSha256(conversationStaticSha256) ||
+    typeof requestMessageCount !== 'number' ||
+    !Number.isSafeInteger(requestMessageCount) ||
+    requestMessageCount < 0 ||
+    !isSha256(requestMessagesSha256) ||
+    !isSha256(cacheProfileSha256) ||
+    (cacheRetention !== 'none' && cacheRetention !== 'short' && cacheRetention !== 'long') ||
+    (compactionBoundarySha256 !== null && !isSha256(compactionBoundarySha256)) ||
+    !isSha256(signatureEpochSha256) ||
+    typeof signatureEpochInheritsPrior !== 'boolean' ||
+    (previousMessageId !== null && !isNonEmptyString(previousMessageId))
   ) {
     return undefined;
   }
-  return details as unknown as AnthropicLineageDetails;
+
+  return {
+    schema_version: ANTHROPIC_LINEAGE_SCHEMA,
+    projection_version: ANTHROPIC_PROJECTION_VERSION,
+    source_provider: 'anthropic',
+    source_api: 'anthropic-messages',
+    source_model: sourceModel,
+    response_id: responseId,
+    assistant_content_sha256: assistantContentSha256,
+    conversation_static_sha256: conversationStaticSha256,
+    request_message_count: requestMessageCount,
+    request_messages_sha256: requestMessagesSha256,
+    cache_profile_sha256: cacheProfileSha256,
+    cache_retention: cacheRetention,
+    compaction_boundary_sha256: compactionBoundarySha256,
+    signature_epoch_sha256: signatureEpochSha256,
+    signature_epoch_inherits_prior: signatureEpochInheritsPrior,
+    previous_message_id: previousMessageId,
+  };
+}
+
+function isSuccessfulLineageStopReason(
+  stopReason: string | undefined,
+): stopReason is 'stop' | 'length' | 'toolUse' {
+  return stopReason === 'stop' || stopReason === 'length' || stopReason === 'toolUse';
+}
+
+function lineageBindsContainingAssistant(
+  message: Extract<PiMessage, { role: 'assistant' }>,
+  lineage: AnthropicLineageDetails,
+): boolean {
+  return (
+    message.provider === lineage.source_provider &&
+    message.api === lineage.source_api &&
+    isNonEmptyString(message.model) &&
+    message.model === lineage.source_model &&
+    isSuccessfulLineageStopReason(message.stopReason) &&
+    isNonEmptyString(message.responseId) &&
+    message.responseId === lineage.response_id &&
+    lineage.assistant_content_sha256 === assistantContentHash(message.content)
+  );
 }
 
 function canTargetReadAnthropicThinking(sourceModel: string, targetModel: string): boolean {
@@ -1529,11 +1633,25 @@ function resolveSignatureEpochPolicy(
   compactionBoundarySha256: string | null,
 ): SignatureEpochPolicy {
   const targetModelId = normalizedAnthropicModelId(model);
-  const latest = latestLineageForTarget({ messages }, targetModelId);
-  if (latest === undefined) {
+  const latestState = targetLineageState({ messages }, targetModelId);
+  if (latestState.kind === 'none') {
     return initialSignatureEpochPolicy(targetModelId, cacheRetention, compactionBoundarySha256);
   }
+  if (latestState.kind === 'untrusted') {
+    return {
+      sha256: sha256Canonical({
+        projection_version: ANTHROPIC_PROJECTION_VERSION,
+        kind: 'untrusted-lineage-reset',
+        target_model: targetModelId,
+        cache_retention: cacheRetention,
+        compaction_boundary_sha256: compactionBoundarySha256,
+        latest_assistant_sha256: latestState.assistantSha256,
+      }),
+      inheritsPrior: false,
+    };
+  }
 
+  const latest = latestState.lineage;
   const retentionChanged = latest.cache_retention !== cacheRetention;
   const declaredNewCompaction =
     compactionBoundarySha256 !== null &&
@@ -1565,22 +1683,12 @@ function isTrustedReplayableAnthropicAssistant(
   conversationStaticSha256: string,
   wireMessagesBeforeAssistant: readonly JsonObject[],
 ): boolean {
-  if (
-    message.provider !== 'anthropic' ||
-    message.api !== 'anthropic-messages' ||
-    typeof message.model !== 'string' ||
-    message.stopReason === 'error' ||
-    message.stopReason === 'aborted' ||
-    !canTargetReadAnthropicThinking(message.model, normalizedAnthropicModelId(targetModel))
-  ) {
-    return false;
-  }
+  if (typeof message.model !== 'string') return false;
   const lineage = parseAnthropicLineageDetails(message);
   if (
     lineage === undefined ||
-    lineage.source_model !== message.model ||
-    lineage.response_id !== message.responseId ||
-    lineage.assistant_content_sha256 !== assistantContentHash(message.content) ||
+    !lineageBindsContainingAssistant(message, lineage) ||
+    !canTargetReadAnthropicThinking(message.model, normalizedAnthropicModelId(targetModel)) ||
     lineage.cache_retention !== targetCacheRetention ||
     lineage.conversation_static_sha256 !== conversationStaticSha256 ||
     lineage.request_message_count !== wireMessagesBeforeAssistant.length ||
@@ -1858,12 +1966,20 @@ export function buildAnthropicRequestParams(
   context: PiStreamContext,
   options?: PiSimpleStreamOptions,
 ): JsonObject {
+  return buildAnthropicRequest(model, context, options).params;
+}
+
+function buildAnthropicRequest(
+  model: PiModelLike,
+  context: PiStreamContext,
+  options?: PiSimpleStreamOptions,
+): { readonly params: JsonObject; readonly signatureEpoch: SignatureEpochPolicy } {
   const policy = resolveClaudeCodeModelPolicy(model);
   const maxTokens = resolveAnthropicMaxTokens(model);
   const cacheControl = resolveAnthropicCacheControl(model, options);
   const cacheRetention: CacheRetention =
     cacheControl === undefined ? 'none' : cacheControl.ttl === '1h' ? 'long' : 'short';
-  const signatureEpoch = resolveSignatureEpochPolicy(
+  let signatureEpoch = resolveSignatureEpochPolicy(
     model,
     context.messages,
     cacheRetention,
@@ -1934,8 +2050,37 @@ export function buildAnthropicRequestParams(
     params['thinking'] = { type: 'disabled' };
     params['temperature'] = options?.temperature ?? 1;
   }
+  const previous = latestLineageForTarget(context, normalizedAnthropicModelId(model));
+  if (
+    previous !== undefined &&
+    signatureEpoch.sha256 === previous.signature_epoch_sha256 &&
+    (previous.cache_profile_sha256 !== cacheProfileHash(model, policy, params, staticSha256) ||
+      !hasLineageRequestPrefix(requestMessagesFromPayload(params), previous))
+  ) {
+    // Resume/reload and profile edits can invalidate a lane. Re-project before transport,
+    // rather than just clearing the response ID while retaining prefix-bound signatures.
+    signatureEpoch = {
+      sha256: sha256Canonical({
+        projection_version: ANTHROPIC_PROJECTION_VERSION,
+        kind: 'lineage-reset',
+        previous_signature_epoch_sha256: previous.signature_epoch_sha256,
+        previous_response_id: previous.response_id,
+        cache_profile_sha256: cacheProfileHash(model, policy, params, staticSha256),
+        request_messages_sha256: promptMessagesHash(requestMessagesFromPayload(params)),
+      }),
+      inheritsPrior: false,
+    };
+    params['messages'] = convertMessages(
+      model,
+      context.messages,
+      staticSha256,
+      cacheRetention,
+      signatureEpoch,
+      cacheControl,
+    );
+  }
   assertCacheControlBreakpointLimit(params);
-  return params;
+  return { params, signatureEpoch };
 }
 
 interface PreparedAnthropicLineage {
@@ -2001,24 +2146,68 @@ function cacheRetentionFromPayload(payload: JsonObject): CacheRetention {
   return inspectCacheControls(payload).retention ?? 'none';
 }
 
-function latestLineageForTarget(
+type TargetLineageState =
+  | { readonly kind: 'none' }
+  | { readonly kind: 'trusted'; readonly lineage: AnthropicLineageDetails }
+  | { readonly kind: 'untrusted'; readonly assistantSha256: string };
+
+function untrustedAssistantSha256(
+  message: Extract<PiMessage, { role: 'assistant' }>,
+): string {
+  return sha256Canonical({
+    provider: message.provider ?? null,
+    api: message.api ?? null,
+    model: message.model ?? null,
+    response_id: message.responseId ?? null,
+    stop_reason: message.stopReason ?? null,
+    assistant_content_sha256: assistantContentHash(message.content),
+    lineage_diagnostics: (message.diagnostics ?? []).filter(
+      (diagnostic) => diagnostic.type === ANTHROPIC_LINEAGE_DIAGNOSTIC_TYPE,
+    ),
+  });
+}
+
+function targetLineageState(
   context: PiStreamContext,
   targetModelId: string,
-): AnthropicLineageDetails | undefined {
+): TargetLineageState {
   for (let index = context.messages.length - 1; index >= 0; index -= 1) {
     const message = context.messages[index];
+    if (message?.role !== 'assistant') continue;
+
+    const lineageDiagnostics = (message.diagnostics ?? []).filter(
+      (diagnostic) => diagnostic.type === ANTHROPIC_LINEAGE_DIAGNOSTIC_TYPE,
+    );
+    const latestRawDetails = lineageDiagnostics.at(-1)?.details;
+    const receiptClaimsTarget = latestRawDetails?.['source_model'] === targetModelId;
+    const assistantClaimsTarget = message.model === targetModelId;
+    if (!assistantClaimsTarget && !receiptClaimsTarget) continue;
+
     if (
-      message?.role !== 'assistant' ||
-      message.model !== targetModelId ||
-      message.stopReason === 'error' ||
-      message.stopReason === 'aborted'
+      (message.stopReason === 'error' || message.stopReason === 'aborted') &&
+      lineageDiagnostics.length === 0
     ) {
       continue;
     }
+
     const lineage = parseAnthropicLineageDetails(message);
-    return lineage?.source_model === targetModelId ? lineage : undefined;
+    if (
+      lineage?.source_model === targetModelId &&
+      lineageBindsContainingAssistant(message, lineage)
+    ) {
+      return { kind: 'trusted', lineage };
+    }
+    return { kind: 'untrusted', assistantSha256: untrustedAssistantSha256(message) };
   }
-  return undefined;
+  return { kind: 'none' };
+}
+
+function latestLineageForTarget(
+  context: PiStreamContext,
+  targetModelId: string,
+): AnthropicLineageDetails | undefined {
+  const state = targetLineageState(context, targetModelId);
+  return state.kind === 'trusted' ? state.lineage : undefined;
 }
 
 function declaredCompactionBoundarySha256(messages: readonly JsonObject[]): string | null {
@@ -2035,11 +2224,23 @@ function declaredCompactionBoundarySha256(messages: readonly JsonObject[]): stri
   return sha256Canonical(promptMessagesWithoutCacheControls([firstMessage])[0]);
 }
 
+function hasLineageRequestPrefix(
+  messages: readonly JsonObject[],
+  previous: AnthropicLineageDetails,
+): boolean {
+  return (
+    messages.length >= previous.request_message_count &&
+    promptMessagesHash(messages.slice(0, previous.request_message_count)) ===
+      previous.request_messages_sha256
+  );
+}
+
 function prepareAnthropicLineageDetails(args: {
   readonly model: PiModelLike;
   readonly policy: ClaudeCodeModelPolicy;
   readonly context: PiStreamContext;
   readonly payload: JsonObject;
+  readonly signatureEpoch: SignatureEpochPolicy;
 }): PreparedAnthropicLineage['details'] {
   const targetModelId = normalizedAnthropicModelId(args.model);
   const messages = requestMessagesFromPayload(args.payload);
@@ -2050,37 +2251,16 @@ function prepareAnthropicLineageDetails(args: {
   const profileSha256 = cacheProfileHash(args.model, args.policy, args.payload, staticSha256);
   const cacheRetention = cacheRetentionFromPayload(args.payload);
   const compactionBoundarySha256 = declaredCompactionBoundarySha256(messages);
-  const signatureEpoch = resolveSignatureEpochPolicy(
-    args.model,
-    args.context.messages,
-    cacheRetention,
-    compactionBoundarySha256,
-  );
+  const signatureEpoch = args.signatureEpoch;
   let previous = latestLineageForTarget(args.context, targetModelId);
-  if (previous !== undefined) {
-    const prefixStillExists =
-      messages.length >= previous.request_message_count &&
-      promptMessagesHash(messages.slice(0, previous.request_message_count)) ===
-        previous.request_messages_sha256;
-    if (
-      !prefixStillExists &&
-      compactionBoundarySha256 !== null &&
-      compactionBoundarySha256 !== previous.compaction_boundary_sha256
-    ) {
-      previous = undefined;
-    } else {
-      if (!prefixStillExists) {
-        throw new Error(
-          'Anthropic cache lineage diverged before transport: message history is not append-only',
-        );
-      }
-      if (previous.cache_profile_sha256 !== profileSha256) {
-        throw new Error(
-          'Anthropic cache lineage diverged before transport: model/system/tools/thinking/beta profile changed',
-        );
-      }
-      if (previous.cache_retention !== cacheRetention) previous = undefined;
-    }
+  if (
+    previous !== undefined &&
+    (signatureEpoch.sha256 !== previous.signature_epoch_sha256 ||
+      !hasLineageRequestPrefix(messages, previous) ||
+      previous.cache_profile_sha256 !== profileSha256 ||
+      previous.cache_retention !== cacheRetention)
+  ) {
+    previous = undefined;
   }
   return {
     schema_version: ANTHROPIC_LINEAGE_SCHEMA,
@@ -2109,6 +2289,7 @@ class AnthropicLineageCoordinator {
     readonly policy: ClaudeCodeModelPolicy;
     readonly context: PiStreamContext;
     readonly payload: JsonObject;
+    readonly signatureEpoch: SignatureEpochPolicy;
   }): PreparedAnthropicLineage {
     const targetModelId = normalizedAnthropicModelId(args.model);
     const key = `${args.sessionId}\u0000${targetModelId}`;
@@ -2136,6 +2317,14 @@ export function createAnthropicLineageDiagnostic(args: {
   readonly requestPayload: JsonObject;
   readonly previousMessageId?: string | null;
 }): PiAssistantDiagnosticLike {
+  if (!isNonEmptyString(args.responseId)) {
+    throw new Error('Anthropic lineage diagnostic requires a non-empty response ID');
+  }
+  if (args.previousMessageId !== undefined && args.previousMessageId !== null) {
+    if (!isNonEmptyString(args.previousMessageId)) {
+      throw new Error('Anthropic lineage diagnostic requires a non-empty previous response ID');
+    }
+  }
   const policy = resolveClaudeCodeModelPolicy(args.model);
   const messages = requestMessagesFromPayload(args.requestPayload);
   const staticSha256 = conversationStaticHash(
@@ -2177,7 +2366,7 @@ function appendLineageDiagnostic(
   output: AssistantMessageLike,
   prepared: PreparedAnthropicLineage,
 ): void {
-  if (typeof output.responseId !== 'string' || output.responseId.length === 0) {
+  if (!isNonEmptyString(output.responseId)) {
     throw new Error(
       'Anthropic attribution successful response is missing responseId lineage proof',
     );
@@ -2488,33 +2677,37 @@ function createOutput(model: PiModelLike): AssistantMessageLike {
   };
 }
 
-async function forwardToBuiltInAnthropic(
+type HostForwardingModel = PiModelLike & HostModel<'anthropic-messages'>;
+type HostForwardingContext = PiStreamContext & HostContext;
+type HostForwardingOptions = PiSimpleStreamOptions & HostSimpleStreamOptions;
+type HostForwardingStream = AssistantMessageEventStreamLike & HostAssistantMessageEventStream;
+
+function forwardToBuiltInAnthropic(
   model: PiModelLike,
   context: PiStreamContext,
   options: PiSimpleStreamOptions | undefined,
-  stream: AssistantMessageEventStreamLike,
-  output: AssistantMessageLike,
-): Promise<void> {
-  try {
-    const dynamicImport = new Function('specifier', 'return import(specifier)') as (
-      specifier: string,
-    ) => Promise<{
-      streamSimpleAnthropic: (
-        model: PiModelLike,
-        context: PiStreamContext,
-        options?: PiSimpleStreamOptions,
-      ) => AssistantMessageEventStreamLike;
-    }>;
-    const mod = await dynamicImport('@earendil-works/pi-ai/anthropic');
-    const delegated = mod.streamSimpleAnthropic(model, context, options);
-    for await (const event of delegated) stream.push(event);
-    stream.end(await delegated.result());
-  } catch (error) {
-    output.stopReason = 'error';
-    output.errorMessage = `Anthropic attribution could not delegate non-target provider ${JSON.stringify(model.provider)}: ${error instanceof Error ? error.message : String(error)}`;
-    stream.push({ type: 'error', reason: 'error', error: output });
-    stream.end();
+  dependencies: AnthropicTransportDependencies,
+): AssistantMessageEventStreamLike {
+  // The compiled gateway resolves this host-owned adapter through Pi's alias-aware
+  // extension loader and injects it across the lazy native-import boundary. Keeping
+  // the deferred core free of runtime Pi package imports prevents Node from trying to
+  // resolve a private @earendil-works/pi-ai installation beside a managed package.
+  const hostAnthropicMessagesApi = dependencies.hostAnthropicMessagesApi;
+  if (hostAnthropicMessagesApi === undefined) {
+    throw new Error(
+      "pi_anthropic_attribution_host_adapter_missing: the extension gateway did not inject Pi's anthropic-messages adapter",
+    );
   }
+
+  // The host owns both its legacy Context or normalized TranscriptContext input and
+  // the complete stream/event/result shape. These intersections only mark that
+  // host-owned boundary; no request, callback, event, or result is reconstructed.
+  const delegated = hostAnthropicMessagesApi().streamSimple(
+    model as HostForwardingModel,
+    context as HostForwardingContext,
+    options as HostForwardingOptions | undefined,
+  );
+  return delegated as HostForwardingStream;
 }
 
 export function streamAnthropicViaBetaMessages(
@@ -2523,14 +2716,12 @@ export function streamAnthropicViaBetaMessages(
   options?: PiSimpleStreamOptions,
   dependencies: AnthropicTransportDependencies = {},
 ): AssistantMessageEventStreamLike {
-  const stream = createAssistantMessageEventStream();
-  const output = createOutput(model);
-
   if (model.provider !== 'anthropic') {
-    void forwardToBuiltInAnthropic(model, context, options, stream, output);
-    return stream;
+    return forwardToBuiltInAnthropic(model, context, options, dependencies);
   }
 
+  const stream = createAssistantMessageEventStream();
+  const output = createOutput(model);
   void (async () => {
     let preparedLineage: PreparedAnthropicLineage | undefined;
     try {
@@ -2548,11 +2739,12 @@ export function streamAnthropicViaBetaMessages(
 
       const sessionId = requireSessionId(options?.sessionId, 'options.sessionId');
       const account = requireAttributionAccount(
-        (dependencies.loadAccount ?? loadClaudeAttributionAccount)(),
+        dependencies.loadAccount?.() ?? loadClaudeAttributionAccount(undefined, options?.env),
       );
       const url = resolveAnthropicBetaMessagesUrl(model);
       const policy = resolveClaudeCodeModelPolicy(model);
-      let params = buildAnthropicRequestParams(model, context, options);
+      const request = buildAnthropicRequest(model, context, options);
+      let params = request.params;
       const billingSystemText = buildClaudeCodeBillingSystemText(
         firstUserMessageTextFromPayload(params),
       );
@@ -2561,6 +2753,7 @@ export function streamAnthropicViaBetaMessages(
         policy,
         context,
         payload: params,
+        signatureEpoch: request.signatureEpoch,
       });
       if (policy.supportsCacheDiagnostics) {
         if (!policy.beta.split(',').includes(ANTHROPIC_CACHE_DIAGNOSTICS_BETA)) {
@@ -2608,6 +2801,7 @@ export function streamAnthropicViaBetaMessages(
         policy,
         context,
         payload: params,
+        signatureEpoch: request.signatureEpoch,
       });
       if (
         preparedLineage.details.previous_message_id !== provisionalLineage.previous_message_id ||
@@ -2693,7 +2887,7 @@ export function streamAnthropicViaBetaMessages(
               'Anthropic beta messages stream emitted malformed/duplicate message_start',
             );
           }
-          if (typeof event['message']['id'] !== 'string' || event['message']['id'].length === 0) {
+          if (!isNonEmptyString(event['message']['id'])) {
             throw new Error('Anthropic beta messages message_start is missing a response id');
           }
           sawMessageStart = true;

package/src/core/attested-pi-contract.ts

@@ -0,0 +1,4 @@
+export const ATTESTED_TASK_ID_PATTERN = /^b[0-9a-f]{32}$/;
+export const ATTESTED_GIT_TIMEOUT_MS = 30_000;
+export const ATTESTED_GIT_KILL_GRACE_MS = 250;
+export const ATTESTED_GIT_MAX_OUTPUT_BYTES = 4 * 1024 * 1024;