@springbrand/agent-runtime 0.3.0-alpha.16 → 0.3.0-alpha.18

package/src/harness/submission-operation.ts

@@ -1,49 +1,24 @@
-import type { OperationRequest, OperationResultRecord } from "@earendil-works/pi-agent-core";
-import type { Context } from "@earendil-works/pi-agent-core/harness/context";
+import type { Context } from "@earendil-works/chord";
+import type { EntryId } from "@earendil-works/pi-durable";
 import type { PiCanonicalUserInput } from "../conversation/message/contract";
 import type { StoredSubmission } from "../submission/repository";
-import type { SessionHarness } from "./session-harness";
+import type { SessionHarness, SessionRunRequest } from "./session-harness";
 
-/** Recover the stable operation before accepting new input or navigating its branch. */
+/** Reacquire Pi's stable Submission before admitting another model run. */
 export async function prepareSubmissionOperation(
-  runtime: SessionHarness<object | undefined>,
+  runtime: SessionHarness,
   submission: Pick<StoredSubmission, "submissionId" | "queuedInputJson" | "regenerateMessageId">,
-  regenerationTarget: (messageId: string) => string | null,
+  regenerationTarget: (messageId: string) => Promise<EntryId | null>,
   context: Context,
-): Promise<{ kind: "run"; request?: OperationRequest } | { kind: "settled"; outcome: OperationResultRecord }> {
-  const id = submission.submissionId;
-  const navigationId = `${id}:regenerate`;
-  if (runtime.openOperation?.operationId === navigationId) {
-    const navigation = await runtime.run(undefined, context);
-    if (navigation.kind !== "settled" || navigation.outcome.status !== "completed") {
-      throw new Error("Could not recover the regeneration branch navigation");
-    }
-  }
-  if (runtime.openOperation) {
-    if (runtime.openOperation.operationId !== id) {
-      throw new Error(`Submission ${id} does not own the open Harness operation`);
-    }
-    return { kind: "run" };
-  }
-  const watch = await runtime.lane.watch(context);
-  const previous = watch.snapshot.lastResult;
-  watch.unsubscribe();
-  if (previous?.operationId === id) return { kind: "settled", outcome: previous };
-  if (!submission.queuedInputJson) {
-    throw new Error(`Submission ${id} has no open Harness operation or queued input`);
-  }
+): Promise<SessionRunRequest> {
+  const existing = await runtime.submissionFor(submission.submissionId, context);
+  if (existing) return { operationId: submission.submissionId };
+  if (!submission.queuedInputJson) throw new Error("The admitted Submission has no canonical input");
   const prompt = JSON.parse(submission.queuedInputJson) as PiCanonicalUserInput;
-  if (prompt.role !== "user") throw new Error("Queued SpringBrand user message is invalid");
-  if (submission.regenerateMessageId && previous?.operationId !== navigationId) {
-    const navigation = await runtime.run({
-      kind: "navigation",
-      operationId: navigationId,
-      targetId: regenerationTarget(submission.regenerateMessageId),
-      options: { summarize: false },
-    }, context);
-    if (navigation.kind !== "settled" || navigation.outcome.status !== "completed") {
-      throw new Error("Could not navigate to the regeneration branch");
-    }
+  if (prompt.role !== "user") throw new Error("Invalid canonical user input");
+  if (submission.regenerateMessageId) {
+    const target = await regenerationTarget(submission.regenerateMessageId);
+    await runtime.fork(target, context);
   }
-  return { kind: "run", request: { kind: "prompt", operationId: id, prompt } };
+  return { operationId: submission.submissionId, prompt };
 }

package/src/models/index.ts

@@ -537,14 +537,15 @@ export function modelRequestUrl(model: Model<Api>): string {
  */
 export function withProviderBoundary(
   streamFn: ProviderBoundStream,
-  defaultSessionId?: string,
+  /** Host-owned provider Session; it overrides the durable Harness's per-conversation identity. */
+  hostSessionId?: string | (() => string),
   onGeneration?: PiGenerationLifecycleObserver,
 ): ProviderBoundStream {
   return (model, context, options) =>
     lazyStream(model, async () => {
       const requestId = crypto.randomUUID();
       const startedAt = Date.now();
-      const sessionId = options?.sessionId ?? defaultSessionId;
+      const sessionId = (typeof hostSessionId === "function" ? hostSessionId() : hostSessionId) ?? options?.sessionId;
       const url = modelRequestUrl(model);
       const systemPrompt = "systemPrompt" in context && typeof context.systemPrompt === "string"
         ? context.systemPrompt
@@ -910,11 +911,15 @@ function configuredModel(
             ...(endpoint.protocol === "openrouter-messages"
               ? {
                   ...anthropicMessagesCompat,
+                  // The direct Anthropic catalog enables positional system and Tool updates, but
+                  // OpenRouter Messages rejects `tool_addition` definitions. Fold them into the
+                  // leading system and top-level tools so deferred Tool decoration still applies.
+                  supportsMidConvoSystemMessages: false,
+                  supportsMidConvoToolChanges: false,
                   supportsMidConvoEffort: false,
                   supportsEagerToolInputStreaming: false,
                   supportsStrictTools:
                     anthropicMessagesCompat?.supportsStrictTools ?? false,
-                  supportsToolReferences: true,
                   ...(modelId === "anthropic/claude-sonnet-5.5" ||
                       modelId === "anthropic/claude-opus-5.5"
                     ? { forceAdaptiveThinking: true }
@@ -923,6 +928,9 @@ function configuredModel(
               : endpoint.protocol === "openrouter-chat"
                 ? {
                     ...catalogCompat,
+                    // OpenRouter Chat has no verified positional system or Tool update support.
+                    supportsMidConvoSystemMessages: false,
+                    supportsMidConvoToolChanges: false,
                     thinkingFormat: "openrouter" as const,
                     maxTokensField: "max_tokens" as const,
                     supportsStore: false,
@@ -942,6 +950,9 @@ function configuredModel(
                   }),
             openRouterRouting: {
               require_parameters: true,
+              ...(endpoint.openRouterProviderSort
+                ? { sort: endpoint.openRouterProviderSort }
+                : {}),
               ...(openRouterProviderPin
                 ? {
                     order: [openRouterProviderPin],

package/src/models/openrouter/protocol-response.ts

@@ -1,6 +1,5 @@
 import {
-  createAssistantMessageEventStream,
-  fauxAssistantMessage,
+  lazyStream,
   type Api,
   type AssistantMessage,
   type AssistantMessageEventStream,
@@ -13,15 +12,11 @@ import { overlayProviderStreams } from "../provider-streams";
 
 export type OpenRouterProtocol = Extract<RuntimeModelProtocol, `openrouter-${string}`>;
 
-/** Minimal native output retained for the next OpenRouter Responses request. */
+/** Native output required by OpenRouter's stateless continuation. */
 export interface ModelProtocolResponse {
   readonly output: readonly Readonly<Record<string, unknown>>[];
 }
 
-interface ProtocolEvent {
-  readonly data: unknown;
-}
-
 declare module "@earendil-works/pi-ai" {
   interface AssistantMessage {
     protocolResponse?: ModelProtocolResponse;
@@ -34,113 +29,46 @@ function record(value: unknown): Record<string, unknown> | undefined {
     : undefined;
 }
 
-function parseProtocolEvents(body: string): ProtocolEvent[] {
-  return body.split(/\r?\n\r?\n/).flatMap((frame) => {
-    const lines = frame.split(/\r?\n/);
-    const dataLines = lines.filter((line) => line.startsWith("data:"))
-      .map((line) => line.slice(5).replace(/^ /, ""));
-    if (dataLines.length === 0) return [];
-    const dataText = dataLines.join("\n");
-    let data: unknown = dataText;
-    try {
-      data = JSON.parse(dataText);
-    } catch {
-      data = dataText;
-    }
-    return [{ data }];
-  });
-}
-
-function compactResponsesBody(body: string): ModelProtocolResponse | undefined {
-  const completedItems = new Map<number, Record<string, unknown>>();
-  let terminalItems: Record<string, unknown>[] | undefined;
-  let terminal = false;
-  for (const frame of parseProtocolEvents(body)) {
-    const event = record(frame.data);
-    if (
-      event?.type === "response.output_item.done" &&
-      typeof event.output_index === "number"
-    ) {
-      const item = record(event.item);
-      if (item) completedItems.set(event.output_index, item);
-    }
-    if (event?.type === "response.completed" || event?.type === "response.incomplete") {
-      terminal = true;
-      const response = record(event.response);
-      if (Array.isArray(response?.output)) {
-        terminalItems = response.output.flatMap((value) => {
-          const output = record(value);
-          return output ? [output] : [];
-        });
-      }
-    }
-  }
-  if (!terminal) return undefined;
-  const output = terminalItems?.length
-    ? terminalItems.map((item, index) => ({ ...completedItems.get(index), ...item }))
-    : [...completedItems.entries()]
-      .sort(([left], [right]) => left - right)
-      .map(([, item]) => item);
-  return output.length > 0 ? { output } : undefined;
-}
-
 function streamWithProtocolResponse<T extends StreamOptions>(
   model: Model<Api>,
   options: T | undefined,
   start: (options: T) => AssistantMessageEventStream,
 ): AssistantMessageEventStream {
-  const output = createAssistantMessageEventStream();
-  const fetcher = options?.fetch ?? globalThis.fetch;
-  let responseOutput: Promise<ModelProtocolResponse | undefined> | undefined;
-  let terminal = false;
-  const requestOptions = {
-    ...options,
-    fetch: (async (...args: Parameters<typeof fetch>) => {
-      const response = await fetcher(...args);
-      responseOutput = response.clone().text()
-        .then((body) => compactResponsesBody(body))
-        .catch(() => undefined);
-      return response;
-    }) satisfies typeof fetch,
-  } as T;
-
-  void (async () => {
-    const source = start(requestOptions);
-    for await (const event of source) {
-      if (event.type === "done" || event.type === "error") {
-        terminal = true;
-        if (responseOutput) {
-          const message = event.type === "done" ? event.message : event.error;
-          const compact = await responseOutput;
-          if (compact) message.protocolResponse = compact;
+  return lazyStream(model, async () => {
+    let nativeResponse: ModelProtocolResponse | undefined;
+    const source = start({
+      ...options,
+      onProviderStreamEvent: async (data: unknown, activeModel: Model<Api>) => {
+        const event = record(data);
+        if (event?.type === "response.created") nativeResponse = undefined;
+        if (event?.type === "response.completed" || event?.type === "response.incomplete") {
+          const output = record(event.response)?.output;
+          if (Array.isArray(output)) {
+            const items = output.flatMap((value) => {
+              const item = record(value);
+              return item ? [item] : [];
+            });
+            nativeResponse = items.length > 0 ? { output: items } : undefined;
+          }
+        }
+        await options?.onProviderStreamEvent?.(data, activeModel);
+      },
+    } as T);
+    return (async function* () {
+      let terminal = false;
+      for await (const event of source) {
+        if (event.type === "done" || event.type === "error") {
+          terminal = true;
+          if (nativeResponse) {
+            const message = event.type === "done" ? event.message : event.error;
+            message.protocolResponse = nativeResponse;
+          }
         }
+        yield event;
       }
-      output.push(event);
-    }
-    if (!terminal) throw new Error("Provider stream ended without a terminal event");
-    output.end();
-  })().catch(async (error: unknown) => {
-    if (terminal) {
-      output.end();
-      return;
-    }
-    const reason = options?.signal?.aborted ? "aborted" : "error";
-    const failure = fauxAssistantMessage("", {
-      stopReason: reason,
-      errorMessage: error instanceof Error ? error.message : String(error),
-    });
-    if (responseOutput) {
-      const compact = await responseOutput;
-      if (compact) failure.protocolResponse = compact;
-    }
-    output.push({
-      type: "error",
-      reason,
-      error: { ...failure, api: model.api, provider: model.provider, model: model.id },
-    });
-    output.end();
+      if (!terminal) throw new Error("Provider stream ended without a terminal event");
+    })();
   });
-  return output;
 }
 
 export function withModelProtocolResponse(
@@ -150,12 +78,8 @@ export function withModelProtocolResponse(
   if (protocol !== "openrouter-responses") return api;
   return overlayProviderStreams(api, {
     stream: (model, context, options) =>
-      streamWithProtocolResponse(model, options, (requestOptions) =>
-        api.stream(model, context, requestOptions)
-      ),
+      streamWithProtocolResponse(model, options, (requestOptions) => api.stream(model, context, requestOptions)),
     streamSimple: (model, context, options) =>
-      streamWithProtocolResponse(model, options, (requestOptions) =>
-        api.streamSimple(model, context, requestOptions)
-      ),
+      streamWithProtocolResponse(model, options, (requestOptions) => api.streamSimple(model, context, requestOptions)),
   });
 }