@nyte-ai/plugin 0.0.0-stage → 0.0.18

package/dist/chunks/billing-8rjk35gr.js

@@ -0,0 +1,444 @@
+import {
+  parseRecord2
+} from "./billing-0y7dfkp2.js";
+import {
+  describeUsageCreditsRejection2
+} from "./billing-tzr3cebf.js";
+import {
+  TOOL_PREFIX2,
+  NATIVE_TOOL_CHANGES_BETA2,
+  getInitialUserPrefix2,
+  getInitialSystemMessages2,
+  prepareFrames2,
+  prepareTools2,
+  prepareNativeTranscript2,
+  buildExtraBody2,
+  makeReplayDiagnostic2
+} from "./billing-ejx2hv52.js";
+import {
+  runClaudeRequest2
+} from "./billing-3scqmkzb.js";
+
+// examples/claude-code/stream.ts
+import {
+  calculateCost,
+  collapseSystemMessages,
+  createAssistantMessageEventStream,
+  getCurrentSystemPrompt,
+  getCurrentTools,
+  getInitialSystemMessage,
+  getSystemMessageText
+} from "@nyte-ai/ai";
+function mapStopReason(reason) {
+  switch (reason) {
+    case "end_turn":
+    case "pause_turn":
+    case "stop_sequence":
+      return { stopReason: "stop" };
+    case "max_tokens":
+    case "model_context_window_exceeded":
+      return { stopReason: "length" };
+    case "tool_use":
+      return { stopReason: "toolUse" };
+    case "refusal":
+      return { stopReason: "error", errorMessage: "The model refused to complete the request" };
+    case "sensitive":
+      return { stopReason: "error", errorMessage: "Provider stopped with: sensitive" };
+    default:
+      return {
+        stopReason: "error",
+        errorMessage: `Unhandled Claude Code stop reason: ${reason ?? "missing"}`
+      };
+  }
+}
+function parseArguments(raw, fallback) {
+  if (!raw.trim())
+    return fallback;
+  try {
+    return parseRecord2(raw);
+  } catch {
+    return fallback;
+  }
+}
+function updateUsage(output, model, usage) {
+  if (!usage)
+    return;
+  if (typeof usage.input_tokens === "number")
+    output.usage.input = usage.input_tokens;
+  if (typeof usage.output_tokens === "number")
+    output.usage.output = usage.output_tokens;
+  if (typeof usage.cache_read_input_tokens === "number")
+    output.usage.cacheRead = usage.cache_read_input_tokens;
+  if (typeof usage.cache_creation_input_tokens === "number")
+    output.usage.cacheWrite = usage.cache_creation_input_tokens;
+  const oneHour = usage.cache_creation?.ephemeral_1h_input_tokens;
+  if (typeof oneHour === "number")
+    output.usage.cacheWrite1h = oneHour;
+  const thinking = usage.output_tokens_details?.thinking_tokens;
+  if (typeof thinking === "number")
+    output.usage.reasoning = thinking;
+  output.usage.totalTokens = output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
+  calculateCost(model, output.usage);
+}
+function comparableContent(content) {
+  return content.map((block) => {
+    if (block.type === "text")
+      return { type: "text", text: block.text };
+    if (block.type === "thinking") {
+      return {
+        type: "thinking",
+        thinking: block.thinking,
+        thinkingSignature: block.thinkingSignature,
+        redacted: block.redacted
+      };
+    }
+    return { type: "toolCall", id: block.id, name: block.name, arguments: block.arguments };
+  });
+}
+function nativeContent(content, toolNames) {
+  const converted = [];
+  for (const block of content) {
+    if (block.type === "text") {
+      converted.push({ type: "text", text: block.text });
+    } else if (block.type === "thinking") {
+      converted.push({
+        type: "thinking",
+        thinking: block.thinking,
+        thinkingSignature: block.signature
+      });
+    } else if (block.type === "redacted_thinking") {
+      converted.push({
+        type: "thinking",
+        thinking: "[Reasoning redacted]",
+        thinkingSignature: block.data,
+        redacted: true
+      });
+    } else if (block.type === "tool_use") {
+      if (!block.name.startsWith(TOOL_PREFIX2))
+        throw new Error(`Claude Code returned unexpected tool ${block.name}`);
+      const name = block.name.slice(TOOL_PREFIX2.length);
+      if (!toolNames.has(name))
+        throw new Error(`Claude Code returned unavailable tool ${name}`);
+      converted.push({ type: "toolCall", id: block.id, name, arguments: block.input });
+    }
+  }
+  return converted;
+}
+
+class EventTranslator {
+  nativeToContent = new Map;
+  argumentsByIndex = new Map;
+  sawContentEvent = false;
+  model;
+  output;
+  stream;
+  toolNames;
+  constructor(model, output, stream, toolNames) {
+    this.model = model;
+    this.output = output;
+    this.stream = stream;
+    this.toolNames = toolNames;
+  }
+  event(event) {
+    switch (event.type) {
+      case "message_start":
+        if (event.message.id)
+          this.output.responseId = event.message.id;
+        updateUsage(this.output, this.model, event.message.usage);
+        break;
+      case "content_block_start":
+        this.startBlock(event.index, event.content_block);
+        break;
+      case "content_block_delta":
+        this.delta(event.index, event.delta);
+        break;
+      case "content_block_stop":
+        this.stopBlock(event.index);
+        break;
+      case "message_delta": {
+        if (event.delta.stop_reason) {
+          this.output.rawStopReason = event.delta.stop_reason;
+          const mapped = mapStopReason(event.delta.stop_reason);
+          this.output.stopReason = mapped.stopReason;
+          this.output.errorMessage = mapped.errorMessage;
+        }
+        updateUsage(this.output, this.model, event.usage);
+        break;
+      }
+    }
+  }
+  finish(message, usage, initialUserPrefix, initialSystemMessages) {
+    const authoritative = nativeContent(message.content, this.toolNames);
+    if (!this.sawContentEvent) {
+      this.emitComplete(authoritative);
+    } else if (JSON.stringify(comparableContent(this.output.content)) !== JSON.stringify(comparableContent(authoritative))) {
+      throw new Error("Claude Code final response differs from its incremental stream");
+    }
+    if (message.id)
+      this.output.responseId = message.id;
+    updateUsage(this.output, this.model, usage);
+    this.output.rawStopReason = message.stop_reason ?? undefined;
+    const mapped = mapStopReason(message.stop_reason);
+    this.output.stopReason = mapped.stopReason;
+    this.output.errorMessage = mapped.errorMessage;
+    this.output.diagnostics = [
+      ...this.output.diagnostics ?? [],
+      makeReplayDiagnostic2(message, this.output, initialUserPrefix, initialSystemMessages)
+    ];
+  }
+  startBlock(nativeIndex, native) {
+    this.sawContentEvent = true;
+    const contentIndex = this.output.content.length;
+    this.nativeToContent.set(nativeIndex, contentIndex);
+    if (native.type === "text") {
+      this.output.content.push({ type: "text", text: native.text ?? "" });
+      this.stream.push({ type: "text_start", contentIndex, partial: this.output });
+    } else if (native.type === "thinking") {
+      this.output.content.push({
+        type: "thinking",
+        thinking: native.thinking ?? "",
+        thinkingSignature: native.signature ?? ""
+      });
+      this.stream.push({ type: "thinking_start", contentIndex, partial: this.output });
+    } else if (native.type === "redacted_thinking") {
+      this.output.content.push({
+        type: "thinking",
+        thinking: "[Reasoning redacted]",
+        thinkingSignature: native.data,
+        redacted: true
+      });
+      this.stream.push({ type: "thinking_start", contentIndex, partial: this.output });
+    } else if (native.type === "tool_use") {
+      if (!native.name.startsWith(TOOL_PREFIX2))
+        throw new Error(`Claude Code returned unexpected tool ${native.name}`);
+      const name = native.name.slice(TOOL_PREFIX2.length);
+      if (!this.toolNames.has(name))
+        throw new Error(`Claude Code returned unavailable tool ${name}`);
+      this.output.content.push({
+        type: "toolCall",
+        id: native.id,
+        name,
+        arguments: native.input ?? {}
+      });
+      this.stream.push({ type: "toolcall_start", contentIndex, partial: this.output });
+    }
+  }
+  delta(nativeIndex, delta) {
+    const contentIndex = this.nativeToContent.get(nativeIndex);
+    if (contentIndex === undefined)
+      return;
+    const block = this.output.content[contentIndex];
+    if (!block)
+      return;
+    if (delta.type === "text_delta" && block.type === "text") {
+      block.text += delta.text;
+      this.stream.push({
+        type: "text_delta",
+        contentIndex,
+        delta: delta.text,
+        partial: this.output
+      });
+    } else if (delta.type === "thinking_delta" && block.type === "thinking") {
+      block.thinking += delta.thinking;
+      this.stream.push({
+        type: "thinking_delta",
+        contentIndex,
+        delta: delta.thinking,
+        partial: this.output
+      });
+    } else if (delta.type === "signature_delta" && block.type === "thinking") {
+      block.thinkingSignature = (block.thinkingSignature ?? "") + delta.signature;
+    } else if (delta.type === "input_json_delta" && block.type === "toolCall") {
+      const json = (this.argumentsByIndex.get(nativeIndex) ?? "") + delta.partial_json;
+      this.argumentsByIndex.set(nativeIndex, json);
+      block.arguments = parseArguments(json, block.arguments);
+      this.stream.push({
+        type: "toolcall_delta",
+        contentIndex,
+        delta: delta.partial_json,
+        partial: this.output
+      });
+    }
+  }
+  stopBlock(nativeIndex) {
+    const contentIndex = this.nativeToContent.get(nativeIndex);
+    if (contentIndex === undefined)
+      return;
+    const block = this.output.content[contentIndex];
+    if (!block)
+      return;
+    if (block.type === "text") {
+      this.stream.push({
+        type: "text_end",
+        contentIndex,
+        content: block.text,
+        partial: this.output
+      });
+    } else if (block.type === "thinking") {
+      this.stream.push({
+        type: "thinking_end",
+        contentIndex,
+        content: block.thinking,
+        partial: this.output
+      });
+    } else {
+      block.arguments = parseArguments(this.argumentsByIndex.get(nativeIndex) ?? "", block.arguments);
+      this.argumentsByIndex.delete(nativeIndex);
+      this.stream.push({
+        type: "toolcall_end",
+        contentIndex,
+        toolCall: block,
+        partial: this.output
+      });
+    }
+  }
+  emitComplete(content) {
+    for (const source of content) {
+      const contentIndex = this.output.content.length;
+      if (source.type === "text") {
+        this.output.content.push({ ...source });
+        this.stream.push({ type: "text_start", contentIndex, partial: this.output });
+        if (source.text)
+          this.stream.push({
+            type: "text_delta",
+            contentIndex,
+            delta: source.text,
+            partial: this.output
+          });
+        this.stream.push({
+          type: "text_end",
+          contentIndex,
+          content: source.text,
+          partial: this.output
+        });
+      } else if (source.type === "thinking") {
+        this.output.content.push({ ...source });
+        this.stream.push({ type: "thinking_start", contentIndex, partial: this.output });
+        if (source.thinking && !source.redacted) {
+          this.stream.push({
+            type: "thinking_delta",
+            contentIndex,
+            delta: source.thinking,
+            partial: this.output
+          });
+        }
+        this.stream.push({
+          type: "thinking_end",
+          contentIndex,
+          content: source.thinking,
+          partial: this.output
+        });
+      } else {
+        this.output.content.push({ ...source });
+        this.stream.push({ type: "toolcall_start", contentIndex, partial: this.output });
+        const json = JSON.stringify(source.arguments);
+        if (json)
+          this.stream.push({
+            type: "toolcall_delta",
+            contentIndex,
+            delta: json,
+            partial: this.output
+          });
+        this.stream.push({
+          type: "toolcall_end",
+          contentIndex,
+          toolCall: source,
+          partial: this.output
+        });
+      }
+    }
+  }
+}
+function normalizeError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const usageCredits = describeUsageCreditsRejection2(message);
+  if (usageCredits)
+    return usageCredits;
+  if (/prompt is too long|context(?:_| )length|context window exceeded|too many input tokens/iu.test(message)) {
+    return `context_length_exceeded: ${message}`;
+  }
+  return message;
+}
+function streamClaudeCode2(model, context, options, catalog) {
+  const stream = createAssistantMessageEventStream();
+  const output = {
+    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: "pending",
+    timestamp: Date.now()
+  };
+  (async () => {
+    try {
+      const nativeTranscript = prepareNativeTranscript2(context.messages, catalog.supportsNativeToolChanges(model.id));
+      const transcript = nativeTranscript ? context : collapseSystemMessages(context);
+      const initialSystem = getInitialSystemMessage(transcript.messages);
+      const systemPrompt = nativeTranscript ? initialSystem ? getSystemMessageText(initialSystem) : "" : getCurrentSystemPrompt(transcript.messages);
+      const tools = getCurrentTools(transcript.messages);
+      const frames = prepareFrames2(transcript.messages);
+      const initialUserPrefix = getInitialUserPrefix2(transcript.messages);
+      const initialSystemMessages = getInitialSystemMessages2(transcript.messages);
+      const preparedTools = prepareTools2(tools);
+      const extraBody = buildExtraBody2(nativeTranscript?.requestTools ?? preparedTools.nativeTools, options, catalog.supportsAdaptiveThinking(model.id));
+      const translator = new EventTranslator(model, output, stream, preparedTools.names);
+      stream.push({ type: "start", partial: output });
+      const response = await runClaudeRequest2({
+        model: catalog.nativeModel(model.id),
+        cwd: process.cwd(),
+        frames,
+        systemPrompt,
+        manifest: preparedTools.manifest,
+        extraBody,
+        toolNames: preparedTools.names,
+        signal: options?.signal,
+        timeoutMs: options?.timeoutMs,
+        env: options?.env,
+        initialUserPrefix,
+        initialSystemMessages,
+        nativeSystemInjections: nativeTranscript?.systemInjections,
+        betas: nativeTranscript ? [NATIVE_TOOL_CHANGES_BETA2] : undefined,
+        sessionId: options?.cacheRetention === "none" ? undefined : options?.sessionId,
+        onEvent: (event) => translator.event(event)
+      });
+      translator.finish(response.message, response.usage, response.initialUserPrefix, response.initialSystemMessages);
+      output.diagnostics = [
+        ...output.diagnostics ?? [],
+        {
+          type: "claude-code.turn-relay",
+          timestamp: Date.now(),
+          details: response.relay
+        },
+        ...response.rateLimit ? [
+          {
+            type: "claude-code.rate-limit",
+            timestamp: Date.now(),
+            details: response.rateLimit
+          }
+        ] : []
+      ];
+      if (output.stopReason === "error" || output.stopReason === "aborted" || output.stopReason === "pending") {
+        throw new Error(output.errorMessage || `Claude Code ended with ${output.stopReason}`);
+      }
+      stream.push({ type: "done", reason: output.stopReason, message: output });
+      stream.end();
+    } catch (error) {
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = normalizeError(error);
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+      stream.end();
+    }
+  })();
+  return stream;
+}
+
+export { streamClaudeCode2 };