@springbrand/agent-runtime 0.3.0-alpha.2 → 0.3.0-alpha.21

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

@@ -0,0 +1,85 @@
+import {
+  lazyStream,
+  type Api,
+  type AssistantMessage,
+  type AssistantMessageEventStream,
+  type Model,
+  type ProviderStreams,
+  type StreamOptions,
+} from "@earendil-works/pi-ai";
+import type { RuntimeModelProtocol } from "../../config/ports";
+import { overlayProviderStreams } from "../provider-streams";
+
+export type OpenRouterProtocol = Extract<RuntimeModelProtocol, `openrouter-${string}`>;
+
+/** Native output required by OpenRouter's stateless continuation. */
+export interface ModelProtocolResponse {
+  readonly output: readonly Readonly<Record<string, unknown>>[];
+}
+
+declare module "@earendil-works/pi-ai" {
+  interface AssistantMessage {
+    protocolResponse?: ModelProtocolResponse;
+  }
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function streamWithProtocolResponse<T extends StreamOptions>(
+  model: Model<Api>,
+  options: T | undefined,
+  start: (options: T) => AssistantMessageEventStream,
+): AssistantMessageEventStream {
+  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;
+      }
+      if (!terminal) throw new Error("Provider stream ended without a terminal event");
+    })();
+  });
+}
+
+export function withModelProtocolResponse(
+  api: ProviderStreams,
+  protocol: OpenRouterProtocol,
+): ProviderStreams {
+  if (protocol !== "openrouter-responses") return api;
+  return overlayProviderStreams(api, {
+    stream: (model, context, options) =>
+      streamWithProtocolResponse(model, options, (requestOptions) => api.stream(model, context, requestOptions)),
+    streamSimple: (model, context, options) =>
+      streamWithProtocolResponse(model, options, (requestOptions) => api.streamSimple(model, context, requestOptions)),
+  });
+}

package/src/models/provider-streams.ts

@@ -0,0 +1,45 @@
+import type {
+  Api,
+  Model,
+  ProviderEnv,
+  ProviderStreams,
+} from "@earendil-works/pi-ai";
+
+/**
+ * ProviderStreams 是普通对象，不是 class。完整适配先 spread 底层全部方法，再覆盖需要装饰的入口。
+ * 只手写 stream / streamSimple 会丢掉 Pi 后续挂上的 fetchDeferred / cancelDeferred。
+ */
+export function overlayProviderStreams(
+  base: ProviderStreams,
+  overlay: Partial<ProviderStreams>,
+): ProviderStreams {
+  return { ...base, ...overlay };
+}
+
+/**
+ * 在保留其余方法的前提下，把每个已知的 model 入口改写到 remap 后的模型。
+ * 未知的未来方法仍通过 spread 透传，避免再出现白名单丢方法。
+ */
+export function remapProviderStreamModels(
+  streams: ProviderStreams,
+  remap: (model: Model<Api>, env: ProviderEnv | undefined) => Model<Api>,
+): ProviderStreams {
+  return overlayProviderStreams(streams, {
+    stream: (model, context, options) =>
+      streams.stream(remap(model, options?.env), context, options),
+    streamSimple: (model, context, options) =>
+      streams.streamSimple(remap(model, options?.env), context, options),
+    ...(streams.fetchDeferred
+      ? {
+          fetchDeferred: (model, handle, options) =>
+            streams.fetchDeferred!(remap(model, options?.env), handle, options),
+        }
+      : {}),
+    ...(streams.cancelDeferred
+      ? {
+          cancelDeferred: (model, handle, options) =>
+            streams.cancelDeferred!(remap(model, options?.env), handle, options),
+        }
+      : {}),
+  });
+}