veryfront 0.1.215 → 0.1.217

package/src/src/platform/index.ts

@@ -14,6 +14,7 @@ export type { RuntimeAdapter } from "./adapters/base.js";
 // Compat: process
 export {
   chdir,
+  type CommandResult,
   cwd,
   env,
   exit,

package/src/src/provider/runtime-loader/provider-endpoints.ts

@@ -0,0 +1,50 @@
+const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
+const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+const DEFAULT_GOOGLE_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+
+function joinUrl(base: string, path: string): string {
+  return `${base.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+
+export function getOpenAIEmbeddingUrl(baseURL?: string): string {
+  return joinUrl(baseURL ?? DEFAULT_OPENAI_BASE_URL, "embeddings");
+}
+
+export function getAnthropicMessagesUrl(baseURL?: string): string {
+  return joinUrl(baseURL ?? DEFAULT_ANTHROPIC_BASE_URL, "messages");
+}
+
+export function getOpenAIChatCompletionsUrl(baseURL?: string): string {
+  return joinUrl(baseURL ?? DEFAULT_OPENAI_BASE_URL, "chat/completions");
+}
+
+export function getOpenAIResponsesUrl(baseURL?: string): string {
+  return joinUrl(baseURL ?? DEFAULT_OPENAI_BASE_URL, "responses");
+}
+
+export function getGoogleGenerateContentUrl(
+  baseURL: string | undefined,
+  modelId: string,
+): string {
+  return joinUrl(
+    baseURL ?? DEFAULT_GOOGLE_BASE_URL,
+    `models/${encodeURIComponent(modelId)}:generateContent`,
+  );
+}
+
+export function getGoogleStreamGenerateContentUrl(
+  baseURL: string | undefined,
+  modelId: string,
+): string {
+  return joinUrl(
+    baseURL ?? DEFAULT_GOOGLE_BASE_URL,
+    `models/${encodeURIComponent(modelId)}:streamGenerateContent?alt=sse`,
+  );
+}
+
+export function getGoogleEmbeddingUrl(baseURL: string | undefined, modelId: string): string {
+  return joinUrl(
+    baseURL ?? DEFAULT_GOOGLE_BASE_URL,
+    `models/${encodeURIComponent(modelId)}:embedContent`,
+  );
+}

package/src/src/provider/runtime-loader/provider-request-init.ts

@@ -0,0 +1,101 @@
+const ANTHROPIC_FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
+
+export function createRequestHeaders(options: {
+  apiKeyHeaderName: string;
+  apiKey: string;
+  extraHeaders?: HeadersInit;
+}): Headers {
+  const headers = new Headers(options.extraHeaders);
+  headers.set("content-type", "application/json");
+  headers.set(options.apiKeyHeaderName, options.apiKey);
+  return headers;
+}
+
+export function createAnthropicRequestHeaders(options: {
+  apiKey?: string;
+  authToken?: string;
+  extraHeaders?: HeadersInit;
+  enableFineGrainedToolStreaming?: boolean;
+}): Headers {
+  const headers = new Headers(options.extraHeaders);
+  headers.set("content-type", "application/json");
+  headers.set("anthropic-version", headers.get("anthropic-version") ?? "2023-06-01");
+
+  if (options.enableFineGrainedToolStreaming) {
+    const existingBetaHeader = headers.get("anthropic-beta");
+    if (!existingBetaHeader) {
+      headers.set("anthropic-beta", ANTHROPIC_FINE_GRAINED_TOOL_STREAMING_BETA);
+    } else {
+      const betas = new Set(
+        existingBetaHeader.split(",").map((beta) => beta.trim()).filter((beta) => beta.length > 0),
+      );
+      betas.add(ANTHROPIC_FINE_GRAINED_TOOL_STREAMING_BETA);
+      headers.set("anthropic-beta", Array.from(betas).join(","));
+    }
+  }
+
+  if (options.authToken) {
+    headers.set("authorization", `Bearer ${options.authToken}`);
+  } else if (options.apiKey) {
+    headers.set("x-api-key", options.apiKey);
+  }
+
+  return headers;
+}
+
+export function createOpenAIRequestInit(options: {
+  apiKey: string;
+  extraHeaders?: HeadersInit;
+  body: string;
+  signal?: AbortSignal;
+}): RequestInit {
+  return {
+    method: "POST",
+    headers: createRequestHeaders({
+      apiKeyHeaderName: "authorization",
+      apiKey: `Bearer ${options.apiKey}`,
+      extraHeaders: options.extraHeaders,
+    }),
+    body: options.body,
+    signal: options.signal,
+  };
+}
+
+export function createAnthropicRequestInit(options: {
+  apiKey?: string;
+  authToken?: string;
+  extraHeaders?: HeadersInit;
+  enableFineGrainedToolStreaming?: boolean;
+  body: string;
+  signal?: AbortSignal;
+}): RequestInit {
+  return {
+    method: "POST",
+    headers: createAnthropicRequestHeaders({
+      apiKey: options.apiKey,
+      authToken: options.authToken,
+      extraHeaders: options.extraHeaders,
+      enableFineGrainedToolStreaming: options.enableFineGrainedToolStreaming,
+    }),
+    body: options.body,
+    signal: options.signal,
+  };
+}
+
+export function createGoogleRequestInit(options: {
+  apiKey: string;
+  extraHeaders?: HeadersInit;
+  body: string;
+  signal?: AbortSignal;
+}): RequestInit {
+  return {
+    method: "POST",
+    headers: createRequestHeaders({
+      apiKeyHeaderName: "x-goog-api-key",
+      apiKey: options.apiKey,
+      extraHeaders: options.extraHeaders,
+    }),
+    body: options.body,
+    signal: options.signal,
+  };
+}

package/src/src/provider/runtime-loader/tool-input-status.ts

@@ -0,0 +1,210 @@
+import * as dntShim from "../../../_dnt.shims.js";
+export const TOOL_INPUT_PENDING_THRESHOLD_MS = 5_000;
+
+type ToolInputActivityStatus = "pending_input" | "streaming_input";
+
+type ToolInputStatusState = {
+  dueAt: number | null;
+  lastStatus: ToolInputActivityStatus | null;
+};
+
+type ToolStatusEvent = {
+  type: "data-tool-call-status";
+  data: { toolCallId: string; status: "pending_input" | "streaming_input" };
+};
+
+export function getToolCallIdFromStreamPart(part: unknown): string | null {
+  if (!part || typeof part !== "object") {
+    return null;
+  }
+
+  const record = part as Record<string, unknown>;
+  if (typeof record.toolCallId === "string" && record.toolCallId.length > 0) {
+    return record.toolCallId;
+  }
+
+  if (typeof record.id === "string" && record.id.length > 0) {
+    return record.id;
+  }
+
+  return null;
+}
+
+export function collectDueToolStatuses(
+  toolStates: Map<string, ToolInputStatusState>,
+  now: number,
+  thresholdMs: number,
+): Array<{ type: "data-tool-call-status"; data: { toolCallId: string; status: "pending_input" } }> {
+  const events: Array<
+    { type: "data-tool-call-status"; data: { toolCallId: string; status: "pending_input" } }
+  > = [];
+
+  for (const [toolCallId, state] of toolStates.entries()) {
+    if (state.dueAt === null || state.dueAt > now) {
+      continue;
+    }
+
+    state.dueAt = now + thresholdMs;
+    state.lastStatus = "pending_input";
+    events.push({
+      type: "data-tool-call-status",
+      data: {
+        toolCallId,
+        status: "pending_input",
+      },
+    });
+  }
+
+  return events;
+}
+
+export async function* withToolInputStatusTransitions(
+  stream: AsyncIterable<unknown>,
+  thresholdMs = TOOL_INPUT_PENDING_THRESHOLD_MS,
+): AsyncIterable<unknown> {
+  const iterator = stream[Symbol.asyncIterator]();
+  const toolStates = new Map<string, ToolInputStatusState>();
+  const buffered: unknown[] = [];
+  let nextPartPromise: Promise<IteratorResult<unknown>> | null = null;
+
+  const closeTool = (toolCallId: string | null) => {
+    if (!toolCallId) {
+      return;
+    }
+
+    toolStates.delete(toolCallId);
+  };
+
+  const schedulePending = (toolCallId: string | null) => {
+    if (!toolCallId) {
+      return;
+    }
+
+    const state = toolStates.get(toolCallId) ?? {
+      dueAt: null,
+      lastStatus: null,
+    };
+    state.dueAt = Date.now() + thresholdMs;
+    toolStates.set(toolCallId, state);
+  };
+
+  const markStreaming = (toolCallId: string | null) => {
+    if (!toolCallId) {
+      return;
+    }
+
+    const state = toolStates.get(toolCallId) ?? {
+      dueAt: null,
+      lastStatus: null,
+    };
+
+    if (state.lastStatus !== "streaming_input") {
+      buffered.push(
+        {
+          type: "data-tool-call-status",
+          data: {
+            toolCallId,
+            status: "streaming_input",
+          },
+        } satisfies ToolStatusEvent,
+      );
+    }
+
+    state.lastStatus = "streaming_input";
+    state.dueAt = Date.now() + thresholdMs;
+    toolStates.set(toolCallId, state);
+  };
+
+  const processPart = (part: unknown) => {
+    if (!part || typeof part !== "object") {
+      buffered.push(part);
+      return;
+    }
+
+    const record = part as Record<string, unknown>;
+    const partType = typeof record.type === "string" ? record.type : null;
+    const toolCallId = getToolCallIdFromStreamPart(part);
+
+    switch (partType) {
+      case "tool-input-start":
+        schedulePending(toolCallId);
+        buffered.push(part);
+        return;
+      case "tool-input-delta":
+        markStreaming(toolCallId);
+        buffered.push(part);
+        return;
+      case "tool-call":
+      case "tool-result":
+      case "tool-error":
+        closeTool(toolCallId);
+        buffered.push(part);
+        return;
+      case "finish":
+      case "error":
+        toolStates.clear();
+        buffered.push(part);
+        return;
+      default:
+        buffered.push(part);
+        return;
+    }
+  };
+
+  while (true) {
+    if (buffered.length > 0) {
+      yield buffered.shift();
+      continue;
+    }
+
+    if (!nextPartPromise) {
+      nextPartPromise = iterator.next();
+    }
+
+    const nextDueAt = [...toolStates.values()]
+      .map((state) => state.dueAt)
+      .filter((value): value is number => value !== null)
+      .sort((left, right) => left - right)[0] ?? null;
+
+    if (nextDueAt !== null) {
+      let timeoutId: ReturnType<typeof dntShim.setTimeout> | null = null;
+      const timeoutResult = await Promise.race([
+        nextPartPromise.then((result) => ({ kind: "part" as const, result })),
+        new Promise<{ kind: "timeout" }>((resolve) => {
+          timeoutId = dntShim.setTimeout(
+            () => resolve({ kind: "timeout" }),
+            Math.max(0, nextDueAt - Date.now()),
+          );
+        }),
+      ]);
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+      }
+
+      if (timeoutResult.kind === "timeout") {
+        buffered.push(...collectDueToolStatuses(toolStates, Date.now(), thresholdMs));
+        continue;
+      }
+
+      nextPartPromise = null;
+      if (timeoutResult.result.done) {
+        buffered.push(...collectDueToolStatuses(toolStates, Date.now(), thresholdMs));
+        while (buffered.length > 0) {
+          yield buffered.shift();
+        }
+        return;
+      }
+
+      processPart(timeoutResult.result.value);
+      continue;
+    }
+
+    const result = await nextPartPromise;
+    nextPartPromise = null;
+    if (result.done) {
+      return;
+    }
+
+    processPart(result.value);
+  }
+}