@centerforagenticai/pi-multi-account 0.1.1

package/src/anthropic-adaptive-stream.ts

@@ -0,0 +1,531 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2026 Leo Henon
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * Provenance: pi-anthropic-oauth@0.2.4-intel.2, private pin
+ * 99ac00f290efbcb93e7f23e6b7482d8727367aa7, upstream baseline
+ * 53266ecb51b6d1890ef3f7251a64cb1d71d96099, source src/stream.ts.
+ * Local delta: adaptive thinking emits type=adaptive and mapped output effort,
+ * without budget_tokens; all other request and response behavior is unchanged.
+ */
+
+import { Anthropic } from "@anthropic-ai/sdk";
+import type { MessageCreateParamsStreaming } from "@anthropic-ai/sdk/resources/messages.js";
+import {
+  type Api,
+  type AssistantMessage,
+  type AssistantMessageEventStream,
+  calculateCost,
+  type Context,
+  createAssistantMessageEventStream,
+  type Model,
+  type SimpleStreamOptions,
+  type StopReason,
+} from "@earendil-works/pi-ai";
+type IndexedBlock =
+  | ({ type: "text"; text: string } & { index: number })
+  | ({ type: "thinking"; thinking: string; thinkingSignature?: string } & {
+      index: number;
+    })
+  | ({
+      type: "toolCall";
+      id: string;
+      name: string;
+      arguments: Record<string, unknown>;
+      partialJson: string;
+    } & { index: number });
+type UpstreamHelpers = {
+  isClaudeOAuthAccessToken: (apiKey: string) => boolean;
+  USER_AGENT: string;
+  convertPiMessagesToAnthropic: (
+    messages: Context["messages"],
+    isOAuth: boolean,
+    model: Pick<Model<Api>, "provider" | "api" | "id">,
+  ) => unknown;
+  convertPiToolsToAnthropic: (tools: NonNullable<Context["tools"]>, isOAuth: boolean) => unknown;
+  fromClaudeCodeToolName: (name: string, tools?: NonNullable<Context["tools"]>) => string;
+  buildAnthropicSystemPrompt: (systemPrompt: string | undefined, isOAuth: boolean) => unknown;
+};
+
+const upstreamAuthPath = "../packages/pi-anthropic-oauth/src/auth.ts";
+const upstreamConvertPath = "../packages/pi-anthropic-oauth/src/convert.ts";
+const upstreamPromptPath = "../packages/pi-anthropic-oauth/src/prompt.ts";
+const upstreamHelpers = {
+  ...(await import(upstreamAuthPath)),
+  ...(await import(upstreamConvertPath)),
+  ...(await import(upstreamPromptPath)),
+} as unknown as UpstreamHelpers;
+const {
+  isClaudeOAuthAccessToken,
+  USER_AGENT,
+  convertPiMessagesToAnthropic,
+  convertPiToolsToAnthropic,
+  fromClaudeCodeToolName,
+  buildAnthropicSystemPrompt,
+} = upstreamHelpers;
+
+const REQUIRED_BETAS = [
+  "claude-code-20250219",
+  "oauth-2025-04-20",
+  // fine-grained-tool-streaming removed: it ships the model's raw, unvalidated
+  // tool-input JSON. For large edits full of quotes/newlines the streamed
+  // string escaping breaks, so a field (e.g. edit.oldText) swallows the rest of
+  // the structure — surfacing as either a hard JSON.parse crash or a wrong-shape
+  // schema-validation failure. Default streaming has the server validate/buffer
+  // tool JSON, guaranteeing well-formed, correctly-structured input.
+  "interleaved-thinking-2025-05-14",
+] as const;
+
+function mapStopReason(reason: string | null | undefined): StopReason {
+  switch (reason) {
+    case "end_turn":
+    case "pause_turn":
+    case "stop_sequence":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "toolUse";
+    default:
+      return "error";
+  }
+}
+
+function headersToRecord(headers: Headers): Record<string, string> {
+  const record: Record<string, string> = {};
+  headers.forEach((value, key) => {
+    record[key] = value;
+  });
+  return record;
+}
+
+function makeDefaultHeaders(
+  isOAuth: boolean,
+  options?: SimpleStreamOptions,
+): Record<string, string> {
+  const headers: Record<string, string> = {
+    accept: "application/json",
+    "anthropic-dangerous-direct-browser-access": "true",
+  };
+
+  if (isOAuth) {
+    headers["anthropic-beta"] = REQUIRED_BETAS.join(",");
+    headers["user-agent"] = USER_AGENT;
+    headers["x-app"] = "cli";
+  } else {
+    headers["anthropic-beta"] = ["interleaved-thinking-2025-05-14"].join(",");
+  }
+
+  if (options?.headers) {
+    for (const [key, value] of Object.entries(options.headers)) {
+      const normalizedKey = key.toLowerCase();
+      if (
+        isOAuth &&
+        (normalizedKey === "x-api-key" || normalizedKey === "authorization")
+      ) {
+        continue;
+      }
+      const existingKey = Object.keys(headers).find(
+        (header) => header.toLowerCase() === normalizedKey,
+      );
+      if (existingKey) delete headers[existingKey];
+      if (value !== null) headers[key] = value;
+    }
+  }
+
+  return headers;
+}
+
+export function streamAnthropicAdaptive(
+  model: Model<Api>,
+  context: Context,
+  options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+  const stream = createAssistantMessageEventStream();
+
+  void (async () => {
+    const output: AssistantMessage = {
+      role: "assistant",
+      content: [],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+      },
+      stopReason: "stop",
+      timestamp: Date.now(),
+    };
+
+    try {
+      const apiKey = options?.apiKey;
+      if (!apiKey) {
+        throw new Error(
+          "No Anthropic auth available. Run /login and choose Claude Pro/Max.",
+        );
+      }
+
+      const isOAuth = isClaudeOAuthAccessToken(apiKey);
+      const defaultHeaders = makeDefaultHeaders(isOAuth, options);
+
+      if (isOAuth) defaultHeaders.authorization = `Bearer ${apiKey}`;
+
+      const client = new Anthropic({
+        baseURL: model.baseUrl,
+        apiKey: isOAuth ? null : apiKey,
+        authToken: isOAuth ? apiKey : null,
+        defaultHeaders,
+        dangerouslyAllowBrowser: true,
+      });
+
+      const maxTokens =
+        options?.maxTokens || Math.floor(model.maxTokens / 3);
+
+      const params: MessageCreateParamsStreaming = {
+        model: model.id,
+        messages: convertPiMessagesToAnthropic(
+          context.messages,
+          isOAuth,
+          model,
+        ) as MessageCreateParamsStreaming["messages"],
+        max_tokens: maxTokens,
+        stream: true,
+      };
+
+      const system = buildAnthropicSystemPrompt(context.systemPrompt, isOAuth);
+      if (system) params.system = system as never;
+      if (context.tools?.length)
+        params.tools = convertPiToolsToAnthropic(
+          context.tools,
+          isOAuth,
+        ) as NonNullable<MessageCreateParamsStreaming["tools"]>;
+
+      // The pinned stream gates both thinking modes on maxTokens > 1 because a
+      // budget must stay below the output cap. Adaptive thinking carries no
+      // budget, so that condition applies to the legacy branch only.
+      if (options?.reasoning && model.reasoning) {
+        const forceAdaptiveThinking =
+          (model.compat as { forceAdaptiveThinking?: boolean } | undefined)
+            ?.forceAdaptiveThinking === true;
+        if (forceAdaptiveThinking) {
+          const defaultEfforts: Record<string, string> = {
+            minimal: "low",
+            low: "low",
+            medium: "medium",
+          };
+          const mappedEffort = (model as Model<Api> & {
+            thinkingLevelMap?: Record<string, string | null>;
+          }).thinkingLevelMap?.[options.reasoning];
+          params.thinking = { type: "adaptive" } as never;
+          (params as MessageCreateParamsStreaming & {
+            output_config?: { effort: string };
+          }).output_config = {
+            effort:
+              typeof mappedEffort === "string"
+                ? mappedEffort
+                : defaultEfforts[options.reasoning] ?? "high",
+          };
+        } else if (maxTokens > 1) {
+          const defaultBudgets: Record<string, number> = {
+            minimal: 1024,
+            low: 4096,
+            medium: 10240,
+            high: 20480,
+            xhigh: 32000,
+          };
+          const customBudget =
+            options.thinkingBudgets?.[
+              options.reasoning as keyof typeof options.thinkingBudgets
+            ];
+          const requestedBudget =
+            customBudget ?? defaultBudgets[options.reasoning] ?? 10240;
+
+          params.thinking = {
+            type: "enabled",
+            budget_tokens: Math.min(requestedBudget, maxTokens - 1),
+          };
+        }
+      }
+
+      // Raw stream instead of the MessageStream helper: MessageStream
+      // accumulates tool_use input and JSON.parses it on content_block_stop,
+      // which throws under fine-grained-tool-streaming (input may be invalid
+      // mid-flight) and aborts the turn. The raw stream yields the same
+      // RawMessageStreamEvents; tool args are already parsed leniently below.
+      const { data: anthropicStream, response: httpResponse } =
+        await client.messages
+          .create(params, {
+            signal: options?.signal,
+          })
+          .withResponse();
+
+      if (options?.onResponse) {
+        try {
+          await options.onResponse(
+            {
+              status: httpResponse.status,
+              headers: headersToRecord(httpResponse.headers),
+            },
+            model,
+          );
+        } catch {
+          // Response hooks are best-effort and should not break streaming.
+        }
+      }
+
+      stream.push({ type: "start", partial: output });
+
+      const blocks = output.content as IndexedBlock[];
+
+      for await (const event of anthropicStream) {
+        if (event.type === "message_start") {
+          output.usage.input = event.message.usage.input_tokens || 0;
+          output.usage.output = event.message.usage.output_tokens || 0;
+          output.usage.cacheRead =
+            (event.message.usage as { cache_read_input_tokens?: number })
+              .cache_read_input_tokens || 0;
+          output.usage.cacheWrite =
+            (event.message.usage as { cache_creation_input_tokens?: number })
+              .cache_creation_input_tokens || 0;
+          output.usage.totalTokens =
+            output.usage.input +
+            output.usage.output +
+            output.usage.cacheRead +
+            output.usage.cacheWrite;
+          calculateCost(model, output.usage);
+          continue;
+        }
+
+        if (event.type === "content_block_start") {
+          if (event.content_block.type === "text") {
+            output.content.push({
+              type: "text",
+              text: "",
+              index: event.index,
+            } as IndexedBlock);
+            stream.push({
+              type: "text_start",
+              contentIndex: output.content.length - 1,
+              partial: output,
+            });
+          } else if (event.content_block.type === "thinking") {
+            output.content.push({
+              type: "thinking",
+              thinking: "",
+              thinkingSignature: "",
+              index: event.index,
+            } as IndexedBlock);
+            stream.push({
+              type: "thinking_start",
+              contentIndex: output.content.length - 1,
+              partial: output,
+            });
+          } else if (event.content_block.type === "redacted_thinking") {
+            output.content.push({
+              type: "thinking",
+              thinking: "[Reasoning redacted]",
+              thinkingSignature: event.content_block.data,
+              redacted: true,
+              index: event.index,
+            } as IndexedBlock);
+            stream.push({
+              type: "thinking_start",
+              contentIndex: output.content.length - 1,
+              partial: output,
+            });
+          } else if (event.content_block.type === "tool_use") {
+            output.content.push({
+              type: "toolCall",
+              id: event.content_block.id,
+              name: isOAuth
+                ? fromClaudeCodeToolName(
+                    event.content_block.name,
+                    context.tools,
+                  )
+                : event.content_block.name,
+              arguments: {},
+              partialJson: "",
+              index: event.index,
+            } as IndexedBlock);
+            stream.push({
+              type: "toolcall_start",
+              contentIndex: output.content.length - 1,
+              partial: output,
+            });
+          }
+          continue;
+        }
+
+        if (event.type === "content_block_delta") {
+          const contentIndex = blocks.findIndex(
+            (block) => block.index === event.index,
+          );
+          const block = blocks[contentIndex];
+          if (!block) continue;
+
+          if (event.delta.type === "text_delta" && block.type === "text") {
+            block.text += event.delta.text;
+            stream.push({
+              type: "text_delta",
+              contentIndex,
+              delta: event.delta.text,
+              partial: output,
+            });
+          } else if (
+            event.delta.type === "thinking_delta" &&
+            block.type === "thinking"
+          ) {
+            block.thinking += event.delta.thinking;
+            stream.push({
+              type: "thinking_delta",
+              contentIndex,
+              delta: event.delta.thinking,
+              partial: output,
+            });
+          } else if (
+            event.delta.type === "signature_delta" &&
+            block.type === "thinking"
+          ) {
+            block.thinkingSignature =
+              (block.thinkingSignature || "") + event.delta.signature;
+          } else if (
+            event.delta.type === "input_json_delta" &&
+            block.type === "toolCall"
+          ) {
+            block.partialJson += event.delta.partial_json;
+            try {
+              block.arguments = JSON.parse(block.partialJson) as Record<
+                string,
+                unknown
+              >;
+            } catch {}
+            stream.push({
+              type: "toolcall_delta",
+              contentIndex,
+              delta: event.delta.partial_json,
+              partial: output,
+            });
+          }
+          continue;
+        }
+
+        if (event.type === "content_block_stop") {
+          const contentIndex = blocks.findIndex(
+            (block) => block.index === event.index,
+          );
+          const block = blocks[contentIndex];
+          if (!block) continue;
+
+          delete (block as { index?: number }).index;
+          if (block.type === "text") {
+            stream.push({
+              type: "text_end",
+              contentIndex,
+              content: block.text,
+              partial: output,
+            });
+          } else if (block.type === "thinking") {
+            stream.push({
+              type: "thinking_end",
+              contentIndex,
+              content: block.thinking,
+              partial: output,
+            });
+          } else if (block.type === "toolCall") {
+            try {
+              block.arguments = JSON.parse(block.partialJson) as Record<
+                string,
+                unknown
+              >;
+            } catch {}
+            delete (block as { partialJson?: string }).partialJson;
+            stream.push({
+              type: "toolcall_end",
+              contentIndex,
+              toolCall: block,
+              partial: output,
+            });
+          }
+          continue;
+        }
+
+        if (event.type === "message_delta") {
+          output.stopReason = mapStopReason(event.delta.stop_reason);
+          output.usage.input =
+            (event.usage as { input_tokens?: number }).input_tokens ||
+            output.usage.input;
+          output.usage.output =
+            (event.usage as { output_tokens?: number }).output_tokens ||
+            output.usage.output;
+          output.usage.cacheRead =
+            (event.usage as { cache_read_input_tokens?: number })
+              .cache_read_input_tokens || 0;
+          output.usage.cacheWrite =
+            (event.usage as { cache_creation_input_tokens?: number })
+              .cache_creation_input_tokens || 0;
+          const thinkingTokens = (
+            event.usage as {
+              output_tokens_details?: { thinking_tokens?: number };
+            }
+          ).output_tokens_details?.thinking_tokens;
+          if (thinkingTokens != null) {
+            output.usage.reasoning = thinkingTokens;
+          }
+          output.usage.totalTokens =
+            output.usage.input +
+            output.usage.output +
+            output.usage.cacheRead +
+            output.usage.cacheWrite;
+          calculateCost(model, output.usage);
+        }
+      }
+
+      if (options?.signal?.aborted) throw new Error("Request aborted");
+      stream.push({
+        type: "done",
+        reason: output.stopReason as "stop" | "length" | "toolUse",
+        message: output,
+      });
+      stream.end();
+    } catch (error) {
+      for (const block of output.content as Array<{
+        index?: number;
+        partialJson?: string;
+      }>) {
+        delete block.index;
+        delete block.partialJson;
+      }
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage =
+        error instanceof Error ? error.message : String(error);
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+      stream.end();
+    }
+  })();
+
+  return stream;
+}

package/src/anthropic-alias-stream.ts

@@ -0,0 +1,140 @@
+import {
+  createAssistantMessageEventStream,
+  type Api,
+  type AssistantMessage,
+  type AssistantMessageEvent,
+  type AssistantMessageEventStream,
+  type Context,
+  type Model,
+  type ProviderResponse,
+  type SimpleStreamOptions,
+} from "@earendil-works/pi-ai";
+import {
+  sanitizeDiagnosticText,
+  sanitizeHeaderValue,
+} from "./diagnostics.js";
+
+export const ANTHROPIC_ALIAS_API = "hypha-anthropic-oauth" as const;
+
+export type AnthropicUpstreamStream = (
+  model: Model<Api>,
+  context: Context,
+  options?: SimpleStreamOptions,
+) => AssistantMessageEventStream;
+
+/**
+ * Copies and sanitizes response metadata before it crosses into an
+ * extension-owned callback. The upstream response and headers are never
+ * retained or serialized by this adapter.
+ */
+export function sanitizeAnthropicProviderResponse(
+  response: ProviderResponse,
+): ProviderResponse {
+  return {
+    status: response.status,
+    headers: Object.fromEntries(
+      Object.entries(response.headers).map(([name, value]) => [
+        sanitizeDiagnosticText(name),
+        sanitizeHeaderValue(name, value),
+      ]),
+    ),
+  };
+}
+
+function withAliasAttribution(
+  message: AssistantMessage,
+  aliasModel: Model<Api>,
+): AssistantMessage {
+  return {
+    ...message,
+    api: aliasModel.api,
+    provider: aliasModel.provider,
+    model: aliasModel.id,
+  };
+}
+
+function sanitizeUpstreamError(message: AssistantMessage): AssistantMessage {
+  if (message.errorMessage === undefined) return message;
+  return {
+    ...message,
+    errorMessage: sanitizeDiagnosticText(message.errorMessage),
+  };
+}
+
+function withAliasEvent(
+  event: AssistantMessageEvent,
+  aliasModel: Model<Api>,
+): AssistantMessageEvent {
+  switch (event.type) {
+    case "done":
+      return {
+        ...event,
+        message: withAliasAttribution(event.message, aliasModel),
+      };
+    case "error":
+      return {
+        ...event,
+        error: withAliasAttribution(
+          sanitizeUpstreamError(event.error),
+          aliasModel,
+        ),
+      };
+    default:
+      return {
+        ...event,
+        partial: withAliasAttribution(event.partial, aliasModel),
+      };
+  }
+}
+
+function reattributeStream(
+  upstream: AssistantMessageEventStream,
+  aliasModel: Model<Api>,
+): AssistantMessageEventStream {
+  const attributed = createAssistantMessageEventStream();
+
+  void (async () => {
+    for await (const event of upstream) {
+      attributed.push(withAliasEvent(event, aliasModel));
+    }
+  })();
+
+  return attributed;
+}
+
+/**
+ * Creates the sole extension-owned Anthropic alias handler. Pi resolves the
+ * alias credential before calling this function, so the adapter forwards the
+ * complete options object (including apiKey) to upstream. Its only request-side
+ * model change is a shallow clone with provider rebound to `anthropic`, which
+ * keeps the exact upstream OAuth/Claude Code transport path active.
+ */
+export function createAnthropicAliasStream(
+  upstreamStream: AnthropicUpstreamStream,
+): AnthropicUpstreamStream {
+  return (aliasModel, context, options) => {
+    const upstreamModel: Model<Api> = {
+      ...aliasModel,
+      provider: "anthropic",
+    };
+
+    let upstreamOptions = options;
+    if (options?.onResponse) {
+      const aliasOnResponse = options.onResponse;
+      upstreamOptions = {
+        ...options,
+        onResponse: async (response) => {
+          await aliasOnResponse(
+            sanitizeAnthropicProviderResponse(response),
+            aliasModel,
+          );
+        },
+      };
+    }
+
+    return reattributeStream(
+      upstreamStream(upstreamModel, context, upstreamOptions),
+      aliasModel,
+    );
+  };
+}