plasalid 0.7.9 → 0.8.1

package/dist/ai/providers/openai-shared.d.ts

@@ -0,0 +1,26 @@
+import OpenAI from "openai";
+import type { NormalizedResponse, NormalizedContentBlock, NormalizedMessage, NormalizedToolResult, ToolDefinition } from "../provider.js";
+export type ChatCompletion = OpenAI.Chat.Completions.ChatCompletion;
+type RequestOptions = Parameters<OpenAI["chat"]["completions"]["create"]>[1];
+export interface CompletionBody {
+    model: string;
+    maxTokens: number;
+    messages: OpenAI.ChatCompletionMessageParam[];
+    tools: OpenAI.ChatCompletionTool[] | undefined;
+}
+/**
+ * Older models accept `max_tokens`; o-series / gpt-5+ require
+ * `max_completion_tokens`. Try the former, fall back on the 400.
+ */
+export declare function createCompletionWithTokenFallback(client: OpenAI, body: CompletionBody, options: RequestOptions): Promise<ChatCompletion>;
+export declare function normalizeResponse(response: ChatCompletion): NormalizedResponse;
+export declare function convertTools(tools: ToolDefinition[]): OpenAI.ChatCompletionTool[];
+/**
+ * Throw on malformed JSON so truncated tool args surface as an error instead
+ * of being silently coerced to `{}` (which would record zero transactions).
+ */
+export declare function parseArguments(toolName: string, args: string): unknown;
+export declare function convertToolResults(toolResults: NormalizedToolResult[]): OpenAI.ChatCompletionToolMessageParam[];
+export declare function convertAssistantMessage(blocks: NormalizedContentBlock[]): OpenAI.ChatCompletionAssistantMessageParam;
+export declare function isToolResultEnvelope(content: NormalizedMessage["content"]): content is NormalizedToolResult[];
+export {};

package/dist/ai/providers/openai-shared.js

@@ -0,0 +1,118 @@
+function isMaxTokensRejection(e) {
+    const err = e;
+    return err.status === 400 && (err.message?.includes("max_tokens") ?? false);
+}
+/**
+ * Older models accept `max_tokens`; o-series / gpt-5+ require
+ * `max_completion_tokens`. Try the former, fall back on the 400.
+ */
+export async function createCompletionWithTokenFallback(client, body, options) {
+    const base = {
+        model: body.model,
+        messages: body.messages,
+        tools: body.tools,
+    };
+    try {
+        return await client.chat.completions.create({ ...base, max_tokens: body.maxTokens }, options);
+    }
+    catch (e) {
+        if (isMaxTokensRejection(e)) {
+            return await client.chat.completions.create({ ...base, max_completion_tokens: body.maxTokens }, options);
+        }
+        throw e;
+    }
+}
+export function normalizeResponse(response) {
+    const choice = response.choices[0];
+    if (!choice) {
+        return { content: [], stopReason: "end_turn" };
+    }
+    const content = [];
+    if (choice.message.content) {
+        content.push({ type: "text", text: choice.message.content });
+    }
+    if (choice.message.tool_calls) {
+        for (const tc of choice.message.tool_calls) {
+            if (tc.type !== "function")
+                continue;
+            content.push({
+                type: "tool_use",
+                id: tc.id,
+                name: tc.function.name,
+                input: parseArguments(tc.function.name, tc.function.arguments),
+            });
+        }
+    }
+    const hasToolCalls = content.some((b) => b.type === "tool_use");
+    /**
+     * finish_reason "length" → "max_tokens" so the agent loop records a
+     * scan_truncated question instead of silently accepting a partial batch.
+     */
+    const stopReason = choice.finish_reason === "length"
+        ? "max_tokens"
+        : hasToolCalls
+            ? "tool_use"
+            : "end_turn";
+    return {
+        content,
+        stopReason,
+        usage: response.usage
+            ? { input_tokens: response.usage.prompt_tokens, output_tokens: response.usage.completion_tokens }
+            : undefined,
+    };
+}
+export function convertTools(tools) {
+    return tools.map((t) => ({
+        type: "function",
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.input_schema,
+        },
+    }));
+}
+/**
+ * Throw on malformed JSON so truncated tool args surface as an error instead
+ * of being silently coerced to `{}` (which would record zero transactions).
+ */
+export function parseArguments(toolName, args) {
+    if (typeof args !== "string")
+        return args;
+    try {
+        return JSON.parse(args);
+    }
+    catch {
+        const preview = args.length > 120 ? `${args.slice(0, 120)}…` : args;
+        throw new Error(`Tool call arguments for "${toolName}" were not valid JSON (likely truncated by max_tokens): ${preview}`);
+    }
+}
+export function convertToolResults(toolResults) {
+    return toolResults.map((tr) => ({
+        role: "tool",
+        tool_call_id: tr.tool_use_id,
+        content: tr.content,
+    }));
+}
+export function convertAssistantMessage(blocks) {
+    const textParts = blocks
+        .filter((b) => b.type === "text")
+        .map((b) => b.text)
+        .join("\n");
+    const toolCalls = blocks
+        .filter((b) => b.type === "tool_use")
+        .map((tu) => ({
+        id: tu.id,
+        type: "function",
+        function: { name: tu.name, arguments: JSON.stringify(tu.input) },
+    }));
+    return {
+        role: "assistant",
+        content: textParts || null,
+        ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+    };
+}
+export function isToolResultEnvelope(content) {
+    return (Array.isArray(content) &&
+        content.length > 0 &&
+        content[0].type === "tool_result");
+}

package/dist/ai/providers/openai.d.ts

@@ -1,5 +1,29 @@
-import type { Provider } from "../provider.js";
-export declare function createOpenAICompatibleProvider(opts: {
+import OpenAI from "openai";
+import type { Provider, NormalizedResponse, NormalizedContentBlock, NormalizedMessage, NormalizedToolResult, ToolDefinition } from "../provider.js";
+export type ChatCompletion = OpenAI.Chat.Completions.ChatCompletion;
+type RequestOptions = Parameters<OpenAI["chat"]["completions"]["create"]>[1];
+export interface CompletionBody {
+    model: string;
+    maxTokens: number;
+    messages: OpenAI.ChatCompletionMessageParam[];
+    tools: OpenAI.ChatCompletionTool[] | undefined;
+}
+export declare function createOpenAIProvider(opts: {
     apiKey: string;
-    baseURL: string;
 }): Provider;
+/**
+ * Older models accept `max_tokens`; o-series / gpt-5+ require
+ * `max_completion_tokens`. Try the former, fall back on the 400.
+ */
+export declare function createCompletionWithTokenFallback(client: OpenAI, body: CompletionBody, options: RequestOptions): Promise<ChatCompletion>;
+export declare function normalizeResponse(response: ChatCompletion): NormalizedResponse;
+export declare function convertTools(tools: ToolDefinition[]): OpenAI.ChatCompletionTool[];
+/**
+ * Throw on malformed JSON so truncated tool args surface as an error instead
+ * of being silently coerced to `{}` (which would record zero transactions).
+ */
+export declare function parseArguments(toolName: string, args: string): unknown;
+export declare function convertToolResults(toolResults: NormalizedToolResult[]): OpenAI.ChatCompletionToolMessageParam[];
+export declare function convertAssistantMessage(blocks: NormalizedContentBlock[]): OpenAI.ChatCompletionAssistantMessageParam;
+export declare function isToolResultEnvelope(content: NormalizedMessage["content"]): content is NormalizedToolResult[];
+export {};

package/dist/ai/providers/openai.js

@@ -1,38 +1,15 @@
 import OpenAI from "openai";
 import { classifyProviderError } from "../errors.js";
-function isMaxTokensRejection(e) {
-    const err = e;
-    return err.status === 400 && (err.message?.includes("max_tokens") ?? false);
-}
-/**
- * Some OpenAI-compatible endpoints (older models, Ollama, vLLM) accept `max_tokens`;
- * newer OpenAI models require `max_completion_tokens`. Try the former, fall back on a
- * 400 that explicitly names the parameter.
- */
-async function createCompletionWithTokenFallback(client, body, options) {
-    const base = {
-        model: body.model,
-        messages: body.messages,
-        tools: body.tools,
-    };
-    try {
-        return await client.chat.completions.create({ ...base, max_tokens: body.maxTokens }, options);
-    }
-    catch (e) {
-        if (isMaxTokensRejection(e)) {
-            return await client.chat.completions.create({ ...base, max_completion_tokens: body.maxTokens }, options);
-        }
-        throw e;
-    }
-}
-export function createOpenAICompatibleProvider(opts) {
+const OPENAI_BASE_URL = "https://api.openai.com/v1";
+export function createOpenAIProvider(opts) {
     const client = new OpenAI({
         apiKey: opts.apiKey,
-        baseURL: opts.baseURL,
+        baseURL: OPENAI_BASE_URL,
     });
     return {
-        name: "openai-compatible",
+        name: "openai",
         supportsThinking: false,
+        acceptsDocuments: true,
         async sendMessage(params) {
             const tools = convertTools(params.tools);
             const body = {
@@ -52,7 +29,94 @@ export function createOpenAICompatibleProvider(opts) {
         },
     };
 }
-function normalizeResponse(response) {
+function convertMessages(system, messages) {
+    const result = [
+        { role: "system", content: system },
+    ];
+    for (const msg of messages) {
+        if (msg.role === "user") {
+            if (isToolResultEnvelope(msg.content)) {
+                result.push(...convertToolResults(msg.content));
+            }
+            else if (Array.isArray(msg.content)) {
+                result.push(buildUserMessage(msg.content));
+            }
+            else {
+                result.push({ role: "user", content: msg.content });
+            }
+        }
+        else {
+            if (Array.isArray(msg.content)) {
+                result.push(convertAssistantMessage(msg.content));
+            }
+            else {
+                result.push({ role: "assistant", content: msg.content });
+            }
+        }
+    }
+    return result;
+}
+/** Real OpenAI accepts `file` parts for PDFs and `image_url` for images. */
+function buildUserMessage(blocks) {
+    const hasAttachment = blocks.some((b) => b.type === "document" || b.type === "image");
+    if (!hasAttachment) {
+        const text = blocks
+            .filter((b) => b.type === "text")
+            .map((b) => b.text)
+            .join("\n");
+        return { role: "user", content: text };
+    }
+    const parts = [];
+    for (const block of blocks) {
+        if (block.type === "text") {
+            parts.push({ type: "text", text: block.text });
+        }
+        else if (block.type === "document") {
+            parts.push({
+                type: "file",
+                file: {
+                    filename: block.title ?? "document.pdf",
+                    file_data: `data:${block.source.media_type};base64,${block.source.data}`,
+                },
+            });
+        }
+        else if (block.type === "image") {
+            parts.push({
+                type: "image_url",
+                image_url: { url: `data:${block.source.media_type};base64,${block.source.data}` },
+            });
+        }
+    }
+    return { role: "user", content: parts };
+}
+/* ------------------------------------------------------------------ */
+/*  Shared helpers — also imported by openai-compat.ts.               */
+/* ------------------------------------------------------------------ */
+function isMaxTokensRejection(e) {
+    const err = e;
+    return err.status === 400 && (err.message?.includes("max_tokens") ?? false);
+}
+/**
+ * Older models accept `max_tokens`; o-series / gpt-5+ require
+ * `max_completion_tokens`. Try the former, fall back on the 400.
+ */
+export async function createCompletionWithTokenFallback(client, body, options) {
+    const base = {
+        model: body.model,
+        messages: body.messages,
+        tools: body.tools,
+    };
+    try {
+        return await client.chat.completions.create({ ...base, max_tokens: body.maxTokens }, options);
+    }
+    catch (e) {
+        if (isMaxTokensRejection(e)) {
+            return await client.chat.completions.create({ ...base, max_completion_tokens: body.maxTokens }, options);
+        }
+        throw e;
+    }
+}
+export function normalizeResponse(response) {
     const choice = response.choices[0];
     if (!choice) {
         return { content: [], stopReason: "end_turn" };
@@ -69,77 +133,29 @@ function normalizeResponse(response) {
                 type: "tool_use",
                 id: tc.id,
                 name: tc.function.name,
-                input: parseArguments(tc.function.arguments),
+                input: parseArguments(tc.function.name, tc.function.arguments),
             });
         }
     }
     const hasToolCalls = content.some((b) => b.type === "tool_use");
+    /**
+     * finish_reason "length" → "max_tokens" so the agent loop records a
+     * scan_truncated question instead of silently accepting a partial batch.
+     */
+    const stopReason = choice.finish_reason === "length"
+        ? "max_tokens"
+        : hasToolCalls
+            ? "tool_use"
+            : "end_turn";
     return {
         content,
-        stopReason: hasToolCalls ? "tool_use" : "end_turn",
+        stopReason,
         usage: response.usage
             ? { input_tokens: response.usage.prompt_tokens, output_tokens: response.usage.completion_tokens }
             : undefined,
     };
 }
-function convertMessages(system, messages) {
-    const result = [
-        { role: "system", content: system },
-    ];
-    for (const msg of messages) {
-        if (msg.role === "user") {
-            if (Array.isArray(msg.content) &&
-                msg.content.length > 0 &&
-                msg.content[0].type === "tool_result") {
-                const toolResults = msg.content;
-                for (const tr of toolResults) {
-                    result.push({
-                        role: "tool",
-                        tool_call_id: tr.tool_use_id,
-                        content: tr.content,
-                    });
-                }
-            }
-            else if (Array.isArray(msg.content)) {
-                // Strip document blocks (OpenAI-compat doesn't accept them); keep text.
-                const text = msg.content
-                    .filter((b) => b.type === "text")
-                    .map((b) => b.text)
-                    .join("\n");
-                result.push({ role: "user", content: text });
-            }
-            else {
-                result.push({ role: "user", content: msg.content });
-            }
-        }
-        else {
-            if (Array.isArray(msg.content)) {
-                const blocks = msg.content;
-                const textParts = blocks
-                    .filter((b) => b.type === "text")
-                    .map((b) => b.text)
-                    .join("\n");
-                const toolCalls = blocks
-                    .filter((b) => b.type === "tool_use")
-                    .map((tu) => ({
-                    id: tu.id,
-                    type: "function",
-                    function: { name: tu.name, arguments: JSON.stringify(tu.input) },
-                }));
-                result.push({
-                    role: "assistant",
-                    content: textParts || null,
-                    ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
-                });
-            }
-            else {
-                result.push({ role: "assistant", content: msg.content });
-            }
-        }
-    }
-    return result;
-}
-function convertTools(tools) {
+export function convertTools(tools) {
     return tools.map((t) => ({
         type: "function",
         function: {
@@ -149,13 +165,48 @@ function convertTools(tools) {
         },
     }));
 }
-function parseArguments(args) {
+/**
+ * Throw on malformed JSON so truncated tool args surface as an error instead
+ * of being silently coerced to `{}` (which would record zero transactions).
+ */
+export function parseArguments(toolName, args) {
     if (typeof args !== "string")
         return args;
     try {
         return JSON.parse(args);
     }
     catch {
-        return {};
+        const preview = args.length > 120 ? `${args.slice(0, 120)}…` : args;
+        throw new Error(`Tool call arguments for "${toolName}" were not valid JSON (likely truncated by max_tokens): ${preview}`);
     }
 }
+export function convertToolResults(toolResults) {
+    return toolResults.map((tr) => ({
+        role: "tool",
+        tool_call_id: tr.tool_use_id,
+        content: tr.content,
+    }));
+}
+export function convertAssistantMessage(blocks) {
+    const textParts = blocks
+        .filter((b) => b.type === "text")
+        .map((b) => b.text)
+        .join("\n");
+    const toolCalls = blocks
+        .filter((b) => b.type === "tool_use")
+        .map((tu) => ({
+        id: tu.id,
+        type: "function",
+        function: { name: tu.name, arguments: JSON.stringify(tu.input) },
+    }));
+    return {
+        role: "assistant",
+        content: textParts || null,
+        ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+    };
+}
+export function isToolResultEnvelope(content) {
+    return (Array.isArray(content) &&
+        content.length > 0 &&
+        content[0].type === "tool_result");
+}

package/dist/cli/commands/scan.js

@@ -1,6 +1,14 @@
 import chalk from "chalk";
 import { getDb } from "../../db/connection.js";
 import { runScan } from "../../scanner/engine.js";
+import { getActiveModel } from "../../config.js";
+import { getProvider } from "../../ai/providers/index.js";
+import { AbortedError } from "../../ai/errors.js";
+/** Show the cursor — always safe; mirrors the TTY mount-time hide. */
+function restoreTerminal() {
+    if (process.stdout.isTTY)
+        process.stdout.write("\x1b[?25h");
+}
 export async function runScanCommand(opts) {
     if (opts.regex) {
         try {
@@ -14,17 +22,46 @@ export async function runScanCommand(opts) {
     }
     const parallel = opts.parallel ?? 5;
     const isTTY = !!process.stdout.isTTY;
-    const hooks = isTTY ? await buildTtyHooks() : buildPlainHooks();
-    const result = await runScan(getDb(), {
-        regex: opts.regex,
-        force: opts.force,
-        interactive: true,
-        maxFileWorkers: parallel,
-    }, hooks);
-    renderSummary(result.state);
+    const controller = new AbortController();
+    let sigintCount = 0;
+    const onSigint = () => {
+        sigintCount++;
+        if (sigintCount === 1) {
+            controller.abort();
+            return;
+        }
+        restoreTerminal();
+        process.exit(130);
+    };
+    process.on("SIGINT", onSigint);
+    const hooks = isTTY
+        ? await buildTtyHooks(controller.signal)
+        : buildPlainHooks(controller.signal);
+    try {
+        const result = await runScan(getDb(), {
+            regex: opts.regex,
+            force: opts.force,
+            interactive: true,
+            maxFileWorkers: parallel,
+        }, hooks, controller.signal);
+        renderSummary(result.state);
+    }
+    catch (err) {
+        if (err instanceof AbortedError) {
+            restoreTerminal();
+            console.log("");
+            console.log(chalk.yellow("scan cancelled. anything committed before cancel stays in the database (run `scan --force` or `revert`)."));
+            process.exitCode = 130;
+            return;
+        }
+        throw err;
+    }
+    finally {
+        process.removeListener("SIGINT", onSigint);
+    }
 }
 /* TTY mode — Ink dashboard with one in-place row per file. */
-async function buildTtyHooks() {
+async function buildTtyHooks(signal) {
     const { render } = await import("ink");
     const { createElement } = await import("react");
     const { ScanDashboard, createScanDashboardController } = await import("../ink/ScanDashboard.js");
@@ -32,6 +69,14 @@ async function buildTtyHooks() {
     let inkInstance = null;
     let unsubscribeProgress = null;
     const chunkLookup = new Map();
+    // Surface cancellation through Ink's controller, not raw stdout — writing
+    // to stdout while Ink is rendering corrupts its frame tracking and leaves
+    // a phantom copy of the header in scrollback. once:true so the listener
+    // self-removes without leaking past the scan run.
+    const onAbortEvt = () => {
+        controller.publish({ type: "phase-set", phase: "cancelling" });
+    };
+    signal.addEventListener("abort", onAbortEvt, { once: true });
     return {
         afterDecrypt: (s) => {
             const total = s.decrypted.length + s.skipped.length + s.failed.length;
@@ -60,9 +105,16 @@ async function buildTtyHooks() {
                 fileName: d.fileName,
                 totalPages: s.chunks.filter((c) => c.fileId === d.path).length,
             }));
+            const provider = getProvider();
+            const attachment = {
+                format: provider.acceptsDocuments ? "pdf" : "png",
+                providerName: provider.name,
+                modelName: getActiveModel(),
+            };
             inkInstance = render(createElement(ScanDashboard, {
                 controller,
                 files,
+                attachment,
             }), {
                 exitOnCtrlC: false,
                 patchConsole: false,
@@ -108,6 +160,18 @@ async function buildTtyHooks() {
             inkInstance = null;
             process.stdout.write("\x1b[?25h");
         },
+        /**
+         * Cancellation lands here when the user hits Ctrl+C mid-scan. Drop the
+         * Ink dashboard immediately so subsequent stderr lines aren't trapped
+         * under its render, and restore the cursor we hid at mount time.
+         */
+        onAbort: () => {
+            unsubscribeProgress?.();
+            unsubscribeProgress = null;
+            inkInstance?.unmount();
+            inkInstance = null;
+            process.stdout.write("\x1b[?25h");
+        },
     };
 }
 const FINALIZE_RULES = [
@@ -126,10 +190,14 @@ function classifyFinalize(t) {
             return r.kind;
     return "partial";
 }
-function buildPlainHooks() {
+function buildPlainHooks(signal) {
     const tallies = new Map();
     const fileIdByChunkId = new Map();
     let unsubscribeProgress = null;
+    // No Ink in this mode, so writing one dim line directly is safe.
+    signal.addEventListener("abort", () => {
+        console.log(chalk.dim("Cancelling… waiting for in-flight work."));
+    }, { once: true });
     const finalize = (fileId) => {
         const t = tallies.get(fileId);
         if (!t || t.completedChunks + t.failedChunks < t.totalChunks)

package/dist/cli/commands/status.js

@@ -6,6 +6,7 @@ import { getRecurringSummary } from "../../db/queries/recurrences.js";
 import { countScannedFiles } from "../../db/queries/files.js";
 import { countQuestions } from "../../db/queries/questions.js";
 import { countMemories } from "../../ai/memory.js";
+import { config, getActiveModel } from "../../config.js";
 import { formatAmount } from "../../currency.js";
 import { visibleLength } from "../format.js";
 const LABEL_WIDTH = 18;
@@ -14,6 +15,8 @@ export function showStatus() {
     printSection("Financial", financialRows(db));
     console.log("");
     printSection("System", systemRows(db));
+    console.log("");
+    printSection("Model", modelRows(), { align: "left" });
 }
 function financialRows(db) {
     const nw = getNetWorth(db);
@@ -72,7 +75,14 @@ function systemRows(db) {
     }
     return rows;
 }
-function printSection(title, rows) {
+function modelRows() {
+    return [
+        { label: "Provider", value: config.providerType },
+        { label: "Model", value: getActiveModel() },
+    ];
+}
+function printSection(title, rows, opts) {
+    const align = opts?.align ?? "right";
     console.log(chalk.bold(title));
     console.log(chalk.dim("─".repeat(title.length)));
     const valueWidth = Math.max(0, ...rows.map((r) => visibleLength(r.value)));
@@ -80,7 +90,10 @@ function printSection(title, rows) {
         const label = row.label.padEnd(LABEL_WIDTH);
         const valuePad = " ".repeat(Math.max(0, valueWidth - visibleLength(row.value)));
         const suffix = row.suffix ? `  ${row.suffix}` : "";
-        console.log(`  ${label}${valuePad}${row.value}${suffix}`);
+        const body = align === "left"
+            ? `${row.value}${valuePad}${suffix}`
+            : `${valuePad}${row.value}${suffix}`;
+        console.log(`  ${label}${body}`);
     }
 }
 function formatInteger(n) {

package/dist/cli/ink/ScanDashboard.d.ts

@@ -2,7 +2,7 @@
  * Events the CLI publishes into the dashboard. The CLI subscribes to the
  * scanner's ScanProgress sink and routes per-chunk ticks here via chunkLookup.
  */
-export type CurrentPhase = "parse" | "clarify" | "done";
+export type CurrentPhase = "parse" | "clarify" | "cancelling" | "done";
 export type DashboardEvent = {
     type: "chunk-start";
     fileId: string;
@@ -36,14 +36,15 @@ export interface FileSeed {
     readonly fileName: string;
     readonly totalPages: number;
 }
+export interface AttachmentInfo {
+    format: "pdf" | "png";
+    providerName: string;
+    modelName: string;
+}
 interface Props {
     controller: ScanDashboardController;
     files: ReadonlyArray<FileSeed>;
+    attachment: AttachmentInfo;
 }
-/**
- * Tree-layout scan dashboard. Header carries the only animated element (one
- * `<Spinner>`). All other status indicators are static glyphs that only
- * redraw when their data changes.
- */
 export declare function ScanDashboard(props: Props): import("react/jsx-runtime").JSX.Element;
 export {};