@rol1n/pi-kit 0.0.0-stage → 0.1.0

package/extensions/ask-u-questions/schema.ts

@@ -0,0 +1,17 @@
+import { Type } from "typebox";
+
+const OptionSchema = Type.Object({
+  label: Type.String({ description: 'Option label. Put a recommended option first and append "(Recommended)".' }),
+  value: Type.Optional(Type.String({ description: "Machine-readable value; defaults to the label." })),
+  description: Type.Optional(Type.String({ description: "Additional context shown below the option." })),
+});
+
+export const AskUserQuestionParams = Type.Object({
+  question: Type.String({ description: "The question to ask. Ask only one question per call." }),
+  details: Type.Optional(Type.String({ description: "Background or instructions shown below the question." })),
+  options: Type.Optional(Type.Array(OptionSchema, {
+    description: "Choices for selection. Omit or pass an empty array for free-text input. An Other choice is always available.",
+  })),
+  multiSelect: Type.Optional(Type.Boolean({ description: "Allow selecting multiple options when true." })),
+});
+

package/extensions/ask-u-questions/single-choice.ts

@@ -0,0 +1,182 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Editor, Key, matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { AskAnswer, AskOption, DisplayOption } from "./types.ts";
+import { getOtherLabel, isChineseContext } from "./answers.ts";
+import { addWrapped, createEditorTheme } from "./dialog-ui.ts";
+
+export async function askSingleChoice(
+  ctx: ExtensionContext,
+  question: string,
+  context: string | undefined,
+  options: AskOption[],
+): Promise<AskAnswer | null> {
+  const isZh = isChineseContext(question, options, context);
+  const otherLabel = getOtherLabel(options, isZh);
+  const allOptions: DisplayOption[] = [
+    ...options.map((option, index) => ({
+      ...option,
+      id: `option:${index}`,
+      index: index + 1,
+    })),
+    { id: "other", label: otherLabel, value: "__other__", isOther: true },
+  ];
+
+  return ctx.ui.custom<AskAnswer | null>(
+    (tui, theme, _kb, done: (result: AskAnswer | null) => void) => {
+      let optionIndex = 0;
+      let editMode = false;
+      let cachedLines: string[] | undefined;
+      let cachedWidth = -1;
+      let componentFocused = false;
+      const editor = new Editor(tui, createEditorTheme(theme));
+
+      editor.onSubmit = (value) => {
+        const trimmed = value.trim();
+        if (!trimmed) return;
+        done({ type: "other", label: trimmed, value: trimmed });
+      };
+
+      function refresh() {
+        cachedLines = undefined;
+        tui.requestRender();
+      }
+
+      function handleInput(data: string) {
+        if (editMode) {
+          if (matchesKey(data, Key.escape)) {
+            editMode = false;
+            editor.focused = false;
+            editor.setText("");
+            refresh();
+            return;
+          }
+          editor.handleInput(data);
+          refresh();
+          return;
+        }
+
+        if (matchesKey(data, Key.up)) {
+          optionIndex = Math.max(0, optionIndex - 1);
+          refresh();
+          return;
+        }
+        if (matchesKey(data, Key.down)) {
+          optionIndex = Math.min(allOptions.length - 1, optionIndex + 1);
+          refresh();
+          return;
+        }
+        if (matchesKey(data, Key.enter)) {
+          const selected = allOptions[optionIndex];
+          if (selected.isOther) {
+            editMode = true;
+            editor.focused = componentFocused;
+            editor.setText("");
+            refresh();
+            return;
+          }
+          done({
+            type: "option",
+            label: selected.label,
+            value: selected.value,
+            index: selected.index!,
+          });
+          return;
+        }
+        if (matchesKey(data, Key.escape)) {
+          done(null);
+        }
+      }
+
+      function render(width: number): string[] {
+        if (cachedLines && cachedWidth === width) return cachedLines;
+
+        const lines: string[] = [];
+        const add = (text: string) => lines.push(truncateToWidth(text, width));
+
+        add(theme.fg("accent", "─".repeat(width)));
+
+        if (editMode) {
+          addWrapped(lines, question, width, " ", " ", (l) => theme.fg("text", theme.bold(l)));
+          if (context) {
+            addWrapped(lines, context, width, " ", " ", (l) => theme.fg("muted", l));
+          }
+          lines.push("");
+          const header = allOptions[optionIndex]?.label || otherLabel;
+          add(theme.fg("accent", ` > ${header}:`));
+          for (const line of editor.render(Math.max(1, width - 4))) {
+            add(`   ${line}`);
+          }
+          lines.push("");
+          const editHint = isZh
+            ? " Enter 提交 • Esc 返回选项"
+            : " Enter to submit • Esc to return";
+          add(theme.fg("dim", editHint));
+          add(theme.fg("accent", "─".repeat(width)));
+          cachedLines = lines;
+          cachedWidth = width;
+          return lines;
+        }
+
+        addWrapped(lines, question, width, " ", " ", (l) => theme.fg("text", theme.bold(l)));
+        if (context) {
+          addWrapped(lines, context, width, " ", " ", (l) => theme.fg("muted", l));
+        }
+        lines.push("");
+
+        for (let i = 0; i < allOptions.length; i++) {
+          const item = allOptions[i];
+          const selected = i === optionIndex;
+          const prefix = selected ? theme.fg("accent", " > ") : "   ";
+
+          if (item.isOther) {
+            const styledLabel = selected
+              ? theme.bold(theme.fg("accent", item.label))
+              : theme.fg("text", item.label);
+            lines.push(truncateToWidth(`${prefix}${styledLabel}`, width));
+          } else {
+            const numPrefix = `${item.index}. `;
+            const firstIndent = `${prefix}${selected ? theme.fg("accent", numPrefix) : numPrefix}`;
+            const restIndent = " ".repeat(visibleWidth(firstIndent));
+            const styleLabel = (l: string) =>
+              selected ? theme.bold(theme.fg("accent", l)) : theme.fg("text", l);
+
+            addWrapped(lines, item.label, width, firstIndent, restIndent, styleLabel);
+
+            if (item.description) {
+              const descIndent = " ".repeat(visibleWidth(firstIndent));
+              const descStyle = (l: string) => theme.fg("muted", l);
+              addWrapped(lines, item.description, width, descIndent, descIndent, descStyle);
+            }
+          }
+        }
+
+        lines.push("");
+        const navHint = isZh
+          ? " ↑↓ 选择 • Enter 确定 • Esc 取消"
+          : " ↑↓ to navigate • Enter to select • Esc to cancel";
+        add(theme.fg("dim", navHint));
+        add(theme.fg("accent", "─".repeat(width)));
+
+        cachedLines = lines;
+        cachedWidth = width;
+        return lines;
+      }
+
+      return {
+        render,
+        invalidate: () => {
+          cachedLines = undefined;
+        },
+        handleInput,
+        get focused(): boolean {
+          return componentFocused;
+        },
+        set focused(value: boolean) {
+          componentFocused = value;
+          editor.focused = editMode && componentFocused;
+        },
+      };
+    },
+  );
+}
+

package/extensions/ask-u-questions/tool-renderers.ts

@@ -0,0 +1,69 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import type { AskUserQuestionParams } from "./schema.ts";
+import type { AskUserQuestionResultDetails } from "./types.ts";
+import { getOtherLabel, isChineseContext, normalizeOptions } from "./answers.ts";
+
+export const questionRenderers: Pick<ToolDefinition<typeof AskUserQuestionParams, AskUserQuestionResultDetails>, "renderCall" | "renderResult"> = {
+  renderCall(args, theme, context) {
+    const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+    const options = normalizeOptions(
+      args.options as Array<{ label: string; value?: string; description?: string }> | undefined,
+    );
+    const isZh = isChineseContext(args.question || "", options, args.details);
+    let summary =
+      theme.fg("toolTitle", theme.bold("ask_user_question ")) +
+      theme.fg("accent", `"${args.question || ""}"`);
+    if (args.multiSelect) {
+      summary += theme.fg("dim", " [multi-select]");
+    }
+    if (options.length > 0) {
+      const otherLbl = getOtherLabel(options, isZh);
+      const labels = [...options.map((option) => option.label), otherLbl].join(", ");
+      const optPrefix = isZh ? "  选项: " : "  Options: ";
+      summary += `\n${theme.fg("dim", `${optPrefix}${labels}`)}`;
+    }
+    text.setText(summary);
+    return text;
+  },
+
+  renderResult(result, _options, theme, context) {
+    const text = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+    const details = result.details as AskUserQuestionResultDetails | undefined;
+    if (!details) {
+      const first = result.content?.[0];
+      text.setText(first?.type === "text" ? first.text : "");
+      return text;
+    }
+
+    const isZh = isChineseContext(details.question || "", details.answers, details.context);
+
+    if (details.status === "cancelled") {
+      const defaultCancelled = isZh ? "已取消" : "Cancelled";
+      text.setText(theme.fg("warning", `⊘ ${details.message || defaultCancelled}`));
+      return text;
+    }
+
+    if (details.status === "unavailable") {
+      const defaultUnavailable = isZh ? "提问工具不可用" : "Tool unavailable";
+      text.setText(theme.fg("error", `! ${details.message || defaultUnavailable}`));
+      return text;
+    }
+
+    const emptyText = isZh ? "(空回答)" : "(empty)";
+    const otherPrefix = isZh ? "其他：" : "Other: ";
+
+    const lines = details.answers.map((answer) => {
+      switch (answer.type) {
+        case "text":
+          return `${theme.fg("success", "✓ ")}${theme.fg("accent", answer.label || emptyText)}`;
+        case "other":
+          return `${theme.fg("success", "✓ ")}${theme.fg("muted", otherPrefix)}${theme.fg("accent", answer.label)}`;
+        case "option":
+          return `${theme.fg("success", "✓ ")}${theme.fg("accent", `${answer.index}. ${answer.label}`)}`;
+      }
+    });
+    text.setText(lines.join("\n"));
+    return text;
+  },
+};

package/extensions/ask-u-questions/types.ts

@@ -0,0 +1,45 @@
+export interface AskOption {
+  label: string;
+  value: string;
+  description?: string;
+}
+
+export interface DisplayOption extends AskOption {
+  id: string;
+  index?: number;
+  isOther?: boolean;
+  isSubmit?: boolean;
+}
+
+export interface TextAnswer {
+  type: "text";
+  label: string;
+  value: string;
+}
+
+export interface OptionAnswer {
+  type: "option";
+  label: string;
+  value: string;
+  index: number;
+}
+
+export interface OtherAnswer {
+  type: "other";
+  label: string;
+  value: string;
+}
+
+export type AskAnswer = TextAnswer | OptionAnswer | OtherAnswer;
+export type AskUserQuestionStatus = "answered" | "cancelled" | "unavailable";
+export type AskUserQuestionMode = "text" | "single-select" | "multi-select";
+
+export interface AskUserQuestionResultDetails {
+  status: AskUserQuestionStatus;
+  question: string;
+  context?: string;
+  mode: AskUserQuestionMode;
+  answers: AskAnswer[];
+  message?: string;
+}
+

package/extensions/ask-u-questions/ui-lock.ts

@@ -0,0 +1,24 @@
+const SHARED_UI_LOCK_KEY = "__piSharedUiLock";
+function getSharedUiLock(): { withLock<T>(fn: () => T | Promise<T>): Promise<T> } {
+  const g = globalThis as any;
+  if (!g[SHARED_UI_LOCK_KEY]) {
+    let chain: Promise<void> = Promise.resolve();
+    g[SHARED_UI_LOCK_KEY] = {
+      withLock<T>(fn: () => T | Promise<T>): Promise<T> {
+        const prev = chain;
+        let release: () => void;
+        chain = new Promise<void>((r) => {
+          release = r;
+        });
+        return prev.then(fn).finally(() => release!());
+      },
+    };
+  }
+  return g[SHARED_UI_LOCK_KEY];
+}
+const sharedUiLock = getSharedUiLock();
+
+export function withUILock<T>(fn: () => Promise<T>): Promise<T> {
+  return sharedUiLock.withLock(fn);
+}
+

package/extensions/continue-signal/README.md

@@ -0,0 +1,28 @@
+# continue-signal
+
+Resume an idle Pi agent with a visible continuation signal.
+
+## Install
+
+```sh
+pi install npm:@rol1n/continue-signal
+```
+
+Also included in `@rol1n/pi-kit`.
+
+## Commands
+
+| Action | Command or shortcut |
+|---|---|
+| Resume unfinished work | `/continue` or Alt+C |
+| Resume with a specific instruction | `/continue Review the remaining test failures` |
+
+An explicit command argument takes priority. Without one, the extension uses and clears the current editor draft. If the draft is empty, it asks the agent to review the conversation and resume unfinished work. It leaves an already-running agent alone.
+
+## Configuration
+
+No settings or credentials are needed. The shortcut requires a terminal that forwards Alt+C. This extension starts a new agent turn; it does not reconstruct a lost session or restart a crashed process.
+
+## Source layout
+
+`index.ts` registers the command and shortcut and sends continuation messages. `renderer.ts` owns the visible signal card.

package/extensions/continue-signal/index.ts

@@ -0,0 +1,51 @@
+/**
+ * continue-signal — Resume an idle agent via /continue [prompt] or Alt+C.
+ * Uses the editor draft when no prompt is supplied.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Key } from "@earendil-works/pi-tui";
+import { renderContinueSignal } from "./renderer.ts";
+
+const DEFAULT_PROMPT = "Review the conversation context and resume any unfinished work from where it stopped.";
+const CUSTOM_TYPE = "continue-signal";
+
+export default function (pi: ExtensionAPI) {
+  pi.registerMessageRenderer(CUSTOM_TYPE, renderContinueSignal);
+
+  const triggerContinue = (ctx: ExtensionContext, customPrompt = "") => {
+    if (!ctx.isIdle()) {
+      ctx.ui.notify("Agent is currently running; no need to wake up.", "warning");
+      return;
+    }
+
+    let prompt = customPrompt.trim();
+    if (!prompt) {
+      const draft = ctx.ui.getEditorText?.()?.trim();
+      if (draft) {
+        prompt = draft;
+        ctx.ui.setEditorText?.("");
+      }
+    }
+
+    pi.sendMessage(
+      {
+        customType: CUSTOM_TYPE,
+        content: prompt || DEFAULT_PROMPT,
+        display: true,
+        details: { timestamp: Date.now() },
+      },
+      { triggerTurn: true, deliverAs: "steer" },
+    );
+  };
+
+  pi.registerCommand("continue", {
+    description: "Send a resume signal to continue unfinished work (optional prompt)",
+    handler: (args, ctx) => triggerContinue(ctx, args),
+  });
+
+  pi.registerShortcut(Key.alt("c"), {
+    description: "Resume unfinished work",
+    handler: (ctx) => triggerContinue(ctx),
+  });
+}

package/extensions/continue-signal/renderer.ts

@@ -0,0 +1,21 @@
+import type { MessageRenderer } from "@earendil-works/pi-coding-agent";
+import { Box, Text } from "@earendil-works/pi-tui";
+
+export const renderContinueSignal: MessageRenderer<{ timestamp?: number }> = (
+  message,
+  { expanded, outputPad },
+  theme,
+) => {
+  const time = new Date(message.details?.timestamp ?? Date.now()).toLocaleTimeString();
+  const title = `${theme.bold(theme.fg("accent", "⚡ LOOP RESUME SIGNAL"))} ${theme.fg("muted", `[${time}]`)}`;
+
+  const box = new Box(outputPad, 1, (text) => theme.bg("customMessageBg", text));
+  box.addChild(new Text(title, 0, 0));
+  box.addChild(new Text(theme.fg("text", "Re-linking conversation context & resuming agent loop..."), 0, 0));
+
+  if (expanded && message.content) {
+    box.addChild(new Text(theme.fg("dim", `Prompt: ${message.content}`), 0, 0));
+  }
+
+  return box;
+};

package/extensions/custom-providers/README.md

@@ -0,0 +1,28 @@
+# custom-providers
+
+Register additional model providers through Pi's native model registry and login interface. Chat, image, classifier, and ASR definitions are organized by model type.
+
+## Install
+
+```sh
+pi install npm:@rol1n/custom-providers
+```
+
+Also included in `@rol1n/pi-kit`. Open Pi's model selector after provider registration and authenticate only the providers you use.
+
+## Provider configuration
+
+| Provider | Configuration |
+|---|---|
+| Magpie | `MAGPIE_BASE_URL` selects the gateway; `MAGPIE_GATEWAY_KEY` or `/login magpie` supplies its gateway key |
+| SHUAI API | `/login shuaiapi`; chat catalog and endpoint are declared in `chat/` |
+| BigModel | `/login bigmodel`; chat catalog and endpoint are declared in `chat/` |
+| DashScope | `/login dashscope`; custom chat/image definitions and ASR model helpers |
+
+Magpie defaults to `http://127.0.0.1:3425/v1`. Set `MAGPIE_BASE_URL` before starting Pi when your gateway runs elsewhere. Model discovery preserves supported native protocols rather than treating every discovered model as OpenAI chat completions. System One classification delegates to the host Pi implementation.
+
+`DASHSCOPE_IMAGE_URL` can override the DashScope image API base URL; its default is `https://dashscope.aliyuncs.com/api/v1`. OpenRouter's image catalog belongs to Pi's built-in provider and is not registered again here. The dedicated `classifier/` catalog is currently reserved; Magpie discovers classifier models dynamically.
+
+## Related packages
+
+[image-generate](https://github.com/RolinShmily/pi-kit/tree/main/extensions/image-generate) provides the image-generation tool. [tui-asr](https://github.com/RolinShmily/pi-kit/tree/main/extensions/tui-asr) provides dictation. Their shared helper files do not independently register this provider extension. Store credentials through Pi or environment variables rather than editing source files.

package/extensions/custom-providers/asr/handlers/dashscope.ts

@@ -0,0 +1,154 @@
+import { randomUUID } from "node:crypto";
+import type { StreamingAsrProvider, VoiceCallbacks } from "../types.ts";
+
+export class DashscopeAsrProvider implements StreamingAsrProvider {
+  private ws: WebSocket | null = null;
+  private taskId: string = "";
+  private lastSentenceMap = new Map<number, string>();
+  private isCancelled = false;
+
+  constructor(
+    private model: string,
+    private apiKey: string,
+  ) {}
+
+  async start(callbacks: VoiceCallbacks): Promise<void> {
+    this.isCancelled = false;
+    if (!this.apiKey) {
+      throw new Error("DashScope API Key not found. Please run /login dashscope or set DASHSCOPE_API_KEY environment variable.");
+    }
+
+    this.taskId = randomUUID().replace(/-/g, "");
+    this.lastSentenceMap.clear();
+
+    const url = "wss://dashscope.aliyuncs.com/api-ws/v1/inference/";
+    const ws = new WebSocket(url, {
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+    } as any);
+    this.ws = ws;
+
+    return new Promise((resolve, reject) => {
+      let taskStarted = false;
+
+      ws.addEventListener("open", () => {
+        if (this.isCancelled) return;
+        const startMsg = {
+          header: {
+            action: "run-task",
+            task_id: this.taskId,
+            streaming: "duplex",
+          },
+          payload: {
+            task_group: "audio",
+            task: "asr",
+            function: "recognition",
+            model: this.model,
+            parameters: {
+              format: "pcm",
+              sample_rate: 16000,
+            },
+            input: {},
+          },
+        };
+        try {
+          ws.send(JSON.stringify(startMsg));
+        } catch {}
+      });
+
+      ws.addEventListener("message", (ev) => {
+        if (this.isCancelled) return;
+        try {
+          const msg = JSON.parse(ev.data as string);
+          const header = msg.header;
+          if (header?.event === "task-started") {
+            taskStarted = true;
+            resolve();
+          } else if (header?.event === "result-generated") {
+            const sentences = msg.payload?.output?.sentence;
+            if (Array.isArray(sentences)) {
+              for (let i = 0; i < sentences.length; i++) {
+                const s = sentences[i];
+                if (s?.text && s.end_time !== undefined) {
+                  if (!this.lastSentenceMap.has(i)) {
+                    this.lastSentenceMap.set(i, s.text);
+                    callbacks.onFinal(s.text.trim());
+                  }
+                }
+              }
+            }
+          } else if (header?.event === "task-finished") {
+            const sentences = msg.payload?.output?.sentence;
+            if (Array.isArray(sentences)) {
+              for (let i = 0; i < sentences.length; i++) {
+                const s = sentences[i];
+                if (s?.text && !this.lastSentenceMap.has(i)) {
+                  this.lastSentenceMap.set(i, s.text);
+                  callbacks.onFinal(s.text.trim());
+                }
+              }
+            }
+            callbacks.onClose();
+          } else if (header?.event === "task-failed") {
+            const err = new Error(header.error_message || "DashScope ASR task failed");
+            if (!taskStarted) reject(err);
+            else callbacks.onError(err);
+          }
+        } catch {}
+      });
+
+      ws.addEventListener("error", () => {
+        if (this.isCancelled) return;
+        const err = new Error("DashScope WebSocket connection error");
+        if (!taskStarted) reject(err);
+        else callbacks.onError(err);
+      });
+
+      ws.addEventListener("close", () => {
+        if (this.isCancelled) return;
+        callbacks.onClose();
+      });
+    });
+  }
+
+  sendAudio(chunk: Buffer): void {
+    if (!this.isCancelled && this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(chunk);
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (!this.isCancelled && this.ws && this.ws.readyState === WebSocket.OPEN && this.taskId) {
+      try {
+        const finishMsg = {
+          header: {
+            action: "finish-task",
+            task_id: this.taskId,
+            streaming: "duplex",
+          },
+          payload: {
+            input: {},
+          },
+        };
+        this.ws.send(JSON.stringify(finishMsg));
+      } catch {}
+    }
+  }
+
+  cancel(): void {
+    this.isCancelled = true;
+    if (this.ws) {
+      try {
+        if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+          this.ws.close();
+        }
+      } catch {}
+      this.ws = null;
+    }
+  }
+}
+
+export function createDashscopeAsrProvider(modelId: string, apiKey: string): StreamingAsrProvider {
+  return new DashscopeAsrProvider(modelId, apiKey);
+}

package/extensions/custom-providers/asr/index.ts

@@ -0,0 +1,37 @@
+import { DASHSCOPE_ASR_MODELS } from "./models.ts";
+import { createDashscopeAsrProvider } from "./handlers/dashscope.ts";
+import type { AsrModelDefinition, StreamingAsrProvider } from "./types.ts";
+
+export * from "./types.ts";
+export * from "./models.ts";
+export * from "./handlers/dashscope.ts";
+
+export interface AsrProviderConfig {
+  name: string;
+  models: AsrModelDefinition[];
+  createProvider: (modelId: string, apiKey: string) => StreamingAsrProvider;
+}
+
+export const asrProviders: Record<string, AsrProviderConfig> = {
+  dashscope: {
+    name: "Aliyun DashScope",
+    models: DASHSCOPE_ASR_MODELS,
+    createProvider: createDashscopeAsrProvider,
+  },
+};
+
+export const ALL_ASR_MODELS: AsrModelDefinition[] = [
+  ...DASHSCOPE_ASR_MODELS,
+];
+
+export function createAsrProvider(
+  providerId: string,
+  modelId: string,
+  apiKey: string,
+): StreamingAsrProvider {
+  const provider = asrProviders[providerId];
+  if (!provider) {
+    throw new Error(`Unsupported ASR provider: ${providerId}`);
+  }
+  return provider.createProvider(modelId, apiKey);
+}

package/extensions/custom-providers/asr/models.ts

@@ -0,0 +1,18 @@
+import type { AsrModelDefinition } from "./types.ts";
+
+export const DASHSCOPE_ASR_MODELS: AsrModelDefinition[] = [
+  {
+    id: "paraformer-realtime-v2",
+    name: "Paraformer Realtime v2",
+    provider: "dashscope",
+    description: "Real-time speech recognition with high-accuracy punctuation and sentence segmentation (recommended).",
+    sampleRate: 16000,
+  },
+  {
+    id: "paraformer-8k-realtime-v1",
+    name: "Paraformer 8k Realtime v1",
+    provider: "dashscope",
+    description: "8k narrowband telephony real-time speech recognition.",
+    sampleRate: 8000,
+  },
+];