Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

6.4 KB
Raw Blame
const test = require("node:test");
const assert = require("node:assert/strict");

const { createRendererServer, installBrowserGlobals } = require("../lib/rendererTestHarness");

// Mirrors the BYOK/local "tool-result" branch of ReasoningService.processTextStreamingAI:
// a successful tool's object/array output must be forwarded as `metadata` on the
// yielded `tool_result` chunk (the way the OpenWhispr Cloud path already does), so
// tool-result cards (e.g. note cards) render for BYOK and local models too.

function createOpenAiChunk(delta, finishReason = null) {
  return {
    id: "chatcmpl-tool-metadata-test",
    object: "chat.completion.chunk",
    created: 1,
    model: "qwen3-4b-q4_k_m",
    choices: [{ index: 0, delta, finish_reason: finishReason }],
  };
}

function createOpenAiSseResponse(chunks, { finishReason = "stop", toolCall } = {}) {
  const events = chunks
    .map((content) => `data: ${JSON.stringify(createOpenAiChunk({ content }))}\n\n`)
    .join("");
  const toolEvent = toolCall
    ? `data: ${JSON.stringify(
        createOpenAiChunk({
          tool_calls: [
            {
              index: 0,
              id: toolCall.id,
              type: "function",
              function: { name: toolCall.name, arguments: toolCall.arguments },
            },
          ],
        })
      )}\n\n`
    : "";
  const finishEvent = `data: ${JSON.stringify(createOpenAiChunk({}, finishReason))}\n\n`;
  return new Response(`${events}${toolEvent}${finishEvent}data: [DONE]\n\n`, {
    status: 200,
    headers: { "content-type": "text/event-stream" },
  });
}

async function loadReasoningService(t, cachePrefix) {
  installBrowserGlobals(t);
  const vite = await createRendererServer(t, { cachePrefix });
  const reasoningService = (await vite.ssrLoadModule("/services/ReasoningService.ts")).default;
  const { usePolicyStore } = await vite.ssrLoadModule("/stores/policyStore.ts");
  usePolicyStore.setState({ status: "unmanaged", appVersion: "1.8.3", policy: null });
  t.after(() => reasoningService.destroy());
  return { reasoningService, vite };
}

async function collectAllChunks(stream) {
  const chunks = [];
  for await (const chunk of stream) chunks.push(chunk);
  return chunks;
}

async function runToolMetadataScenario(t, cachePrefix, toolExecute, calledTool = "test_tool") {
  const { reasoningService, vite } = await loadReasoningService(t, cachePrefix);
  const { ToolRegistry } = await vite.ssrLoadModule("/services/tools/ToolRegistry.ts");
  const registry = new ToolRegistry();
  registry.register({
    name: "test_tool",
    description: "Test tool",
    parameters: { type: "object", properties: {}, additionalProperties: false },
    readOnly: true,
    execute: toolExecute,
  });

  const originalFetch = globalThis.fetch;
  t.after(() => {
    globalThis.fetch = originalFetch;
  });
  let fetchCalls = 0;
  globalThis.fetch = async () => {
    fetchCalls += 1;
    if (fetchCalls === 1) {
      return createOpenAiSseResponse([], {
        finishReason: "tool_calls",
        toolCall: { id: "call-test", name: calledTool, arguments: "{}" },
      });
    }
    return createOpenAiSseResponse(["Answer"]);
  };

  const stream = reasoningService.processTextStreamingAI(
    [{ role: "user", content: "hello" }],
    "qwen3-4b-q4_k_m",
    "lan",
    {
      systemPrompt: "Answer the user.",
      lanUrl: "http://127.0.0.1:11434/v1",
      disableThinking: true,
    },
    registry.toAISDKFormat()
  );

  const chunks = await collectAllChunks(stream);
  const toolResult = chunks.find((chunk) => chunk.type === "tool_result");
  assert.ok(toolResult, "expected a tool_result chunk");
  return toolResult;
}

test("a successful object tool output is forwarded as metadata", async (t) => {
  const toolResult = await runToolMetadataScenario(
    t,
    "openwhispr-tool-metadata-object-test-",
    async () => ({
      success: true,
      data: { id: 42, title: "Q3 notes" },
      displayText: "Created note",
    })
  );

  assert.deepEqual(toolResult.metadata, { id: 42, title: "Q3 notes" });
});

test("a successful array tool output (search results) is forwarded as metadata", async (t) => {
  const results = [
    { id: 1, title: "First" },
    { id: 2, title: "Second" },
  ];
  const toolResult = await runToolMetadataScenario(
    t,
    "openwhispr-tool-metadata-array-test-",
    async () => ({
      success: true,
      data: results,
      displayText: "Found 2 notes",
    })
  );

  assert.deepEqual(toolResult.metadata, results);
});

test("a failed tool output yields no metadata and keeps the error as displayText", async (t) => {
  const toolResult = await runToolMetadataScenario(
    t,
    "openwhispr-tool-metadata-error-test-",
    async () => ({
      success: false,
      data: null,
      displayText: "Something failed",
    })
  );

  assert.equal(toolResult.metadata, undefined);
  assert.equal(toolResult.displayText, "Something failed");
});

test("a connector's failed result is still metadata, so its outcome reaches later turns", async (t) => {
  // Connector results always succeed and carry their own `error` beside the status;
  // only the registry's bare { error } wrapper means the tool itself failed.
  const failed = { status: "failed", errorCode: "network", error: "Couldn't reach Slack" };
  const toolResult = await runToolMetadataScenario(
    t,
    "openwhispr-tool-metadata-connector-failed-test-",
    async () => ({ success: true, data: failed, displayText: "That didn't work." })
  );

  assert.deepEqual(toolResult.metadata, failed);
});

test("a successful string tool output yields no metadata", async (t) => {
  const toolResult = await runToolMetadataScenario(
    t,
    "openwhispr-tool-metadata-string-test-",
    async () => ({
      success: true,
      data: "plain string result",
      displayText: "Done",
    })
  );

  assert.equal(toolResult.metadata, undefined);
  assert.equal(toolResult.displayText, "plain string result");
});

test("a call the SDK rejects still settles, with its error as displayText", async (t) => {
  let executed = false;
  const toolResult = await runToolMetadataScenario(
    t,
    "openwhispr-tool-metadata-rejected-test-",
    async () => {
      executed = true;
      return { success: true, data: "unreachable", displayText: "Done" };
    },
    "ghost_tool"
  );

  assert.equal(executed, false);
  assert.equal(toolResult.callId, "call-test");
  assert.equal(toolResult.toolName, "ghost_tool");
  assert.match(toolResult.displayText, /^Error: .*ghost_tool/);
  assert.equal(toolResult.metadata, undefined);
});