@nyte-ai/plugin 0.0.0-stage → 0.0.19

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

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

package/dist/chunks/billing-a9vqn66p.js

@@ -0,0 +1,351 @@
+import {
+  matchesRecord2,
+  parseRecord2,
+  parseStreamEvent2
+} from "./billing-0y7dfkp2.js";
+
+// examples/claude-code/turn-relay.ts
+import { createServer, request as httpRequest } from "node:http";
+import https from "node:https";
+import { randomBytes } from "node:crypto";
+class AnthropicCapture2 {
+  message;
+  complete = false;
+  error;
+  pending = "";
+  decoder = new TextDecoder;
+  argumentsByIndex = new Map;
+  onEvent;
+  constructor(onEvent) {
+    this.onEvent = onEvent;
+  }
+  feed(chunk) {
+    this.pending += this.decoder.decode(chunk, { stream: true });
+    this.consumeFrames();
+  }
+  finish() {
+    this.pending += this.decoder.decode();
+    this.consumeFrames();
+  }
+  consumeFrames() {
+    for (;; ) {
+      const match = /\r?\n\r?\n/u.exec(this.pending);
+      if (!match)
+        return;
+      const frame = this.pending.slice(0, match.index);
+      this.pending = this.pending.slice(match.index + match[0].length);
+      const data = frame.split(/\r?\n/u).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join(`
+`);
+      if (!data || data === "[DONE]")
+        continue;
+      const event = parseStreamEvent2(data);
+      if (event === undefined)
+        continue;
+      this.apply(event);
+      this.onEvent?.(event);
+    }
+  }
+  apply(event) {
+    switch (event.type) {
+      case "message_start":
+        this.message = structuredClone(event.message);
+        break;
+      case "content_block_start":
+        if (this.message)
+          this.message.content[event.index] = structuredClone(event.content_block);
+        break;
+      case "content_block_delta": {
+        const block = this.message?.content[event.index];
+        if (!block)
+          break;
+        const delta = event.delta;
+        if (delta.type === "text_delta" && block.type === "text")
+          block.text += delta.text;
+        else if (delta.type === "thinking_delta" && block.type === "thinking")
+          block.thinking += delta.thinking;
+        else if (delta.type === "signature_delta" && block.type === "thinking") {
+          block.signature = (block.signature ?? "") + delta.signature;
+        } else if (delta.type === "input_json_delta" && block.type === "tool_use") {
+          this.argumentsByIndex.set(event.index, (this.argumentsByIndex.get(event.index) ?? "") + delta.partial_json);
+        }
+        break;
+      }
+      case "content_block_stop": {
+        const block = this.message?.content[event.index];
+        if (block?.type === "tool_use" && this.argumentsByIndex.has(event.index)) {
+          const raw = this.argumentsByIndex.get(event.index) ?? "";
+          block.input = raw.trim() ? parseRecord2(raw) : {};
+          this.argumentsByIndex.delete(event.index);
+        }
+        break;
+      }
+      case "message_delta":
+        if (this.message) {
+          Object.assign(this.message, event.delta);
+          if (event.usage)
+            this.message.usage = {
+              input_tokens: this.message.usage?.input_tokens ?? 0,
+              output_tokens: this.message.usage?.output_tokens ?? 0,
+              ...this.message.usage,
+              ...event.usage
+            };
+        }
+        break;
+      case "message_stop":
+        this.complete = !!this.message?.stop_reason && this.argumentsByIndex.size === 0;
+        break;
+      case "error": {
+        const { type, message } = event.error ?? {};
+        this.error = [type, message].filter(Boolean).join(": ") || "unknown stream error";
+        break;
+      }
+    }
+  }
+}
+var STRIPPED_REQUEST_HEADERS = new Set([
+  "host",
+  "connection",
+  "content-length",
+  "transfer-encoding",
+  "proxy-authorization",
+  "proxy-connection",
+  "accept-encoding"
+]);
+var STRIPPED_RESPONSE_HEADERS = new Set(["connection", "transfer-encoding", "server", "date"]);
+
+class TurnRelay2 {
+  capture;
+  used = false;
+  denied = 0;
+  status;
+  requestId;
+  failure;
+  errorBody = Buffer.alloc(0);
+  originalRequestBody;
+  requestBody;
+  upstream;
+  prefix = `/turn/${randomBytes(32).toString("base64url")}`;
+  server;
+  sockets = new Set;
+  active = new Set;
+  cancelled = false;
+  closed = false;
+  baseUrl;
+  transformRequest;
+  requestBetas = [];
+  timeoutMs;
+  constructor(upstream = "https://api.anthropic.com", timeoutMs = 180000, onEvent, transformRequest, requestBetas = []) {
+    this.timeoutMs = timeoutMs;
+    this.upstream = new URL(upstream);
+    const loopback = ["127.0.0.1", "::1", "localhost"].includes(this.upstream.hostname);
+    if (this.upstream.protocol !== "https:" && !(this.upstream.protocol === "http:" && loopback) || this.upstream.username || this.upstream.password || this.upstream.search || this.upstream.hash) {
+      throw new Error("Claude Code upstream must be HTTPS or a loopback HTTP fixture");
+    }
+    this.capture = new AnthropicCapture2(onEvent);
+    this.transformRequest = transformRequest;
+    this.requestBetas = requestBetas;
+    this.server = createServer((request, response) => {
+      const operation = this.handle(request, response).finally(() => this.active.delete(operation));
+      this.active.add(operation);
+    });
+  }
+  beginTurn(onEvent, transformRequest, requestBetas = []) {
+    if (this.closed)
+      throw new Error("Claude Code turn relay is closed");
+    if (this.active.size > 0)
+      throw new Error("Claude Code turn relay still has an active request");
+    this.capture = new AnthropicCapture2(onEvent);
+    this.used = false;
+    this.denied = 0;
+    this.status = undefined;
+    this.requestId = undefined;
+    this.failure = undefined;
+    this.errorBody = Buffer.alloc(0);
+    this.originalRequestBody = undefined;
+    this.requestBody = undefined;
+    this.transformRequest = transformRequest;
+    this.requestBetas = requestBetas;
+    this.cancelled = false;
+  }
+  finishTurn() {
+    if (this.cancelled)
+      return;
+    this.cancelled = true;
+    for (const socket of this.sockets)
+      socket.destroy(new Error("Claude Code request aborted"));
+    this.sockets.clear();
+    this.server.closeAllConnections?.();
+  }
+  async start() {
+    await new Promise((resolve, reject) => {
+      const onError = (error) => reject(error);
+      this.server.once("error", onError);
+      this.server.listen(0, "127.0.0.1", () => {
+        this.server.off("error", onError);
+        resolve();
+      });
+    });
+    const address = this.server.address();
+    if (address === null || typeof address === "string")
+      throw new Error("Claude Code relay did not bind a TCP port");
+    this.baseUrl = `http://127.0.0.1:${address.port}${this.prefix}`;
+    return this.baseUrl;
+  }
+  errorText() {
+    if (this.capture.error)
+      return this.capture.error;
+    const text = this.errorBody.toString("utf8");
+    try {
+      const payload = parseRecord2(text);
+      return matchesRecord2(payload.error) && typeof payload.error.message === "string" ? payload.error.message : text;
+    } catch {
+      return text;
+    }
+  }
+  abort() {
+    this.finishTurn();
+  }
+  async settled() {
+    await Promise.allSettled(this.active);
+  }
+  async close() {
+    this.closed = true;
+    this.abort();
+    await new Promise((resolve) => {
+      if (!this.server.listening)
+        return resolve();
+      this.server.close(() => resolve());
+    });
+    await this.settled();
+  }
+  async handle(request, response) {
+    const requestUrl = new URL(request.url ?? "/", "http://127.0.0.1");
+    if (request.method !== "POST" || requestUrl.pathname !== `${this.prefix}/v1/messages` || request.headers.origin) {
+      response.writeHead(404).end();
+      return;
+    }
+    if (this.cancelled || this.used) {
+      this.denied += 1;
+      const body = Buffer.from(JSON.stringify({
+        type: "error",
+        error: { type: "invalid_request_error", message: "NYTE_CLAUDE_CODE_TURN_RELAY_CONSUMED" }
+      }));
+      response.writeHead(400, { "content-type": "application/json", "content-length": body.length }).end(body);
+      return;
+    }
+    this.used = true;
+    this.sockets.add(request);
+    this.sockets.add(response);
+    let upstreamRequest;
+    try {
+      let body = await this.readBody(request);
+      this.originalRequestBody = Buffer.from(body);
+      if (this.transformRequest)
+        body = this.transformRequest(body);
+      this.requestBody = Buffer.from(body);
+      if (this.cancelled)
+        return;
+      const headers = {};
+      for (const [name, value] of Object.entries(request.headers)) {
+        if (!STRIPPED_REQUEST_HEADERS.has(name.toLowerCase()) && value !== undefined)
+          headers[name] = value;
+      }
+      headers["accept-encoding"] = "identity";
+      headers["content-length"] = body.length;
+      if (this.requestBetas.length > 0) {
+        const existing = Array.isArray(headers["anthropic-beta"]) ? headers["anthropic-beta"].join(",") : String(headers["anthropic-beta"] ?? "");
+        headers["anthropic-beta"] = [
+          ...new Set([
+            ...existing.split(",").map((value) => value.trim()).filter(Boolean),
+            ...this.requestBetas
+          ])
+        ].join(",");
+      }
+      const pathPrefix = this.upstream.pathname.replace(/\/$/u, "");
+      const send = this.upstream.protocol === "https:" ? https.request : httpRequest;
+      const outgoing = send({
+        protocol: this.upstream.protocol,
+        hostname: this.upstream.hostname,
+        port: this.upstream.port || undefined,
+        method: "POST",
+        path: `${pathPrefix}/v1/messages${requestUrl.search}`,
+        headers,
+        timeout: this.timeoutMs
+      });
+      upstreamRequest = outgoing;
+      this.sockets.add(outgoing);
+      const upstreamResponse = await new Promise((resolve, reject) => {
+        outgoing.once("response", resolve);
+        outgoing.once("error", reject);
+        outgoing.end(body);
+      });
+      this.sockets.add(upstreamResponse);
+      this.status = upstreamResponse.statusCode;
+      this.requestId = String(upstreamResponse.headers["request-id"] ?? upstreamResponse.headers["x-request-id"] ?? "") || undefined;
+      const responseHeaders = {};
+      for (const [name, value] of Object.entries(upstreamResponse.headers)) {
+        if (!STRIPPED_RESPONSE_HEADERS.has(name.toLowerCase()) && value !== undefined)
+          responseHeaders[name] = value;
+      }
+      responseHeaders.connection = "close";
+      response.writeHead(upstreamResponse.statusCode ?? 502, responseHeaders);
+      for await (const rawChunk of upstreamResponse) {
+        const chunk = Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk);
+        if (this.status === 200)
+          this.capture.feed(chunk);
+        else if (this.errorBody.length < 65536) {
+          this.errorBody = Buffer.concat([this.errorBody, chunk]).subarray(0, 65536);
+        }
+        if (!response.write(chunk))
+          await this.waitForDrain(response);
+      }
+      if (this.status === 200)
+        this.capture.finish();
+      response.end();
+    } catch (error) {
+      this.failure = error instanceof Error ? error.name : "UnknownError";
+      if (!response.headersSent)
+        response.writeHead(this.cancelled ? 499 : 502).end();
+      else
+        response.destroy();
+    } finally {
+      if (upstreamRequest)
+        this.sockets.delete(upstreamRequest);
+      this.sockets.delete(request);
+      this.sockets.delete(response);
+      upstreamRequest?.destroy();
+    }
+  }
+  async waitForDrain(response) {
+    await new Promise((resolve, reject) => {
+      const cleanup = () => {
+        response.off("drain", onDrain);
+        response.off("close", onClose);
+        response.off("error", onError);
+      };
+      const onDrain = () => {
+        cleanup();
+        resolve();
+      };
+      const onClose = () => {
+        cleanup();
+        reject(new Error("Claude Code disconnected from the turn relay"));
+      };
+      const onError = (error) => {
+        cleanup();
+        reject(error);
+      };
+      response.once("drain", onDrain);
+      response.once("close", onClose);
+      response.once("error", onError);
+    });
+  }
+  async readBody(request) {
+    const chunks = [];
+    for await (const rawChunk of request)
+      chunks.push(Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk));
+    return Buffer.concat(chunks);
+  }
+}
+
+export { AnthropicCapture2, TurnRelay2 };