swayrouter 1.0.0

package/src/transport/routerAdmission.ts

@@ -0,0 +1,380 @@
+import { readFileSync } from "node:fs";
+import { env } from "@/lib/env";
+import {
+  routerActiveRequests,
+  routerQueuedRequests,
+  routerConcurrencyLimit,
+  routerBodyBytesInUse,
+  routerAdmissionRejectsTotal,
+} from "@/observability/metrics.js";
+
+const MIB = 1024 * 1024;
+
+export type AdmissionReason = "queue_full" | "timeout" | "aborted" | "stopping" | "body_budget";
+
+export interface AdmissionLease {
+  release(): void;
+  releaseBody(): void;
+}
+
+export interface AdmissionResult {
+  ok: boolean;
+  reason?: AdmissionReason;
+  lease?: AdmissionLease;
+}
+
+export interface RouterAdmissionOptions {
+  hardMaxConcurrent?: number;
+  initialConcurrent?: number;
+  minConcurrent?: number;
+  maxQueue?: number;
+  queueWaitMs?: number;
+  bodyBudgetBytes?: number;
+  memoryHighWaterBytes?: number;
+  memoryCriticalWaterBytes?: number;
+  sampleIntervalMs?: number;
+  autoSample?: boolean;
+}
+
+interface Waiter {
+  bodyBytes: number;
+  workUnits: number;
+  resolve: (result: AdmissionResult) => void;
+  timer: ReturnType<typeof setTimeout> | null;
+  abortHandler: (() => void) | null;
+  signal: AbortSignal | null;
+  settled: boolean;
+}
+
+function positiveInt(value: unknown, fallback: number, max = 1_000_000): number {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 1) return fallback;
+  return Math.min(Math.floor(parsed), max);
+}
+
+function clampBodyBytes(value: number, budget: number): number {
+  if (!Number.isFinite(value) || value <= 0) return 0;
+  return Math.min(Math.floor(value), budget);
+}
+
+function readContainerMemoryLimit(): number | null {
+  for (const path of ["/sys/fs/cgroup/memory.max", "/sys/fs/cgroup/memory/memory.limit_in_bytes"]) {
+    try {
+      const raw = readFileSync(path, "utf8").trim();
+      if (!raw || raw === "max") continue;
+      const value = Number(raw);
+
+      if (Number.isFinite(value) && value > 0 && value < 1024 * 1024 * 1024 * 1024) {
+        return value;
+      }
+    } catch {
+
+    }
+  }
+  return null;
+}
+
+export class RouterAdmission {
+  readonly hardMaxConcurrent: number;
+  readonly minConcurrent: number;
+  readonly maxQueue: number;
+  readonly queueWaitMs: number;
+  readonly bodyBudgetBytes: number;
+  readonly sampleIntervalMs: number;
+
+  private targetConcurrent: number;
+  private active = 0;
+  private activeWorkUnits = 0;
+  private bodyBytesInUse = 0;
+  private readonly waiters: Waiter[] = [];
+  private stopping = false;
+  private stableSamples = 0;
+  private lastEventLoopLagMs = 0;
+  private readonly baselineRss: number;
+  private readonly memoryLimitBytes: number | null;
+  private readonly memoryHighWaterBytes: number;
+  private readonly memoryCriticalWaterBytes: number;
+  private sampleTimer: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(options: RouterAdmissionOptions = {}) {
+    this.hardMaxConcurrent = positiveInt(options.hardMaxConcurrent, env.routerMaxConcurrent, 100_000);
+    const initial = positiveInt(options.initialConcurrent, env.routerInitialConcurrent, 100_000);
+    this.minConcurrent = Math.min(
+      this.hardMaxConcurrent,
+      positiveInt(options.minConcurrent, env.routerMinConcurrent, 100_000),
+    );
+    this.targetConcurrent = Math.max(this.minConcurrent, Math.min(this.hardMaxConcurrent, initial));
+    this.maxQueue = positiveInt(options.maxQueue, env.routerMaxQueue, 1_000_000);
+    this.queueWaitMs = positiveInt(options.queueWaitMs, env.routerQueueWaitMs, 10 * 60 * 1000);
+    this.bodyBudgetBytes = positiveInt(options.bodyBudgetBytes, env.routerBodyBudgetBytes, 16 * 1024 * MIB);
+    this.sampleIntervalMs = positiveInt(options.sampleIntervalMs, 2000, 60_000);
+
+    this.baselineRss = this.readRss();
+    this.memoryLimitBytes = readContainerMemoryLimit();
+    const automaticHigh = this.memoryLimitBytes
+      ? Math.floor(this.memoryLimitBytes * 0.70)
+      : this.baselineRss + (512 * MIB);
+    const automaticCritical = this.memoryLimitBytes
+      ? Math.max(automaticHigh + 1, Math.floor(this.memoryLimitBytes * 0.85))
+      : this.baselineRss + (768 * MIB);
+    this.memoryHighWaterBytes = options.memoryHighWaterBytes
+      || env.routerMemoryHighWaterBytes
+      || automaticHigh;
+    this.memoryCriticalWaterBytes = options.memoryCriticalWaterBytes
+      || env.routerMemoryCriticalWaterBytes
+      || Math.max(automaticCritical, this.memoryHighWaterBytes + (128 * MIB));
+
+    this.updateMetrics();
+    if (options.autoSample !== false) this.armSampler();
+  }
+
+  private readRss(): number {
+    try {
+      return Number(process.memoryUsage?.().rss) || 0;
+    } catch {
+      return 0;
+    }
+  }
+
+  private updateMetrics(): void {
+    try {
+      routerActiveRequests.set({}, this.active);
+      routerQueuedRequests.set({}, this.waiters.length);
+      routerConcurrencyLimit.set({}, this.targetConcurrent);
+      routerBodyBytesInUse.set({}, this.bodyBytesInUse);
+    } catch {
+
+    }
+  }
+
+  private countReject(reason: AdmissionReason): void {
+    try { routerAdmissionRejectsTotal.inc({ reason }); } catch {}
+  }
+
+  private armSampler(): void {
+    if (this.sampleTimer) return;
+    const expectedAt = Date.now() + this.sampleIntervalMs;
+    this.sampleTimer = setTimeout(() => {
+      this.sampleTimer = null;
+      this.lastEventLoopLagMs = Math.max(0, Date.now() - expectedAt);
+      this.sample();
+      this.armSampler();
+    }, this.sampleIntervalMs);
+    this.sampleTimer?.unref?.();
+  }
+
+  sample(): void {
+    const rss = this.readRss();
+    const critical = rss >= this.memoryCriticalWaterBytes
+      || this.bodyBytesInUse >= this.bodyBudgetBytes * 0.95
+      || this.lastEventLoopLagMs >= 750;
+    const pressured = rss >= this.memoryHighWaterBytes
+      || this.bodyBytesInUse >= this.bodyBudgetBytes * 0.80
+      || this.lastEventLoopLagMs >= 250;
+
+    if (critical) {
+      this.targetConcurrent = Math.max(this.minConcurrent, Math.floor(this.targetConcurrent * 0.5));
+      this.stableSamples = 0;
+    } else if (pressured) {
+      this.targetConcurrent = Math.max(this.minConcurrent, Math.floor(this.targetConcurrent * 0.75));
+      this.stableSamples = 0;
+    } else if (this.waiters.length > 0 || this.activeWorkUnits >= this.targetConcurrent * 0.75) {
+      this.stableSamples += 1;
+      if (this.stableSamples >= 2) {
+        this.targetConcurrent = Math.min(
+          this.hardMaxConcurrent,
+          Math.max(this.targetConcurrent + 1, Math.ceil(this.targetConcurrent * 1.15)),
+        );
+        this.stableSamples = 0;
+      }
+    } else {
+      this.stableSamples = 0;
+    }
+    this.updateMetrics();
+    this.drain();
+  }
+
+  private canClaim(bodyBytes: number, workUnits: number): boolean {
+    return !this.stopping
+      && this.activeWorkUnits + workUnits <= this.targetConcurrent
+      && this.bodyBytesInUse + bodyBytes <= this.bodyBudgetBytes;
+  }
+
+  private claim(bodyBytes: number, workUnits: number): AdmissionLease {
+    this.active += 1;
+    this.activeWorkUnits += workUnits;
+    this.bodyBytesInUse += bodyBytes;
+    this.updateMetrics();
+    let released = false;
+    let bodyReleased = bodyBytes === 0;
+
+    return {
+      release: () => {
+        if (released) return;
+        released = true;
+        this.active = Math.max(0, this.active - 1);
+        this.activeWorkUnits = Math.max(0, this.activeWorkUnits - workUnits);
+        this.updateMetrics();
+        this.drain();
+      },
+      releaseBody: () => {
+        if (bodyReleased) return;
+        bodyReleased = true;
+        this.bodyBytesInUse = Math.max(0, this.bodyBytesInUse - bodyBytes);
+        this.updateMetrics();
+        this.drain();
+      },
+    };
+  }
+
+  private removeWaiter(waiter: Waiter): void {
+    const index = this.waiters.indexOf(waiter);
+    if (index >= 0) this.waiters.splice(index, 1);
+    if (waiter.timer) clearTimeout(waiter.timer);
+    waiter.timer = null;
+    if (waiter.signal && waiter.abortHandler) {
+      waiter.signal.removeEventListener("abort", waiter.abortHandler);
+    }
+    this.updateMetrics();
+  }
+
+  private settleWaiter(waiter: Waiter, result: AdmissionResult): void {
+    if (waiter.settled) return;
+    waiter.settled = true;
+    this.removeWaiter(waiter);
+    waiter.abortHandler = null;
+    waiter.resolve(result);
+  }
+
+  private drain(): void {
+    if (this.stopping) return;
+    while (this.activeWorkUnits < this.targetConcurrent && this.waiters.length > 0) {
+
+      const index = this.waiters.findIndex((waiter) => (
+        this.activeWorkUnits + waiter.workUnits <= this.targetConcurrent
+        && this.bodyBytesInUse + waiter.bodyBytes <= this.bodyBudgetBytes
+      ));
+      if (index < 0) return;
+      const waiter = this.waiters[index];
+      if (!waiter) return;
+      this.settleWaiter(waiter, { ok: true, lease: this.claim(waiter.bodyBytes, waiter.workUnits) });
+    }
+  }
+
+  acquire(bodyBytes = 0, signal: AbortSignal | null = null, workUnits = 1): Promise<AdmissionResult> {
+    const requestedBodyBytes = clampBodyBytes(bodyBytes, this.bodyBudgetBytes);
+    const requestedWorkUnits = positiveInt(workUnits, 1, this.hardMaxConcurrent);
+    if (bodyBytes > this.bodyBudgetBytes) {
+      this.countReject("body_budget");
+      return Promise.resolve({ ok: false, reason: "body_budget" });
+    }
+    if (this.stopping) {
+      this.countReject("stopping");
+      return Promise.resolve({ ok: false, reason: "stopping" });
+    }
+    if (signal?.aborted) {
+      this.countReject("aborted");
+      return Promise.resolve({ ok: false, reason: "aborted" });
+    }
+    if (this.canClaim(requestedBodyBytes, requestedWorkUnits)) {
+      return Promise.resolve({ ok: true, lease: this.claim(requestedBodyBytes, requestedWorkUnits) });
+    }
+    if (this.waiters.length >= this.maxQueue) {
+      this.countReject("queue_full");
+      return Promise.resolve({ ok: false, reason: "queue_full" });
+    }
+
+    return new Promise((resolve) => {
+      const waiter: Waiter = {
+        bodyBytes: requestedBodyBytes,
+        workUnits: requestedWorkUnits,
+        resolve,
+        timer: null,
+        abortHandler: null,
+        signal,
+        settled: false,
+      };
+      waiter.timer = setTimeout(() => this.settleWaiter(waiter, { ok: false, reason: "timeout" }), this.queueWaitMs);
+      waiter.abortHandler = () => this.settleWaiter(waiter, { ok: false, reason: "aborted" });
+      signal?.addEventListener("abort", waiter.abortHandler, { once: true });
+      this.waiters.push(waiter);
+      this.updateMetrics();
+    });
+  }
+
+  stopAccepting(): void {
+    this.stopping = true;
+    for (const waiter of [...this.waiters]) {
+      this.settleWaiter(waiter, { ok: false, reason: "stopping" });
+    }
+    if (this.sampleTimer) clearTimeout(this.sampleTimer);
+    this.sampleTimer = null;
+    this.updateMetrics();
+  }
+
+  snapshot() {
+    return {
+      active: this.active,
+      activeWorkUnits: this.activeWorkUnits,
+      queued: this.waiters.length,
+      bodyBytesInUse: this.bodyBytesInUse,
+      bodyBudgetBytes: this.bodyBudgetBytes,
+      currentLimit: this.targetConcurrent,
+      workUnitLimit: this.targetConcurrent,
+      hardMaxConcurrent: this.hardMaxConcurrent,
+      minConcurrent: this.minConcurrent,
+      rssBytes: this.readRss(),
+      baselineRssBytes: this.baselineRss,
+      memoryLimitBytes: this.memoryLimitBytes,
+      memoryHighWaterBytes: this.memoryHighWaterBytes,
+      memoryCriticalWaterBytes: this.memoryCriticalWaterBytes,
+      eventLoopLagMs: this.lastEventLoopLagMs,
+      stopping: this.stopping,
+    };
+  }
+}
+
+export const routerAdmission = new RouterAdmission();
+
+export function wrapResponseWithAdmission(response: Response, release: () => void): Response {
+  let released = false;
+  const releaseOnce = () => {
+    if (released) return;
+    released = true;
+    release();
+  };
+
+  if (!response?.body) {
+    releaseOnce();
+    return response;
+  }
+
+  const reader = response.body.getReader();
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          releaseOnce();
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      } catch (error) {
+        releaseOnce();
+        try { await reader.cancel(error); } catch {}
+        try { controller.error(error); } catch {}
+      }
+    },
+    cancel(reason) {
+      releaseOnce();
+      return reader.cancel(reason);
+    },
+  });
+
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: new Headers(response.headers),
+  });
+}

package/src/types/provider.ts

@@ -0,0 +1,59 @@
+export type ProviderStatus = "online" | "offline" | "degraded";
+
+export type ProviderType =
+  | "alicode" | "alicode-intl" | "alims-intl" | "anthropic" | "antigravity"
+  | "azure" | "baidu" | "blackbox" | "byteplus" | "cerebras"
+  | "chutes" | "claude" | "cline" | "clinepass" | "cloudflare-ai"
+  | "codebuddy-cn" | "codebuddy-intl" | "codex" | "commandcode" | "cursor"
+  | "deepseek" | "featherless" | "fireworks" | "gemini" | "gemini-cli"
+  | "github" | "glm" | "glm-cn" | "grok-cli" | "grok-web"
+  | "groq" | "kilo-gateway" | "kilocode" | "kimchi" | "kimi"
+  | "kiro" | "minimax" | "minimax-cn" | "mistral"
+  | "morph" | "nebius" | "nvidia" | "ollama" | "ollama-local"
+  | "openai" | "opencode" | "opencode-go" | "openrouter" | "perplexity"
+  | "poolside" | "qoder" | "tencent"
+  | "together" | "trae" | "venice" | "vercel-ai-gateway"
+  | "sumopod" | "vertex" | "vertex-partner" | "windsurf" | "xai" | "xiaomi-mimo"
+  | "xiaomi-tokenplan";
+
+export type ProviderCategory = "apikey" | "oauth" | "webCookie" | "none";
+export type AuthType = "apikey" | "oauth" | "cookie" | "none";
+
+export type ProviderFormat =
+  | "openai" | "claude" | "gemini" | "ollama" | "vertex"
+  | "cursor" | "commandcode" | "antigravity" | "kiro"
+  | "grok-web" | "gemini-cli"
+  | "custom";
+
+export type ProviderService = "llm" | "search" | "embeddings" | "image" | "audio";
+
+export interface OAuthConfig {
+  clientId?: string;
+  clientSecret?: string;
+  authUrl?: string;
+  tokenUrl?: string;
+  scopes?: string[];
+  [key: string]: unknown;
+}
+
+export interface Provider {
+  id: string;
+  name: string;
+  type: ProviderType;
+  category: ProviderCategory;
+  authType: AuthType;
+  authModes: AuthType[];
+  format: ProviderFormat;
+  service: ProviderService;
+  baseUrl: string;
+  apiKey?: string;
+  oauthConfig?: OAuthConfig;
+  models: string[];
+  status: ProviderStatus;
+  priority: number;
+  weight: number;
+  maxTokens: number;
+  rateLimit: number;
+  createdAt: string;
+  updatedAt: string;
+}

package/src/utils/bypassHandler.js

@@ -0,0 +1,272 @@
+import { detectFormat } from "../services/provider.js";
+import { translateResponse, initState } from "../translator/index.js";
+import { FORMATS } from "../translator/formats.js";
+import { SKIP_PATTERNS } from "../config/runtimeConfig.js";
+import { formatSSE } from "./stream.js";
+
+export function handleBypassRequest(body, model, userAgent = "", ccFilterNaming = false) {
+  if (!userAgent.includes("claude-cli")) return null;
+  if (!body.messages?.length) return null;
+
+  const messages = body.messages;
+  const getText = (content) => {
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      return content.filter(c => c.type === "text").map(c => c.text).join(" ");
+    }
+    return "";
+  };
+
+  let shouldBypass = false;
+  let namingBypass = false;
+
+  const lastMsg = messages[messages.length - 1];
+  if (lastMsg?.role === "assistant" && lastMsg.content?.[0]?.text === "{") {
+    shouldBypass = true;
+  }
+
+  if (!shouldBypass) {
+    const firstText = getText(messages[0]?.content);
+    if (firstText === "Warmup") {
+      shouldBypass = true;
+    }
+  }
+
+  if (!shouldBypass && messages.length === 1 && messages[0]?.role === "user") {
+    const firstText = getText(messages[0]?.content);
+    if (firstText === "count") {
+      shouldBypass = true;
+    }
+  }
+
+  if (!shouldBypass && SKIP_PATTERNS?.length) {
+    const userMessages = messages.filter(m => m.role === "user");
+    const userText = userMessages.map(m => getText(m.content)).join(" ");
+    if (SKIP_PATTERNS.some(p => userText.includes(p))) {
+      shouldBypass = true;
+    }
+  }
+
+  if (!shouldBypass && ccFilterNaming) {
+    const systemMsg = messages.find(m => m.role === "system");
+    const systemFromMessages = getText(systemMsg?.content);
+    const systemFromBody = Array.isArray(body.system)
+      ? body.system.filter(s => s.type === "text").map(s => s.text).join(" ")
+      : (typeof body.system === "string" ? body.system : "");
+    const systemText = systemFromMessages || systemFromBody;
+    if (systemText.includes("isNewTopic")) {
+      shouldBypass = true;
+      namingBypass = true;
+    }
+  }
+
+  if (!shouldBypass) return null;
+
+  const sourceFormat = detectFormat(body);
+  const stream = body.stream !== false;
+
+  if (namingBypass) {
+    const userMsg = messages.find(m => m.role === "user");
+    const userText = getText(userMsg?.content);
+    const title = userText.trim().split(/\s+/).slice(0, 3).join(" ");
+    const namingText = JSON.stringify({ isNewTopic: true, title });
+    return stream
+      ? createStreamingResponse(sourceFormat, model, namingText)
+      : createNonStreamingResponse(sourceFormat, model, namingText);
+  }
+
+  return stream
+    ? createStreamingResponse(sourceFormat, model)
+    : createNonStreamingResponse(sourceFormat, model);
+}
+
+const DEFAULT_BYPASS_TEXT = "CLI Command Execution: Clear Terminal";
+
+function createOpenAIResponse(model, text = DEFAULT_BYPASS_TEXT) {
+  const id = `chatcmpl-${Date.now()}`;
+  const created = Math.floor(Date.now() / 1000);
+
+  return {
+    id,
+    object: "chat.completion",
+    created,
+    model,
+    choices: [{
+      index: 0,
+      message: {
+        role: "assistant",
+        content: text
+      },
+      finish_reason: "stop"
+    }],
+    usage: {
+      prompt_tokens: 1,
+      completion_tokens: 1,
+      total_tokens: 2
+    }
+  };
+}
+
+function createNonStreamingResponse(sourceFormat, model, text) {
+  const openaiResponse = createOpenAIResponse(model, text);
+
+  if (sourceFormat === FORMATS.OPENAI) {
+    return {
+      success: true,
+      response: new Response(JSON.stringify(openaiResponse), {
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*"
+        }
+      })
+    };
+  }
+
+  const state = initState(sourceFormat);
+  state.model = model;
+
+  const openaiChunks = createOpenAIStreamingChunks(openaiResponse);
+  const allTranslated = [];
+
+  for (const chunk of openaiChunks) {
+    const translated = translateResponse(FORMATS.OPENAI, sourceFormat, chunk, state);
+    if (translated?.length > 0) {
+      allTranslated.push(...translated);
+    }
+  }
+
+  const flushed = translateResponse(FORMATS.OPENAI, sourceFormat, null, state);
+  if (flushed?.length > 0) {
+    allTranslated.push(...flushed);
+  }
+
+  const finalResponse = mergeChunksToResponse(allTranslated, sourceFormat);
+
+  return {
+    success: true,
+    response: new Response(JSON.stringify(finalResponse), {
+      headers: {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*"
+      }
+    })
+  };
+}
+
+function createStreamingResponse(sourceFormat, model, text) {
+  const openaiResponse = createOpenAIResponse(model, text);
+  const state = initState(sourceFormat);
+  state.model = model;
+
+  const openaiChunks = createOpenAIStreamingChunks(openaiResponse);
+
+  const translatedChunks = [];
+
+  for (const chunk of openaiChunks) {
+    const translated = translateResponse(FORMATS.OPENAI, sourceFormat, chunk, state);
+    if (translated?.length > 0) {
+      for (const item of translated) {
+        translatedChunks.push(formatSSE(item, sourceFormat));
+      }
+    }
+  }
+
+  const flushed = translateResponse(FORMATS.OPENAI, sourceFormat, null, state);
+  if (flushed?.length > 0) {
+    for (const item of flushed) {
+      translatedChunks.push(formatSSE(item, sourceFormat));
+    }
+  }
+
+  translatedChunks.push("data: [DONE]\n\n");
+
+  return {
+    success: true,
+    response: new Response(translatedChunks.join(""), {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+        "Access-Control-Allow-Origin": "*"
+      }
+    })
+  };
+}
+
+function mergeChunksToResponse(chunks, sourceFormat) {
+  if (!chunks || chunks.length === 0) {
+    return createOpenAIResponse("unknown");
+  }
+
+  let finalChunk = chunks[chunks.length - 1];
+
+  if (sourceFormat === FORMATS.CLAUDE) {
+    const messageStop = chunks.find(c => c.type === "message_stop");
+    if (messageStop) {
+
+      const contentDelta = chunks.find(c => c.type === "content_block_delta");
+      const messageDelta = chunks.find(c => c.type === "message_delta");
+      const messageStart = chunks.find(c => c.type === "message_start");
+
+      if (messageStart?.message) {
+        finalChunk = messageStart.message;
+
+        const startUsage = messageStart.message.usage;
+        const deltaUsage = messageDelta?.usage;
+        if (startUsage || deltaUsage) {
+          finalChunk.usage = {
+            ...(startUsage || {}),
+            ...(deltaUsage || {}),
+            ...(startUsage?.cache_read_input_tokens !== undefined
+              ? { cache_read_input_tokens: startUsage.cache_read_input_tokens }
+              : {}),
+            ...(startUsage?.cache_creation_input_tokens !== undefined
+              ? { cache_creation_input_tokens: startUsage.cache_creation_input_tokens }
+              : {}),
+            ...(startUsage?.input_tokens !== undefined
+              ? { input_tokens: startUsage.input_tokens }
+              : {})
+          };
+        }
+      }
+    }
+  }
+
+  return finalChunk;
+}
+
+function createOpenAIStreamingChunks(completeResponse) {
+  const { id, created, model, choices } = completeResponse;
+  const content = choices[0].message.content;
+
+  return [
+
+    {
+      id,
+      object: "chat.completion.chunk",
+      created,
+      model,
+      choices: [{
+        index: 0,
+        delta: {
+          role: "assistant",
+          content
+        },
+        finish_reason: null
+      }]
+    },
+
+    {
+      id,
+      object: "chat.completion.chunk",
+      created,
+      model,
+      choices: [{
+        index: 0,
+        delta: {},
+        finish_reason: "stop"
+      }],
+      usage: completeResponse.usage
+    }
+  ];
+}