@nyte-ai/plugin 0.0.21 → 0.0.24

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

@@ -1,444 +0,0 @@
-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 };

package/dist/chunks/billing-9qc0eqh4.js

@@ -1,174 +0,0 @@
-// examples/claude-code/model-catalog.ts
-import { Type } from "typebox";
-var PROVIDER_ID2 = "anthropic";
-var API_ID2 = "claude-code-stream-json";
-var discoveredModelSchema2 = Type.Object({
-  value: Type.String(),
-  resolvedModel: Type.Optional(Type.String()),
-  displayName: Type.String(),
-  description: Type.String(),
-  supportsEffort: Type.Optional(Type.Boolean()),
-  supportedEffortLevels: Type.Optional(Type.Array(Type.Union([
-    Type.Literal("low"),
-    Type.Literal("medium"),
-    Type.Literal("high"),
-    Type.Literal("xhigh"),
-    Type.Literal("max")
-  ]))),
-  supportsAdaptiveThinking: Type.Optional(Type.Boolean()),
-  supportsFastMode: Type.Optional(Type.Boolean()),
-  supportsAutoMode: Type.Optional(Type.Boolean())
-});
-function withoutContextSuffix(model) {
-  return model.replace(/\[1m\]$/u, "");
-}
-function fromBuiltin(id, builtin) {
-  const {
-    api: _api,
-    provider: _provider,
-    baseUrl: _baseUrl,
-    compat: _compat,
-    ...metadata
-  } = builtin;
-  return {
-    ...metadata,
-    id,
-    name: id === "default" ? `Default (${builtin.name})` : builtin.name,
-    api: API_ID2,
-    provider: PROVIDER_ID2,
-    baseUrl: "process://claude-code"
-  };
-}
-function createClaudeModelCatalog2() {
-  const BUILTIN_ANTHROPIC_MODELS = new Map;
-  function restoreAnthropicModels(models) {
-    BUILTIN_ANTHROPIC_MODELS.clear();
-    for (const model of models)
-      BUILTIN_ANTHROPIC_MODELS.set(model.id, model);
-  }
-  const models = new Map;
-  const FALLBACK_DISCOVERY = [
-    {
-      value: "default",
-      resolvedModel: "claude-opus-5-5[1m]",
-      displayName: "Default (recommended)",
-      description: "Opus 5.5 with 1M context · Best for everyday, complex tasks",
-      supportsEffort: true,
-      supportedEffortLevels: ["low", "medium", "high", "xhigh", "max"],
-      supportsAdaptiveThinking: true,
-      supportsFastMode: true,
-      supportsAutoMode: true
-    },
-    {
-      value: "opus[1m]",
-      resolvedModel: "claude-opus-5-5[1m]",
-      displayName: "Opus (1M context)",
-      description: "Opus 5.5 with 1M context · Best for everyday, complex tasks",
-      supportsEffort: true,
-      supportedEffortLevels: ["low", "medium", "high", "xhigh", "max"],
-      supportsAdaptiveThinking: true,
-      supportsFastMode: true,
-      supportsAutoMode: true
-    },
-    {
-      value: "claude-fable-5-1[1m]",
-      resolvedModel: "claude-fable-5-1",
-      displayName: "Fable",
-      description: "Fable 5.1 · Most capable for the hardest and longest-running tasks",
-      supportsEffort: true,
-      supportedEffortLevels: ["low", "medium", "high", "xhigh", "max"],
-      supportsAdaptiveThinking: true,
-      supportsAutoMode: true
-    },
-    {
-      value: "sonnet",
-      resolvedModel: "claude-sonnet-5",
-      displayName: "Sonnet",
-      description: "Sonnet 5 · Efficient for routine tasks",
-      supportsEffort: true,
-      supportedEffortLevels: ["low", "medium", "high", "xhigh", "max"],
-      supportsAdaptiveThinking: true,
-      supportsAutoMode: true
-    },
-    {
-      value: "haiku",
-      resolvedModel: "claude-haiku-4-5-20251001",
-      displayName: "Haiku",
-      description: "Haiku 4.5 · Fastest for quick answers"
-    }
-  ];
-  const ALIASES = {
-    sonnet: "claude-sonnet-5",
-    haiku: "claude-haiku-4-5-20251001",
-    "claude-haiku-4-5": "claude-haiku-4-5-20251001",
-    opus: "claude-opus-5-5",
-    fable: "claude-fable-5-1"
-  };
-  function canonicalModelId(info) {
-    if (info.value === "default")
-      return "default";
-    return withoutContextSuffix(info.resolvedModel || ALIASES[withoutContextSuffix(info.value)] || info.value);
-  }
-  function fallbackModel(info, id) {
-    const supported = info.supportedEffortLevels;
-    const thinkingLevelMap = supported?.length ? Object.fromEntries(supported.map((level) => [level, level])) : undefined;
-    return {
-      id,
-      name: `${info.displayName} (Claude Code)`,
-      api: API_ID2,
-      provider: PROVIDER_ID2,
-      baseUrl: "process://claude-code",
-      reasoning: info.supportsAdaptiveThinking === true || info.supportsEffort === true,
-      ...thinkingLevelMap ? { thinkingLevelMap } : {},
-      input: ["text", "image"],
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-      contextWindow: /\b1M context\b/iu.test(info.description) ? 1e6 : 200000,
-      maxTokens: 64000
-    };
-  }
-  function modelFromDiscovery(info) {
-    const id = canonicalModelId(info);
-    const builtinId = id === "default" ? withoutContextSuffix(info.resolvedModel || "") : id;
-    const builtin = BUILTIN_ANTHROPIC_MODELS.get(builtinId);
-    models.set(id, {
-      route: info.value,
-      nativeToolChanges: builtin?.compat?.supportsMidConvoToolChanges === true,
-      adaptiveThinking: info.supportsAdaptiveThinking === true
-    });
-    return builtin ? fromBuiltin(id, builtin) : fallbackModel(info, id);
-  }
-  function fallbackClaudeModels() {
-    return FALLBACK_DISCOVERY.map(modelFromDiscovery);
-  }
-  function nativeModel(model) {
-    const direct = models.get(model)?.route;
-    if (direct)
-      return direct;
-    if (model === "default")
-      return model;
-    const canonical = canonicalRoute(model);
-    return model.endsWith("[1m]") ? `${canonical}[1m]` : canonical;
-  }
-  function canonicalRoute(model) {
-    const withoutSuffix = withoutContextSuffix(model);
-    return ALIASES[withoutSuffix] ?? withoutSuffix;
-  }
-  function supportsAdaptiveThinking(model) {
-    const canonical = canonicalRoute(model);
-    return models.get(model)?.adaptiveThinking ?? models.get(canonical)?.adaptiveThinking ?? true;
-  }
-  function supportsNativeToolChanges(model) {
-    const canonical = canonicalRoute(model);
-    return models.get(model)?.nativeToolChanges ?? models.get(canonical)?.nativeToolChanges ?? BUILTIN_ANTHROPIC_MODELS.get(canonical)?.compat?.supportsMidConvoToolChanges === true;
-  }
-  return {
-    restoreAnthropicModels,
-    modelFromDiscovery,
-    fallbackClaudeModels,
-    nativeModel,
-    supportsAdaptiveThinking,
-    supportsNativeToolChanges
-  };
-}
-
-export { PROVIDER_ID2, API_ID2, discoveredModelSchema2, createClaudeModelCatalog2 };