pi-workflow-engine 0.12.0 → 1.0.0

package/.pi/extensions/pi-workflow-engine/src/agent-retry.ts

@@ -1,6 +1,7 @@
 import { isRetryableAssistantError, type AssistantMessage } from "@earendil-works/pi-ai";
 import { abortReason, throwIfAborted } from "./cancellation.ts";
 import {
+  lastAssistantError,
   providerUsageLimitFromMessages,
   type WorkflowProviderUsageLimitError,
 } from "./provider-usage-limit.ts";
@@ -75,42 +76,18 @@ export function providerErrorFromMessages(
   messages: readonly unknown[],
   options: { readonly pauseOnUsageLimit?: boolean } = {},
 ): WorkflowProviderError | WorkflowProviderUsageLimitError | undefined {
-  const usageLimit = providerUsageLimitFromMessages(messages);
-  if (usageLimit && options.pauseOnUsageLimit) return usageLimit;
-  const message = messages.findLast(isAssistantMessage);
-  if (!message || message.stopReason !== "error") return undefined;
-  const errorMessage = typeof message.errorMessage === "string" && message.errorMessage.length > 0
-    ? message.errorMessage
-    : "Provider session ended with an unspecified error.";
-  const retryable = isRetryableAssistantError(message as AssistantMessage);
-  const provider = stringDetail(message.provider);
-  const model = stringDetail(message.model);
-  const api = stringDetail(message.api);
-  return new WorkflowProviderError(errorMessage, {
-    stopReason: "error",
-    retryable,
-    ...(provider ? { provider } : {}),
-    ...(model ? { model } : {}),
-    ...(api ? { api } : {}),
-  });
-}
-
-function isAssistantMessage(value: unknown): value is {
-  readonly role: "assistant";
-  readonly stopReason?: unknown;
-  readonly errorMessage?: unknown;
-  readonly provider?: unknown;
-  readonly model?: unknown;
-  readonly api?: unknown;
-} {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "role" in value &&
-    value.role === "assistant"
+  if (options.pauseOnUsageLimit) {
+    const usageLimit = providerUsageLimitFromMessages(messages);
+    if (usageLimit) return usageLimit;
+  }
+  const failure = lastAssistantError(messages);
+  if (!failure) return undefined;
+  return new WorkflowProviderError(
+    failure.errorMessage || "Provider session ended with an unspecified error.",
+    {
+      stopReason: "error",
+      retryable: isRetryableAssistantError(failure.message as AssistantMessage),
+      ...failure.details,
+    },
   );
 }
-
-function stringDetail(value: unknown): string | undefined {
-  return typeof value === "string" && value.length > 0 ? value : undefined;
-}

package/.pi/extensions/pi-workflow-engine/src/agent-runner-types.ts

@@ -29,18 +29,18 @@ export type AgentRunnerSession = Pick<
   | "getActiveToolNames"
   | "getToolDefinition"
   | "setActiveToolsByName"
-  | "setAutoRetryEnabled"
   | "getLastAssistantText"
 >;
 
 export type CreateAgentSession = (options: CreateAgentSessionOptions) => Promise<{ session: AgentRunnerSession }>;
 
+/** Every row update after `agentQueued` addresses that row by its id; labels are display text, not unique keys. */
 export interface AgentProgress {
   agentQueued(phase: string | undefined, label: string): number;
-  agentStart(phase: string | undefined, label: string, id?: number): void;
-  agentTool(label: string, tool: string, id?: number): void;
-  agentDone(label: string, id?: number): void;
-  agentFailed(label: string, error: unknown, id?: number): void;
+  agentStart(id: number): void;
+  agentTool(id: number, tool: string): void;
+  agentDone(id: number): void;
+  agentFailed(id: number, error: unknown): void;
   event(event: WorkflowProgressEvent): void;
   log(message: string): void;
 }
@@ -83,9 +83,3 @@ export type RunContext = RunContextBase & (
 export type AgentExecutionOptions = AgentOptions & {
   readonly worktreeBaseline?: WorktreeBaseline;
 };
-
-export interface AgentRunTags {
-  readonly [key: string]: string | number;
-  readonly label: string;
-  readonly phase: string;
-}

package/.pi/extensions/pi-workflow-engine/src/agent-runner.ts

@@ -9,13 +9,9 @@ import {
   type AgentAttemptResult,
   type AgentReplayPlan,
 } from "./agent-replay.ts";
-import {
-  resolveAgentModel,
-  type ResolvedAgentModel,
-} from "./agent-session.ts";
+import { resolveAgentModel } from "./agent-session.ts";
 import type {
   AgentExecutionOptions,
-  AgentRunTags,
   RunContext,
 } from "./agent-runner-types.ts";
 import type { AgentResumeBaseContext } from "./resume-context.ts";
@@ -33,8 +29,6 @@ export type {
   CreateAgentSession,
   RunContext,
 } from "./agent-runner-types.ts";
-export { resolveAgentModel } from "./agent-session.ts";
-export type { ResolvedAgentModel, ResolvedAgentModelRequest } from "./agent-session.ts";
 
 /**
  * Run one subagent to completion in an isolated in-memory session.
@@ -54,7 +48,6 @@ export async function runAgent(
 
   const label = opts.label ?? "agent";
   const phase = opts.phase ?? "Workflow";
-  const tags: AgentRunTags = { label, phase };
 
   return await rc.perf.time("agent.total_ms", async () => {
     throwIfAborted(rc.signal);
@@ -73,7 +66,7 @@ export async function runAgent(
           const agentRc: RunContext = { ...rc, signal: liveScope.signal };
           throwIfAborted(agentRc.signal);
           if (!isReplayEnabled(replay)) assertWorkflowBudgetAvailable(agentRc.budget);
-          rc.progress.agentStart(opts.phase, label, rowId);
+          rc.progress.agentStart(rowId);
           if (replay.kind === "disabled") {
             rc.progress.log(`${label}: resume disabled for this call (${replay.reason})`);
           }
@@ -92,7 +85,7 @@ export async function runAgent(
                 replay: attemptPlan,
                 label,
                 rowId,
-                tags,
+                phase,
                 admitLiveAgent: liveScope.admit,
               });
             } catch (error) {
@@ -108,23 +101,23 @@ export async function runAgent(
               providerRetries++;
               const delayMs = agentRetryDelayMs(providerRetries);
               rc.progress.log(`${label}: transient provider failure; retry ${providerRetries}/${agentRc.agentRetries} in ${delayMs}ms`);
-              rc.perf.counter("agent.provider_retry", 1, tags);
-              rc.perf.observe("agent.provider_retry_delay_ms", delayMs, tags);
-              attemptPlan = { kind: "off" };
+              rc.perf.counter("agent.provider_retry");
+              rc.perf.observe("agent.provider_retry_delay_ms", delayMs);
+              // Keep the replay plan: the failed attempt recorded nothing, and the restart recaptures identity.
               await agentRc.retryScheduler.sleep(delayMs, agentRc.signal);
               continue;
             }
-            const settlement = await settleAgentAttempt({ rc: agentRc, label, tags, replay: attemptPlan, outcome });
+            const settlement = await settleAgentAttempt({ rc: agentRc, label, outcome });
             if (settlement.kind === "retry-live") {
               attemptPlan = { kind: "off" };
               continue;
             }
-            rc.progress.agentDone(label, rowId);
+            rc.progress.agentDone(rowId);
             return settlement.result;
           }
         },
         {
-          onQueueWaitMs: (durationMs) => rc.perf.observe("agent.queue_wait_ms", durationMs, tags),
+          onQueueWaitMs: (durationMs) => rc.perf.observe("agent.queue_wait_ms", durationMs),
           signal: rc.signal,
         },
       );
@@ -132,13 +125,13 @@ export async function runAgent(
       let failure = error;
       if (liveScope.signal.aborted) failure = abortReason(liveScope.signal);
       if (rc.signal?.aborted) failure = abortReason(rc.signal);
-      rc.progress.agentFailed(label, failure, rowId);
+      rc.progress.agentFailed(rowId, failure);
       rc.progress.log(`${label} failed: ${unknownErrorMessage(failure)}`);
       throw failure;
     } finally {
       liveScope.dispose();
     }
-  }, tags);
+  });
 }
 
 function createAgentLiveScope(rc: RunContext, label: string) {
@@ -169,18 +162,19 @@ function resolveAgentRouting(
   rc: RunContext,
   opts: AgentExecutionOptions,
   label: string,
-): { readonly model: ResolvedAgentModel["model"]; readonly thinkingLevel: AgentExecutionOptions["thinkingLevel"] } {
+): ReturnType<typeof resolveAgentModelProfile> {
   try {
     return resolveAgentModelProfile(
       {
         request: opts,
         profiles: rc.modelProfiles,
-        resolveExplicitModel: (modelRef) => resolveAgentModel(modelRef, rc.modelRegistry, rc.hostModel).model,
+        resolveExplicitModel: (modelRef) => resolveAgentModel(modelRef, rc.modelRegistry),
         hostModel: rc.hostModel,
       },
     );
   } catch (error) {
-    rc.progress.agentFailed(label, error);
+    // Routing runs before the call has a row; give the failure its own so it cannot land on a same-label sibling.
+    rc.progress.agentFailed(rc.progress.agentQueued(opts.phase, label), error);
     throw error;
   }
 }

package/.pi/extensions/pi-workflow-engine/src/agent-session-identity.ts

@@ -6,11 +6,11 @@ import { normalizeWorkspaceReferences } from "./replay-path-identity.ts";
 import { unknownErrorMessage } from "./unknown-error.ts";
 import {
   captureEffectiveToolSourceIdentity,
+  nonEmptyString,
   type EffectiveToolSourceIdentity,
   type EffectiveToolSourceInfoLike,
-  type ToolSourceFingerprintCache,
+  type ToolSourceIdentityOptions,
 } from "./tool-source-identity.ts";
-export type { EffectiveToolSourceIdentity, EffectiveToolSourceInfoLike } from "./tool-source-identity.ts";
 
 export interface EffectiveAgentModelLike {
   readonly provider: string;
@@ -78,14 +78,6 @@ export interface EffectiveAgentSessionIdentityOptions {
   readonly signal?: AbortSignal;
 }
 
-interface IdentityComponents {
-  readonly runtimeVersion: string;
-  readonly systemPromptFingerprint: string;
-  readonly model: EffectiveAgentModelLike;
-  readonly thinkingLevel: string;
-  readonly tools: readonly EffectiveToolIdentity[];
-}
-
 /**
  * Capture the post-creation AgentSession state that determines whether a cached
  * agent result is safe to replay. Any missing or opaque executable identity
@@ -105,7 +97,13 @@ export async function captureEffectiveAgentSessionIdentity(
     const model = captureModel(session.model);
     const activeToolNames = captureActiveToolNames(session.getActiveToolNames());
     const toolInfoByName = indexToolInfo(session.getAllTools());
-    const sourceCaptures: ToolSourceFingerprintCache = new Map();
+    const toolSourceOptions: ToolSourceIdentityOptions = {
+      runtimeVersion,
+      signal: options.signal,
+      sessionCwd,
+      cache: new Map(),
+      workspaceRoot,
+    };
     const tools: EffectiveToolIdentity[] = [];
 
     for (const name of activeToolNames) {
@@ -114,18 +112,10 @@ export async function captureEffectiveAgentSessionIdentity(
       if (!info) throw new Error(`active tool "${name}" is absent from the tool registry`);
       const definition = session.getToolDefinition(name);
       if (!definition) throw new Error(`active tool "${name}" has no executable definition`);
-      tools.push(
-        await captureToolIdentity(name, info, definition, {
-          runtimeVersion,
-          signal: options.signal,
-          sessionCwd,
-          sourceCaptures,
-          workspaceRoot,
-        }),
-      );
+      tools.push(await captureToolIdentity(name, info, definition, toolSourceOptions));
     }
 
-    const components: IdentityComponents = {
+    const components = {
       runtimeVersion,
       systemPromptFingerprint: hashIdentity(
         normalizeWorkspaceReferences(systemPrompt, { sessionCwd, workspaceRoot }),
@@ -147,19 +137,11 @@ export async function captureEffectiveAgentSessionIdentity(
   }
 }
 
-interface ToolCaptureOptions {
-  readonly runtimeVersion: string;
-  readonly sessionCwd: string;
-  readonly workspaceRoot: string;
-  readonly sourceCaptures: ToolSourceFingerprintCache;
-  readonly signal?: AbortSignal;
-}
-
 async function captureToolIdentity(
   name: string,
   info: EffectiveToolInfoLike,
   definition: EffectiveToolDefinitionLike,
-  options: ToolCaptureOptions,
+  options: ToolSourceIdentityOptions,
 ): Promise<EffectiveToolIdentity> {
   if (nonEmptyString(info.name, `registry name for active tool "${name}"`) !== name) {
     throw new Error(`tool registry returned a mismatched definition for "${name}"`);
@@ -175,13 +157,7 @@ async function captureToolIdentity(
     definition.prepareArguments === undefined
       ? null
       : inspectableFunctionSource(definition.prepareArguments, `argument-preparation handler for active tool "${name}"`);
-  const source = await captureEffectiveToolSourceIdentity(info.sourceInfo, {
-    runtimeVersion: options.runtimeVersion,
-    sessionCwd: options.sessionCwd,
-    workspaceRoot: options.workspaceRoot,
-    cache: options.sourceCaptures,
-    signal: options.signal,
-  });
+  const source = await captureEffectiveToolSourceIdentity(info.sourceInfo, options);
 
   return {
     name,
@@ -244,12 +220,6 @@ function optionalString(value: string | undefined, label: string): string | null
   return stringValue(value, label);
 }
 
-function nonEmptyString(value: string, label: string): string {
-  const result = stringValue(value, label);
-  if (result.length === 0) throw new Error(`${label} is empty`);
-  return result;
-}
-
 function stringValue(value: string, label: string): string {
   if (typeof value !== "string") throw new Error(`${label} is not a string`);
   return value;

package/.pi/extensions/pi-workflow-engine/src/agent-session-providers.ts

@@ -8,12 +8,17 @@ type HostProviderRegistry = Pick<
   | "getRegisteredProviderConfig"
   | "getRegisteredProviderIds"
   | "isUsingOAuth"
->;
+> & {
+  /** pi 1.x keeps providers registered as objects (`pi.registerProvider(provider)`) apart from config providers. */
+  getRegisteredNativeProvider?(providerId: string): unknown;
+};
+
+type ChildModelRuntime = ModelRuntime & { registerNativeProvider?(provider: unknown): void };
 
 /** Mirror the host's live provider and selected-model auth state into a child runtime. */
 export async function synchronizeWorkflowModelRuntime(input: {
   readonly host: HostProviderRegistry;
-  readonly child: ModelRuntime;
+  readonly child: ChildModelRuntime;
   readonly selectedModel: Model<Api> | undefined;
   readonly removeChildOnlyProviders: boolean;
 }): Promise<void> {
@@ -28,9 +33,16 @@ export async function synchronizeWorkflowModelRuntime(input: {
 
   for (const providerId of hostProviderIds) {
     const config = host.getRegisteredProviderConfig(providerId);
-    if (!config) continue;
-    child.unregisterProvider(providerId);
-    child.registerProvider(providerId, config);
+    if (config) {
+      child.unregisterProvider(providerId);
+      child.registerProvider(providerId, config);
+      continue;
+    }
+    const native = host.getRegisteredNativeProvider?.(providerId);
+    if (native && child.registerNativeProvider) {
+      child.unregisterProvider(providerId);
+      child.registerNativeProvider(native);
+    }
   }
 
   const selectedProvider = selectedModel?.provider;