@abelxiaoxing/cadence 1.0.2 → 1.0.4

package/src/index.ts

@@ -99,6 +99,14 @@ function activateDispatcher(
   }
 }
 
+function splitUsage(result: unknown): { payload: unknown; usage?: unknown } {
+  if (typeof result !== "object" || result === null || !("usage" in result)) {
+    return { payload: result };
+  }
+  const { usage, ...payload } = result as Record<string, unknown>;
+  return { payload, usage };
+}
+
 export default function register(pi: ExtensionAPI): void {
   const parentPayloadBridge = new ParentPayloadBridge();
   const runtime = new Runtime({ parentPayloadBridge });
@@ -108,7 +116,7 @@ export default function register(pi: ExtensionAPI): void {
     name: DISPATCH_TOOL,
     label: "Abel Dispatch",
     description:
-      "Private Abel workflow delegation: run bounded read-only evidence or Worker phase requests, apply or discard retained results, cancel work, or finish the stage. Inactive unless an eligible Abel stage verified its invocation.",
+      "Private Abel workflow delegation: run bounded read-only evidence or Worker phase requests, apply or discard retained results, apply a parent-only stable AGENTS checkpoint, cancel work, or finish the stage. Inactive unless an eligible Abel stage verified its invocation.",
     parameters: {
       type: "object",
       properties: {
@@ -121,12 +129,32 @@ export default function register(pi: ExtensionAPI): void {
           type: "string",
           description: "Retained result id for apply/discard",
         },
+        requestId: {
+          type: "string",
+          description: "Current Implement apply/discard operation identity",
+        },
+        rejection: {
+          type: "object",
+          description: "Typed parent rejection for Implement discard",
+        },
+        agentsCheckpoint: {
+          type: "object",
+          description:
+            "Parent-owned approved managed-block checkpoint for action=apply (mutually exclusive with resultId)",
+        },
       },
       required: ["action"],
     },
     async execute(
       toolCallId: string,
-      params: { action?: string; request?: unknown; resultId?: string },
+      params: {
+        action?: string;
+        request?: unknown;
+        resultId?: string;
+        requestId?: string;
+        rejection?: unknown;
+        agentsCheckpoint?: unknown;
+      },
       signal: AbortSignal | undefined,
       onUpdate: AgentToolUpdateCallback<unknown> | undefined,
       ctx: ExtensionContext,
@@ -135,10 +163,11 @@ export default function register(pi: ExtensionAPI): void {
       const validRun =
         action === "run" && runtime.validateRequest(params.request).ok;
       const tuiRun = ctx.mode === "tui" && validRun;
+      const { action: _action, ...operation } = params;
       const result = tuiRun
         ? await runtime.execute(
             action,
-            params,
+            operation,
             ctx,
             signal,
             activity.observe(
@@ -146,24 +175,21 @@ export default function register(pi: ExtensionAPI): void {
               onUpdate as ((result: unknown) => void) | undefined,
             ),
           )
-        : await runtime.execute(action, params, ctx, signal);
+        : await runtime.execute(action, operation, ctx, signal);
       const display = tuiRun
         ? activity.finalize(toolCallId, result)
         : undefined;
+      const { payload, usage } = splitUsage(result);
       const details = display
-        ? { ...result, [ACTIVITY_DETAILS_KEY]: display }
-        : result;
-      if (result.ok) {
-        return {
-          content: [{ type: "text", text: JSON.stringify(result) }],
-          details,
-          usage: result.usage,
-        };
-      }
+        ? {
+            ...(payload as Record<string, unknown>),
+            [ACTIVITY_DETAILS_KEY]: display,
+          }
+        : payload;
       return {
-        content: [{ type: "text", text: JSON.stringify(result) }],
+        content: [{ type: "text", text: JSON.stringify(payload) }],
         details,
-        isError: true,
+        ...(usage === undefined ? {} : { usage }),
       };
     },
     renderCall(args: unknown, theme: Theme, _context: unknown) {
@@ -207,7 +233,15 @@ export default function register(pi: ExtensionAPI): void {
       activateDispatcher(pi, runtime.activation, prompt, event.prompt);
   });
 
-  pi.on("session_start", (_event, ctx) => {
+  pi.on("session_start", async (_event, ctx) => {
+    pendingPrompt = undefined;
+    activity.detach();
+    const active = pi.getActiveTools();
+    if (active.includes(DISPATCH_TOOL)) {
+      pi.setActiveTools(deactivateTool(active, DISPATCH_TOOL));
+    }
+    await runtime.drain();
+    activity.clear();
     const sessionId = ctx.sessionManager?.getSessionId?.();
     if (typeof sessionId === "string") {
       parentPayloadBridge.beginSession(sessionId);
@@ -217,15 +251,7 @@ export default function register(pi: ExtensionAPI): void {
     } else {
       parentPayloadBridge.clear();
     }
-    pendingPrompt = undefined;
-    activity.detach();
     if (ctx.mode === "tui") activity.attach(ctx.ui);
-    // Restore the default: dispatch is inactive unless a verified stage
-    // reactivates it through the activation helpers.
-    const active = pi.getActiveTools();
-    if (active.includes(DISPATCH_TOOL)) {
-      pi.setActiveTools(deactivateTool(active, DISPATCH_TOOL));
-    }
   });
 
   pi.on("model_select", (event, ctx) => {

package/src/parent-provider.ts

@@ -2,22 +2,167 @@ import {
   InMemoryCredentialStore,
   type Model,
   type Provider,
+  type StreamOptions,
 } from "@earendil-works/pi-ai";
+import {
+  createProvider,
+  stream as subagentStream,
+  streamSimple as subagentStreamSimple,
+} from "@earendil-works/pi-ai/compat";
 import {
   type ExtensionContext,
   ModelRuntime,
 } from "@earendil-works/pi-coding-agent";
+import type { ChildFailure } from "./contracts.ts";
 import type {
   ParentPayloadBridge,
   ParentPayloadCallback,
   ParentPayloadCapture,
 } from "./parent-payload-bridge.ts";
+import type { SubagentEndpoint } from "./subagent-endpoint.ts";
+
+const SUBAGENT_PROVIDER_ID = "abel-subagent";
+
+function customStreamOptions<T extends StreamOptions>(
+  model: Model<string>,
+  options?: T,
+): T | undefined {
+  if (model.api !== "openai-responses") return options;
+  const childOnPayload = options?.onPayload;
+  return {
+    ...options,
+    onPayload: async (payload, requestModel) => {
+      const transformed = await childOnPayload?.(payload, requestModel);
+      const current = transformed === undefined ? payload : transformed;
+      if (!current || typeof current !== "object" || Array.isArray(current))
+        return current;
+      const normalized = { ...current } as Record<string, unknown>;
+      delete normalized.max_output_tokens;
+      return normalized;
+    },
+  } as T;
+}
+
+// The compat dispatchers resolve the concrete API implementation from
+// model.api at call time, so one pair serves all supported dialects.
+const SUBAGENT_STREAMS = {
+  stream(
+    model: Parameters<typeof subagentStream>[0],
+    context: Parameters<typeof subagentStream>[1],
+    options?: Parameters<typeof subagentStream>[2],
+  ) {
+    return subagentStream(
+      model,
+      context,
+      customStreamOptions(model as Model<string>, options),
+    );
+  },
+  streamSimple(
+    model: Parameters<typeof subagentStreamSimple>[0],
+    context: Parameters<typeof subagentStreamSimple>[1],
+    options?: Parameters<typeof subagentStreamSimple>[2],
+  ) {
+    return subagentStreamSimple(
+      model,
+      context,
+      customStreamOptions(model as Model<string>, options),
+    );
+  },
+};
+
+function customSubagentModel(endpoint: SubagentEndpoint): Model<string> {
+  return {
+    id: endpoint.model,
+    name: endpoint.model,
+    api: endpoint.dialect,
+    provider: SUBAGENT_PROVIDER_ID,
+    baseUrl: endpoint.url,
+    reasoning: true,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    contextWindow: endpoint.contextWindow,
+    maxTokens: endpoint.maxTokens,
+  } as Model<string>;
+}
+
+function customSubagentProvider(
+  endpoint: SubagentEndpoint,
+  model: Model<string>,
+): Provider {
+  return createProvider({
+    id: SUBAGENT_PROVIDER_ID,
+    name: "Abel Subagent Endpoint",
+    baseUrl: endpoint.url,
+    auth: {
+      apiKey: {
+        name: "Abel subagent endpoint auth",
+        resolve: async () =>
+          endpoint.apiKey
+            ? { auth: { apiKey: endpoint.apiKey }, source: "subagent-endpoint" }
+            : {
+                auth: {
+                  apiKey: "unused",
+                  headers: { authorization: null, "x-api-key": null },
+                },
+                source: "subagent-endpoint-keyless",
+              },
+      },
+    },
+    models: [model],
+    api: SUBAGENT_STREAMS,
+  }) as Provider;
+}
+
+export async function customPhaseRuntime(
+  endpoint: SubagentEndpoint,
+  signal?: AbortSignal,
+): Promise<PhaseRuntimeResult> {
+  if (signal?.aborted) return cancelledPhaseRuntime();
+  const model = customSubagentModel(endpoint);
+  const provider = customSubagentProvider(endpoint, model);
+  let modelRuntime: ModelRuntime;
+  try {
+    modelRuntime = await runtimeForProvider(provider, signal);
+  } catch (error) {
+    if (isCancellation(error, signal)) return cancelledPhaseRuntime();
+    throw error;
+  }
+  if (signal?.aborted) return cancelledPhaseRuntime();
+  return { ok: true, modelRuntime, model };
+}
 
 export interface PhasePayloadBridge {
   readonly bridge: ParentPayloadBridge;
   readonly capture: ParentPayloadCapture;
 }
 
+type PhaseRuntimeFailure = Extract<
+  ChildFailure,
+  { kind: "cancelled" | "environment" | "transport" }
+>;
+
+export type PhaseRuntimeResult =
+  | { ok: true; modelRuntime: ModelRuntime; model: Model<string> }
+  | { ok: false; error: string; failure: PhaseRuntimeFailure };
+
+function phaseRuntimeFailure(
+  failure: PhaseRuntimeFailure,
+  error: string,
+): Extract<PhaseRuntimeResult, { ok: false }> {
+  return { ok: false, error, failure };
+}
+
+function cancelledPhaseRuntime(): Extract<PhaseRuntimeResult, { ok: false }> {
+  return phaseRuntimeFailure(
+    { kind: "cancelled", code: "cancelled" },
+    "child phase cancelled",
+  );
+}
+
+function isCancellation(error: unknown, signal?: AbortSignal): boolean {
+  return signal?.aborted === true && error === signal.reason;
+}
+
 function phasePayloadCallback(
   payloadBridge: PhasePayloadBridge,
   childOnPayload: ParentPayloadCallback | undefined,
@@ -137,44 +282,82 @@ export async function runtimeFromContext(
   ctx: Pick<ExtensionContext, "model" | "modelRegistry">,
   payloadBridge: ParentPayloadBridge,
   signal?: AbortSignal,
-): Promise<{ modelRuntime: ModelRuntime; model: Model<string> }> {
-  signal?.throwIfAborted();
-  if (!ctx.model) throw new Error("parent model is unavailable");
+): Promise<PhaseRuntimeResult> {
+  if (signal?.aborted) return cancelledPhaseRuntime();
+  if (!ctx.model) {
+    return phaseRuntimeFailure(
+      { kind: "environment", code: "sandbox-runtime-unavailable" },
+      "parent model is unavailable",
+    );
+  }
   const selectedModel = ctx.model;
   const selectedModelKey = modelKeyFor(selectedModel);
-  const resolved = await abortable(
-    ctx.modelRegistry.getApiKeyAndHeaders(selectedModel),
-    signal,
-  );
-  if (!resolved.ok) throw new Error(resolved.error);
-  signal?.throwIfAborted();
+  let resolved: Awaited<
+    ReturnType<typeof ctx.modelRegistry.getApiKeyAndHeaders>
+  >;
+  try {
+    resolved = await abortable(
+      ctx.modelRegistry.getApiKeyAndHeaders(selectedModel),
+      signal,
+    );
+  } catch (error) {
+    if (isCancellation(error, signal)) return cancelledPhaseRuntime();
+    throw error;
+  }
+  if (!resolved.ok) {
+    return phaseRuntimeFailure(
+      { kind: "environment", code: "sandbox-runtime-unavailable" },
+      "phase authentication is unavailable",
+    );
+  }
+  if (signal?.aborted) return cancelledPhaseRuntime();
   const model = {
     ...selectedModel,
     baseUrl: resolved.baseUrl ?? selectedModel.baseUrl,
   } as Model<string>;
   const effectiveModelKey = modelKeyFor(model);
   const capture = payloadBridge.capture(effectiveModelKey, ctx.modelRegistry);
-  if (!capture) throw new Error("parent payload bridge is unavailable");
-  const requireReadyCapture = () => {
-    if (
-      !ctx.model ||
-      !sameSelectedModel(ctx.model, selectedModelKey) ||
-      payloadBridge.capture(effectiveModelKey, ctx.modelRegistry) !== capture
-    ) {
-      throw new Error("parent payload bridge is unavailable");
-    }
+  if (!capture) {
+    return phaseRuntimeFailure(
+      { kind: "transport", code: "transport-failure" },
+      "parent payload bridge is unavailable",
+    );
+  }
+  const captureIsReady = () => {
+    const currentModel = ctx.model;
+    return (
+      currentModel !== undefined &&
+      sameSelectedModel(currentModel, selectedModelKey) &&
+      payloadBridge.capture(effectiveModelKey, ctx.modelRegistry) === capture
+    );
   };
-  requireReadyCapture();
+  if (!captureIsReady()) {
+    return phaseRuntimeFailure(
+      { kind: "transport", code: "transport-failure" },
+      "parent payload bridge is unavailable",
+    );
+  }
   const delegate = capture.delegate;
   if (!delegate) throw new Error("parent Provider is unavailable");
   const provider = phaseProvider(delegate, resolved, {
     bridge: payloadBridge,
     capture,
   });
-  const modelRuntime = await runtimeForProvider(provider, signal);
-  signal?.throwIfAborted();
-  requireReadyCapture();
-  return { modelRuntime, model };
+  let modelRuntime: ModelRuntime;
+  try {
+    modelRuntime = await runtimeForProvider(provider, signal);
+  } catch (error) {
+    if (isCancellation(error, signal)) return cancelledPhaseRuntime();
+    throw error;
+  }
+  if (signal?.aborted) return cancelledPhaseRuntime();
+  if (!captureIsReady()) {
+    return phaseRuntimeFailure(
+      { kind: "transport", code: "transport-failure" },
+      "parent payload bridge is unavailable",
+    );
+  }
+  return { ok: true, modelRuntime, model };
 }
 
 function abortable<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> {