s-app-scoder-agent 0.6.0 → 0.7.0

package/dist/json-schema.js

@@ -0,0 +1,58 @@
+/**
+ * M2: JSON-Schema subset validator — không dependency. Hỗ trợ: type,
+ * required, properties, enum, items, additionalProperties=false khi khai báo.
+ * Trả về mảng lỗi (rỗng = hợp lệ). Dùng để validate MCP tool args trước
+ * tools/call — lỗi local, không gọi server.
+ */
+const TYPE_CHECKS = {
+    string: (v) => typeof v === "string",
+    number: (v) => typeof v === "number" && Number.isFinite(v),
+    integer: (v) => typeof v === "number" && Number.isInteger(v),
+    boolean: (v) => typeof v === "boolean",
+    object: (v) => typeof v === "object" && v !== null && !Array.isArray(v),
+    array: (v) => Array.isArray(v),
+    null: (v) => v === null,
+};
+/** Validate value theo schema subset. path dùng cho error message. */
+export function validateSchema(value, schema, path = "args") {
+    if (!schema || typeof schema !== "object")
+        return [];
+    const errors = [];
+    const type = schema.type;
+    if (type !== undefined) {
+        const types = Array.isArray(type) ? type : [type];
+        const ok = types.some((t) => TYPE_CHECKS[t]?.(value));
+        if (!ok) {
+            errors.push(`${path}: expected ${types.join("|")}, got ${jsonType(value)}`);
+            return errors; // sai type — không kiểm tra sâu hơn
+        }
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.some((e) => e === value)) {
+        errors.push(`${path}: must be one of ${schema.enum.map((e) => JSON.stringify(e)).join(", ")}`);
+    }
+    if (TYPE_CHECKS.object(value)) {
+        const obj = value;
+        const props = (schema.properties ?? {});
+        for (const req of schema.required ?? []) {
+            if (!(req in obj))
+                errors.push(`${path}: missing required property "${req}"`);
+        }
+        for (const [k, v] of Object.entries(obj)) {
+            if (props[k])
+                errors.push(...validateSchema(v, props[k], `${path}.${k}`));
+            else if (schema.additionalProperties === false)
+                errors.push(`${path}: unexpected property "${k}"`);
+        }
+    }
+    if (Array.isArray(value) && schema.items) {
+        value.forEach((item, i) => errors.push(...validateSchema(item, schema.items, `${path}[${i}]`)));
+    }
+    return errors;
+}
+function jsonType(v) {
+    if (v === null)
+        return "null";
+    if (Array.isArray(v))
+        return "array";
+    return typeof v;
+}

package/dist/llm.js

@@ -3,6 +3,29 @@
  * and optional SSE streaming.
  */
 import { withRetry } from "./retry.js";
+// ---------------------------------------------------------------------------
+// Secrets redaction (H-13) — shared by LLM error bodies, MCP tool output,
+// compaction summaries and snapshot logs. Never log raw credentials.
+// ---------------------------------------------------------------------------
+const REDACTION_PATTERNS = [
+    [/Bearer\s+[^\s,&\]]+/gi, "Bearer ***REDACTED***"],
+    [/sk-[A-Za-z0-9_-]{8,}/g, "sk-***REDACTED***"],
+    [/sk-ant-[^\s,&\]]+/gi, "sk-ant-***REDACTED***"],
+    [/ghp_[A-Za-z0-9]{20,}/g, "ghp_***REDACTED***"],
+    [/github_pat_[A-Za-z0-9_]{20,}/g, "github_pat_***REDACTED***"],
+    [/xox[bap]-[A-Za-z0-9-]{10,}/g, "xox***REDACTED***"],
+    [/AKIA[0-9A-Z]{16}/g, "AKIA***REDACTED***"],
+    [/-----BEGIN [A-Z ]*PRIVATE KEY-----/g, "***PRIVATE-KEY***"],
+    [/\b(api[_-]?key|token|secret|password)["'\s:=]+[^\s"'&]{8,}/gi, "$1=***REDACTED***"],
+];
+/** Redact known secret shapes from arbitrary tool/LLM/log output. */
+export function redactSecrets(text) {
+    let out = text;
+    for (const [rx, replacement] of REDACTION_PATTERNS) {
+        out = out.replace(rx, replacement);
+    }
+    return out;
+}
 export class LlmError extends Error {
     status;
     retryAfterMs;
@@ -19,8 +42,7 @@ export class LlmError extends Error {
 async function toLlmError(res, url) {
     let body = await res.text().catch(() => "");
     // Redact Bearer token and raw key patterns to avoid leaking secrets in logs/errors
-    body = body.replace(/Bearer\s+[^\s,&\]]+/gi, "Bearer ***REDACTED***");
-    body = body.replace(/sk-[A-Za-z0-9_-]{8,}/g, "sk-***REDACTED***");
+    body = redactSecrets(body);
     const err = new LlmError(`LLM API error ${res.status} at ${url}: ${body.slice(0, 500)}`, res.status);
     // Only honor a REAL Retry-After value: Number("") === 0 would zero the backoff
     const retryAfterHeader = res.headers.get("retry-after");
@@ -53,6 +75,8 @@ export function combinedSignal(external, timeoutMs) {
     }
     return {
         signal: ac.signal,
+        /** Clear only the request timer — keep the SIGINT listener alive. */
+        stopTimer: () => clearTimeout(timer),
         cleanup: () => {
             clearTimeout(timer);
             external?.removeEventListener("abort", onExternal);
@@ -102,6 +126,8 @@ function toWireMessages(messages) {
 export class LlmClient {
     opts;
     streamEnabled;
+    /** Last interrupted stream's accumulated tool calls (H-09 continuation). */
+    lastPartialToolCalls = [];
     constructor(opts) {
         this.opts = opts;
         this.streamEnabled = opts.stream !== false; // default true
@@ -109,10 +135,17 @@ export class LlmClient {
     get model() {
         return this.opts.model;
     }
+    /** T-04: runtime hot-swap — next request uses the new model id. */
+    setModel(model) {
+        this.opts = { ...this.opts, model };
+    }
+    get timeoutMs() {
+        return this.opts.requestTimeoutMs ?? LLM_REQUEST_TIMEOUT_MS;
+    }
     // ── Non-streaming ──────────────────────────────────────────────────────────
     async chat(messages, tools, opts = {}) {
         const url = `${this.opts.baseUrl.replace(/\/$/, "")}/chat/completions`;
-        const { signal, cleanup } = combinedSignal(opts.signal, LLM_REQUEST_TIMEOUT_MS);
+        const { signal, cleanup } = combinedSignal(opts.signal, this.timeoutMs);
         const body = JSON.stringify({
             model: this.opts.model,
             messages: toWireMessages(messages),
@@ -135,10 +168,21 @@ export class LlmClient {
                 return r;
             }, {}, (attempt, delay, reason) => console.error(`⚠  LLM request failed (${reason}), retrying in ${(delay / 1000).toFixed(1)}s (attempt ${attempt}/3)...`));
         }
+        catch (err) {
+            cleanup(); // timer must not survive a failed request
+            throw err;
+        }
+        let data;
+        try {
+            // Keep the timeout alive through the body read — a hung body must also
+            // surface as a timeout, not an eternal await.
+            const pending = res.json();
+            pending.catch(() => { }); // no-op catch for the abort path; awaited below
+            data = (await pending);
+        }
         finally {
             cleanup();
         }
-        const data = (await res.json());
         const choice = data.choices?.[0]?.message;
         if (!choice)
             throw new LlmError("LLM API returned no message in response");
@@ -157,6 +201,7 @@ export class LlmClient {
                 role: "assistant",
                 content: choice.content ?? null,
                 stop_reason: choice.stop_reason ?? (choice.content ? "stop" : undefined),
+                reasoning: typeof choice.reasoning_content === "string" && choice.reasoning_content ? choice.reasoning_content : undefined,
                 tool_calls: choice.tool_calls?.map((tc) => ({
                     id: tc.id ?? "",
                     name: tc.function?.name ?? "",
@@ -173,7 +218,7 @@ export class LlmClient {
      */
     async *streamChat(messages, tools, opts = {}) {
         const url = `${this.opts.baseUrl.replace(/\/$/, "")}/chat/completions`;
-        const { signal, cleanup } = combinedSignal(opts.signal, LLM_REQUEST_TIMEOUT_MS);
+        const { signal, cleanup, stopTimer } = combinedSignal(opts.signal, this.timeoutMs);
         const bodyStr = JSON.stringify({
             model: this.opts.model,
             messages: toWireMessages(messages),
@@ -181,6 +226,9 @@ export class LlmClient {
             temperature: this.opts.temperature,
             max_tokens: this.opts.maxTokens,
             stream: true,
+            // OpenAI-compatible providers only include usage in streaming responses
+            // when this flag is set — without it token accounting silently zeros out.
+            stream_options: { include_usage: true },
         });
         let res;
         try {
@@ -203,15 +251,47 @@ export class LlmClient {
         if (!res.body) {
             throw new LlmError("Response body is not readable (not a streaming response)");
         }
+        // Headers received — the WHOLE-request timeout has served its purpose.
+        // A long stream is normal (big models can stream for minutes), so from
+        // here on we enforce an IDLE timeout instead: reset on every received
+        // chunk; only a truly silent connection for idleTimeoutMs kills the read.
+        // (The old whole-request timer fired mid-stream on long generations —
+        // "LLM stream timed out while reading the response".) SIGINT still aborts
+        // through the same signal — stopTimer keeps the external listener alive.
+        stopTimer();
+        const idleTimeoutMs = opts.idleTimeoutMs ?? this.timeoutMs;
+        const readWithIdleTimeout = async () => {
+            const ac = new AbortController();
+            const t = setTimeout(() => ac.abort(new DOMException(`stream idle for ${idleTimeoutMs / 1000}s`, "TimeoutError")), idleTimeoutMs);
+            try {
+                return await Promise.race([
+                    reader.read(),
+                    new Promise((_, rej) => ac.signal.addEventListener("abort", () => rej(ac.signal.reason), { once: true })),
+                ]);
+            }
+            finally {
+                clearTimeout(t);
+            }
+        };
         // Accumulators for tool_calls across chunks
         const accumulatedToolCalls = [];
         let finalResult;
+        let finalUsage;
         const reader = res.body.getReader();
         const decoder = new TextDecoder();
         let buffer = "";
+        // Reset the partial-call record for this stream (H-09 continuation).
+        this.lastPartialToolCalls = [];
+        // I-05: accumulate reasoning deltas for the final message.
+        let reasoningAccum = "";
         try {
             while (true) {
-                const { done, value } = await reader.read();
+                // Guard the pending read against a late abort (e.g. the idle timeout
+                // firing while the consumer paused at a yield): attaching a no-op
+                // catch prevents an unhandled rejection from crashing the process.
+                const pending = readWithIdleTimeout();
+                pending.catch(() => { });
+                const { done, value } = await pending;
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true });
@@ -229,6 +309,10 @@ export class LlmClient {
                     catch {
                         continue; // skip malformed JSON lines
                     }
+                    // Usage-only final chunk: many providers send usage in a chunk with
+                    // an empty choices array — must not be skipped.
+                    if (chunkData.usage)
+                        finalUsage = { ...chunkData.usage };
                     const choice = chunkData.choices?.[0];
                     if (!choice)
                         continue;
@@ -237,6 +321,11 @@ export class LlmClient {
                     if (delta?.content != null && delta.content.length > 0) {
                         yield { contentDelta: delta.content, done: false };
                     }
+                    // I-05: reasoning_content delta (DeepSeek/OpenRouter style)
+                    if (delta?.reasoning_content) {
+                        reasoningAccum += delta.reasoning_content;
+                        yield { reasoningDelta: delta.reasoning_content, done: false };
+                    }
                     // Tool call deltas
                     if (delta?.tool_calls) {
                         for (const tc of delta.tool_calls) {
@@ -278,6 +367,7 @@ export class LlmClient {
                                 content: null,
                                 stop_reason: choice.finish_reason,
                                 tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+                                reasoning: reasoningAccum || undefined,
                             },
                             usage: chunkData.usage,
                         };
@@ -285,15 +375,39 @@ export class LlmClient {
                 }
             }
         }
+        catch (err) {
+            // Normalize the abort timeout into LlmError so callers handle it as a
+            // normal provider failure instead of a stray DOMException.
+            const e = err;
+            if (e?.name === "TimeoutError" || /TimeoutError/.test(e?.message ?? "")) {
+                throw new LlmError(`LLM stream timed out (${(e?.message ?? "").includes("idle") ? `no data for ${e.message.replace(/^.*idle for /, "")}` : "while reading the response"})`);
+            }
+            throw err;
+        }
         finally {
-            // Cancel the body (frees the socket) and clear the request timeout
+            // H-09: record complete tool calls accumulated so far, for continuation.
+            this.lastPartialToolCalls = accumulatedToolCalls
+                .filter((tc) => tc.name)
+                .map((tc) => ({ id: tc.id ?? "", name: tc.name, arguments: tc.arguments }));
+            // Cancel the body (frees the socket) and clear the request timeout.
+            // cancel() returns a promise — a rejection after abort must be swallowed
+            // or it becomes an unhandled rejection that kills the process.
             try {
-                reader.cancel();
+                const c = reader.cancel();
+                if (c && typeof c.catch === "function")
+                    c.catch(() => { });
             }
             catch { /* already released */ }
-            reader.releaseLock();
+            try {
+                reader.releaseLock();
+            }
+            catch { /* lock already released */ }
             cleanup();
         }
+        // Attach usage collected from a usage-only chunk (choices: []) if the
+        // finish chunk itself didn't carry it.
+        if (finalResult && !finalResult.usage && finalUsage)
+            finalResult.usage = finalUsage;
         yield { done: true, final: finalResult };
     }
 }