pi-background-tasks 0.7.7 → 1.0.3

package/src/core/fusion/config.ts

@@ -24,6 +24,7 @@ export interface FusionModelRegistry {
   getAll(): Model<Api>[];
   getAvailable(): Model<Api>[];
   find?(provider: string, modelId: string): Model<Api> | undefined;
+  isUsingOAuth?(model: Model<Api>): boolean;
 }
 
 export interface ResolveFusionModelsInput {
@@ -163,12 +164,119 @@ function modelIndex(models: readonly Model<Api>[]): Map<string, Model<Api>> {
   return out;
 }
 
+const FRONTIER_MODEL_PATTERN =
+  /(?:^|[-_/])(?:gpt|codex|claude|opus|sonnet|o[134](?:-[a-z0-9.]+)*)(?:[-_/]|$)/iu;
+const TRUSTED_SUBSCRIPTION_ENDPOINTS = Object.freeze({
+  anthropic: 'https://api.anthropic.com',
+  'openai-codex': 'https://chatgpt.com/backend-api',
+} as const);
+const AUTH_HEADER_NAMES = new Set(['authorization', 'proxy-authorization', 'x-api-key', 'api-key']);
+
+function isKnownFrontierEndpoint(baseUrl: string | undefined): boolean {
+  if (baseUrl === undefined || baseUrl.trim().length === 0) return false;
+  try {
+    const hostname = new URL(baseUrl).hostname.toLowerCase().replace(/\.+$/u, '');
+    return (
+      hostname === 'api.openai.com' ||
+      hostname === 'api.anthropic.com' ||
+      hostname === 'openrouter.ai' ||
+      hostname === 'chatgpt.com' ||
+      hostname.endsWith('.openai.azure.com') ||
+      hostname.endsWith('.cognitiveservices.azure.com') ||
+      hostname.endsWith('.ai.azure.com')
+    );
+  } catch {
+    return false;
+  }
+}
+
+function assertTrustedSubscriptionEndpoint(
+  model: Model<Api>,
+  slotLabel: string,
+  provider: keyof typeof TRUSTED_SUBSCRIPTION_ENDPOINTS,
+): void {
+  const expectedText = TRUSTED_SUBSCRIPTION_ENDPOINTS[provider];
+  const effectiveText = model.baseUrl?.trim() || expectedText;
+  let effective: URL;
+  try {
+    effective = new URL(effectiveText);
+  } catch {
+    throw new FusionError(
+      `${slotLabel} route ${model.provider}/${model.id} has a malformed subscription endpoint`,
+      { code: 'model_unavailable', childCreated: false },
+    );
+  }
+  const expected = new URL(expectedText);
+  const effectivePath = effective.href.slice(effective.origin.length).replace(/\/+$/u, '');
+  const expectedPath = expected.href.slice(expected.origin.length).replace(/\/+$/u, '');
+  if (
+    effective.protocol !== 'https:' ||
+    effective.username !== '' ||
+    effective.password !== '' ||
+    effective.search !== '' ||
+    effective.hash !== '' ||
+    effective.origin !== expected.origin ||
+    effectivePath !== expectedPath
+  ) {
+    throw new FusionError(
+      `${slotLabel} route ${model.provider}/${model.id} does not use the trusted Pi subscription endpoint ${expectedText}`,
+      { code: 'model_unavailable', childCreated: false },
+    );
+  }
+  const unsafeHeader = Object.keys(model.headers ?? {}).find((name) =>
+    AUTH_HEADER_NAMES.has(name.toLowerCase()),
+  );
+  if (unsafeHeader !== undefined) {
+    throw new FusionError(
+      `${slotLabel} route ${model.provider}/${model.id} overrides subscription authentication header ${unsafeHeader}`,
+      { code: 'model_unavailable', childCreated: false },
+    );
+  }
+}
+
+function assertSubscriptionRoute(
+  model: Model<Api>,
+  slotLabel: string,
+  registry: FusionModelRegistry,
+): void {
+  const provider = model.provider.toLowerCase();
+  const frontier =
+    provider === 'openai' ||
+    provider === 'openrouter' ||
+    provider === 'anthropic' ||
+    provider === 'openai-codex' ||
+    provider.includes('azure') ||
+    FRONTIER_MODEL_PATTERN.test(`${provider}/${model.id}`) ||
+    isKnownFrontierEndpoint(model.baseUrl);
+  if (!frontier) return;
+  if (provider !== 'anthropic' && provider !== 'openai-codex') {
+    throw new FusionError(
+      `${slotLabel} route ${model.provider}/${model.id} is a frontier-model API channel; Fusion requires the Pi Anthropic or Codex subscription route`,
+      { code: 'model_unavailable', childCreated: false },
+    );
+  }
+  assertTrustedSubscriptionEndpoint(model, slotLabel, provider);
+  if (registry.isUsingOAuth === undefined) {
+    throw new FusionError(
+      `${slotLabel} route ${model.provider}/${model.id} cannot be admitted because ModelRegistry OAuth observation is unavailable`,
+      { code: 'model_unavailable', childCreated: false },
+    );
+  }
+  if (!registry.isUsingOAuth(model)) {
+    throw new FusionError(
+      `${slotLabel} route ${model.provider}/${model.id} is not using subscription OAuth; metered API credentials are forbidden for Fusion`,
+      { code: 'model_unavailable', childCreated: false },
+    );
+  }
+}
+
 function resolveSelection(
   selection: FusionModelSelection,
   slotLabel: string,
   availableByKey: Map<string, Model<Api>>,
   currentModel: Model<Api> | undefined,
   thinkingLevel: FusionThinkingLevel,
+  registry: FusionModelRegistry,
 ): ResolvedFusionModel {
   if (selection === CURRENT_MODEL_SELECTION) {
     if (currentModel === undefined) {
@@ -188,6 +296,7 @@ function resolveSelection(
         },
       );
     }
+    assertSubscriptionRoute(available, slotLabel, registry);
     return {
       selection,
       source: 'current',
@@ -205,6 +314,7 @@ function resolveSelection(
       childCreated: false,
     });
   }
+  assertSubscriptionRoute(model, slotLabel, registry);
   return {
     selection,
     source: 'configured',
@@ -219,44 +329,23 @@ function resolveSelection(
 export function resolveFusionModels(input: ResolveFusionModelsInput): ResolvedFusionModels {
   const availableByKey = modelIndex(input.modelRegistry.getAvailable());
   const [first, second, third] = input.config.candidates;
-  return {
-    candidates: [
-      resolveSelection(
-        first,
-        'candidate 1',
-        availableByKey,
-        input.currentModel,
-        input.thinkingLevel,
-      ),
-      resolveSelection(
-        second,
-        'candidate 2',
-        availableByKey,
-        input.currentModel,
-        input.thinkingLevel,
-      ),
-      resolveSelection(
-        third,
-        'candidate 3',
-        availableByKey,
-        input.currentModel,
-        input.thinkingLevel,
-      ),
-    ],
-    evaluator: resolveSelection(
-      input.config.evaluator,
-      'evaluator',
-      availableByKey,
-      input.currentModel,
-      input.thinkingLevel,
-    ),
-    merger: resolveSelection(
-      input.config.merger,
-      'merger',
+  const resolve = (selection: FusionModelSelection, slot: string): ResolvedFusionModel =>
+    resolveSelection(
+      selection,
+      slot,
       availableByKey,
       input.currentModel,
       input.thinkingLevel,
-    ),
+      input.modelRegistry,
+    );
+  return {
+    candidates: [
+      resolve(first, 'candidate 1'),
+      resolve(second, 'candidate 2'),
+      resolve(third, 'candidate 3'),
+    ],
+    evaluator: resolve(input.config.evaluator, 'evaluator'),
+    merger: resolve(input.config.merger, 'merger'),
   };
 }
 

package/src/core/fusion/context.ts

@@ -13,6 +13,7 @@ import {
   type ReadonlyParentSessionManager,
 } from '../context/parent-snapshot.js';
 import type { Message } from '@earendil-works/pi-ai';
+import { FUSION_REASON_TOOL_NAME } from './workflows.js';
 import {
   FUSION_BRANCH_FILTER_ID,
   FUSION_COMMAND_CONTEXT_POLICY_ID,
@@ -22,8 +23,9 @@ import {
   FUSION_TOOL_CONTEXT_POLICY_ID,
   FusionError,
   type FusionBranchFilterDescriptor,
-  type FusionCanonicalInputV3,
   type FusionCanonicalRequestV3,
+  type FusionSessionProjectionCanonicalInputV5,
+  type FusionWorkflowId,
   type FusionContextOmissionLedgerV2,
   type FusionContextPolicyDescriptor,
   type FusionConversationProjectionV3,
@@ -33,7 +35,17 @@ import {
   type FusionSource,
 } from './types.js';
 
-export const FUSION_BRAINSTORM_TOOL_NAME = 'fusion_brainstorm';
+/**
+ * Re-exported from the workflow registry, which owns every workflow's tool name.
+ * Kept here so existing importers of this module keep working unchanged.
+ */
+export {
+  FUSION_BRAINSTORM_TOOL_NAME,
+  FUSION_REASON_TOOL_NAME,
+  FUSION_INVESTIGATE_TOOL_NAME,
+  FUSION_RESEARCH_TOOL_NAME,
+  FUSION_VALIDATE_TOOL_NAME,
+} from './workflows.js';
 
 /** Retained for source compatibility; Fusion's session access is the shared adapter. */
 export type FusionReadonlySessionManager = ReadonlyParentSessionManager;
@@ -44,10 +56,11 @@ export interface BuildFusionCanonicalInputOptions {
   request: string;
   toolCallId?: string;
   toolName?: string;
+  workflow?: FusionWorkflowId;
 }
 
 export interface BuiltFusionCanonicalInput {
-  input: FusionCanonicalInputV3;
+  input: FusionSessionProjectionCanonicalInputV5;
   serialized: string;
   ledger: FusionContextOmissionLedgerV2;
   transcriptLeafId: string | null;
@@ -202,7 +215,14 @@ export function buildFusionCanonicalInput(
       childCreated: false,
     });
   }
-  const toolName = options.toolName ?? FUSION_BRAINSTORM_TOOL_NAME;
+  const workflow = options.workflow ?? 'reason';
+  if (workflow !== 'reason') {
+    throw new FusionError('parent session projection is available only to the reason workflow', {
+      code: 'context_capture_failed',
+      childCreated: false,
+    });
+  }
+  const toolName = options.toolName ?? FUSION_REASON_TOOL_NAME;
   const snapshotOptions: ParentSnapshotOptions = {
     toolName,
     excludeActiveToolCallLeaf: options.source === 'tool',
@@ -222,12 +242,19 @@ export function buildFusionCanonicalInput(
     text: options.request,
     sha256: sha256Text(options.request),
   };
-  const input: FusionCanonicalInputV3 = {
+  const input: FusionSessionProjectionCanonicalInputV5 = {
     schema_version: FUSION_INPUT_SCHEMA_VERSION,
+    workflow: 'reason',
     cwd: ctx.cwd,
-    system_prompt: ctx.getSystemPrompt(),
     request,
+    system_prompt: ctx.getSystemPrompt(),
     conversation_projection: projected.projection,
+    context: {
+      kind: 'session_projection',
+      policy_id: 'fusion-session-projection-v1',
+      system_prompt: ctx.getSystemPrompt(),
+      conversation_projection: projected.projection,
+    },
   };
   return {
     input,