plasalid 0.7.8 → 0.8.0

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/ai/thinking.js

@@ -28,7 +28,7 @@ const THINKING_PHRASES = [
     "Doing math, the slow kind...",
     "Computing... probably correctly...",
     "Pondering quietly...",
-    "Joining the dots...",
+    "Connecting the dots...",
     "Making sense of it...",
     "Sharpening the pencil...",
     "Catching up on the details...",

package/dist/cli/commands/clarify.js

@@ -31,12 +31,7 @@ function formatSummary(summary) {
     if (summary.total === 0) {
         return chalk.dim("No questions.");
     }
-    const tally = Object.entries(summary.tally)
-        .map(([k, v]) => `${k}×${v}`)
-        .join(", ");
-    const lines = [
-        chalk.bold(`Clarified ${summary.clarified}/${summary.total} questions${tally ? ` (${tally})` : ""}.`),
-    ];
+    const lines = [chalk.bold(`Clarified ${summary.clarified}/${summary.total} questions.`)];
     if (summary.remaining > 0) {
         lines.push(chalk.yellow(`${summary.remaining} question(s) remain.`));
     }

package/dist/cli/commands/scan.js

@@ -1,6 +1,8 @@
 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";
 export async function runScanCommand(opts) {
     if (opts.regex) {
         try {
@@ -60,9 +62,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,

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

@@ -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 {};

package/dist/cli/ink/ScanDashboard.js

@@ -30,16 +30,15 @@ const COL = {
     transactions: 13,
     questions: 10,
 };
-/**
- * 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 function ScanDashboard(props) {
     const rows = useFileGroups(props.controller, props.files);
     const phase = usePhase(props.controller);
     const ruleWidth = useRuleWidth();
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { phase: phase }), _jsx(Box, { marginTop: 1, children: _jsx(ColumnHeader, {}) }), _jsx(Divider, { width: ruleWidth }), Array.from(rows.entries()).map(([fileId, group]) => (_jsx(FileGroupView, { group: group }, fileId))), _jsx(Divider, { width: ruleWidth })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { phase: phase }), _jsx(AttachmentLine, { info: props.attachment }), _jsx(Box, { marginTop: 1, children: _jsx(ColumnHeader, {}) }), _jsx(Divider, { width: ruleWidth }), Array.from(rows.entries()).map(([fileId, group]) => (_jsx(FileGroupView, { group: group }, fileId))), _jsx(Divider, { width: ruleWidth })] }));
+}
+function AttachmentLine({ info }) {
+    const detail = info.format === "pdf" ? "pdf (native)" : "png (rasterized)";
+    return (_jsxs(Text, { dimColor: true, children: ["sending: ", detail, " \u00B7 ", info.providerName, " \u00B7 ", info.modelName] }));
 }
 function usePhase(controller) {
     const [phase, setPhase] = useState("parse");