reasonix 0.0.1

package/dist/index.js

@@ -0,0 +1,716 @@
+import {
+  DeepSeekClient,
+  Usage,
+  fetchWithRetry
+} from "./chunk-XILYSYPT.js";
+
+// src/harvest.ts
+function emptyPlanState() {
+  return { subgoals: [], hypotheses: [], uncertainties: [], rejectedPaths: [] };
+}
+function isPlanStateEmpty(s) {
+  return s.subgoals.length === 0 && s.hypotheses.length === 0 && s.uncertainties.length === 0 && s.rejectedPaths.length === 0;
+}
+async function harvest(_reasoningContent) {
+  return emptyPlanState();
+}
+
+// src/memory.ts
+import { createHash } from "crypto";
+var ImmutablePrefix = class {
+  system;
+  toolSpecs;
+  fewShots;
+  constructor(opts) {
+    this.system = opts.system;
+    this.toolSpecs = Object.freeze([...opts.toolSpecs ?? []]);
+    this.fewShots = Object.freeze([...opts.fewShots ?? []]);
+  }
+  toMessages() {
+    return [{ role: "system", content: this.system }, ...this.fewShots.map((m) => ({ ...m }))];
+  }
+  tools() {
+    return this.toolSpecs.map((t) => structuredClone(t));
+  }
+  get fingerprint() {
+    const blob = JSON.stringify({
+      system: this.system,
+      tools: this.toolSpecs,
+      shots: this.fewShots
+    });
+    return createHash("sha256").update(blob).digest("hex").slice(0, 16);
+  }
+};
+var AppendOnlyLog = class {
+  _entries = [];
+  append(message) {
+    if (!message || typeof message !== "object" || !("role" in message)) {
+      throw new Error(`invalid log entry: ${JSON.stringify(message)}`);
+    }
+    this._entries.push(message);
+  }
+  extend(messages) {
+    for (const m of messages) this.append(m);
+  }
+  get entries() {
+    return this._entries;
+  }
+  toMessages() {
+    return this._entries.map((e) => ({ ...e }));
+  }
+  get length() {
+    return this._entries.length;
+  }
+};
+var VolatileScratch = class {
+  reasoning = null;
+  planState = null;
+  notes = [];
+  reset() {
+    this.reasoning = null;
+    this.planState = null;
+    this.notes = [];
+  }
+};
+
+// src/repair/scavenge.ts
+function scavengeToolCalls(reasoningContent, opts) {
+  if (!reasoningContent) return { calls: [], notes: [] };
+  const max = opts.maxCalls ?? 4;
+  const notes = [];
+  const out = [];
+  for (const candidate of iterateJsonObjects(reasoningContent)) {
+    if (out.length >= max) break;
+    const call = coerceToToolCall(candidate, opts.allowedNames);
+    if (call) {
+      out.push(call);
+      notes.push(`scavenged call: ${call.function.name}`);
+    }
+  }
+  return { calls: out, notes };
+}
+function* iterateJsonObjects(text) {
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== "{") continue;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let j = i; j < text.length; j++) {
+      const c = text[j];
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (inString) {
+        if (c === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (c === '"') inString = false;
+        continue;
+      }
+      if (c === '"') inString = true;
+      else if (c === "{") depth++;
+      else if (c === "}") {
+        depth--;
+        if (depth === 0) {
+          yield text.slice(i, j + 1);
+          i = j;
+          break;
+        }
+      }
+    }
+  }
+}
+function coerceToToolCall(candidateJson, allowedNames) {
+  let parsed;
+  try {
+    parsed = JSON.parse(candidateJson);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  if (typeof parsed.name === "string" && allowedNames.has(parsed.name)) {
+    const args = parsed.arguments;
+    return {
+      function: {
+        name: parsed.name,
+        arguments: typeof args === "string" ? args : JSON.stringify(args ?? {})
+      }
+    };
+  }
+  if (parsed.type === "function" && parsed.function && typeof parsed.function.name === "string" && allowedNames.has(parsed.function.name)) {
+    const args = parsed.function.arguments;
+    return {
+      type: "function",
+      function: {
+        name: parsed.function.name,
+        arguments: typeof args === "string" ? args : JSON.stringify(args ?? {})
+      }
+    };
+  }
+  if (typeof parsed.tool_name === "string" && allowedNames.has(parsed.tool_name)) {
+    return {
+      function: {
+        name: parsed.tool_name,
+        arguments: JSON.stringify(parsed.tool_args ?? {})
+      }
+    };
+  }
+  return null;
+}
+
+// src/repair/storm.ts
+var StormBreaker = class {
+  windowSize;
+  threshold;
+  recent = [];
+  constructor(windowSize = 6, threshold = 3) {
+    this.windowSize = windowSize;
+    this.threshold = threshold;
+  }
+  inspect(call) {
+    const sig = signature(call);
+    if (!sig) return { suppress: false };
+    const count = this.recent.reduce(
+      (n, [name, args]) => name === sig[0] && args === sig[1] ? n + 1 : n,
+      0
+    );
+    if (count >= this.threshold - 1) {
+      return {
+        suppress: true,
+        reason: `call-storm suppressed: ${sig[0]} called with identical args ${count + 1} times within window=${this.windowSize}`
+      };
+    }
+    this.recent.push(sig);
+    while (this.recent.length > this.windowSize) this.recent.shift();
+    return { suppress: false };
+  }
+  reset() {
+    this.recent.length = 0;
+  }
+};
+function signature(call) {
+  const name = call.function?.name;
+  if (!name) return null;
+  return [name, call.function?.arguments ?? ""];
+}
+
+// src/repair/truncation.ts
+function repairTruncatedJson(input) {
+  const notes = [];
+  if (!input || !input.trim()) {
+    return { repaired: "{}", changed: input !== "{}", notes: ["empty input \u2192 {}"] };
+  }
+  try {
+    JSON.parse(input);
+    return { repaired: input, changed: false, notes: [] };
+  } catch {
+  }
+  const stack = [];
+  let escaped = false;
+  let inString = false;
+  let lastSignificant = -1;
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i];
+    if (!/\s/.test(c)) lastSignificant = i;
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (inString) {
+      if (c === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (c === '"') {
+        inString = false;
+        stack.pop();
+      }
+      continue;
+    }
+    if (c === '"') {
+      inString = true;
+      stack.push('"');
+      continue;
+    }
+    if (c === "{" || c === "[") stack.push(c);
+    else if (c === "}" || c === "]") stack.pop();
+  }
+  let s = input.slice(0, lastSignificant + 1);
+  if (/,$/.test(s)) {
+    s = s.replace(/,$/, "");
+    notes.push("trimmed trailing comma");
+  }
+  if (/"\s*:\s*$/.test(s)) {
+    s += " null";
+    notes.push("filled dangling key with null");
+  }
+  if (inString) {
+    s += '"';
+    stack.pop();
+    notes.push("closed unterminated string");
+  }
+  while (stack.length > 0) {
+    const top = stack.pop();
+    if (top === "{") s += "}";
+    else if (top === "[") s += "]";
+    else if (top === '"') s += '"';
+  }
+  try {
+    JSON.parse(s);
+    return { repaired: s, changed: true, notes };
+  } catch (err) {
+    notes.push(`fallback to {}: ${err.message}`);
+    return { repaired: "{}", changed: true, notes };
+  }
+}
+
+// src/repair/flatten.ts
+function analyzeSchema(schema) {
+  if (!schema) return { shouldFlatten: false, leafCount: 0, maxDepth: 0 };
+  let leafCount = 0;
+  let maxDepth = 0;
+  walk(schema, 0, (depth, isLeaf) => {
+    if (isLeaf) leafCount++;
+    if (depth > maxDepth) maxDepth = depth;
+  });
+  return {
+    shouldFlatten: leafCount > 10 || maxDepth > 2,
+    leafCount,
+    maxDepth
+  };
+}
+function flattenSchema(schema) {
+  const flatProps = {};
+  const required = [];
+  collect("", schema, flatProps, required, true);
+  return {
+    type: "object",
+    properties: flatProps,
+    required
+  };
+}
+function nestArguments(flatArgs) {
+  const out = {};
+  for (const [key, value] of Object.entries(flatArgs)) {
+    setByPath(out, key.split("."), value);
+  }
+  return out;
+}
+function walk(schema, depth, visit) {
+  if (schema.type === "object" && schema.properties) {
+    for (const child of Object.values(schema.properties)) {
+      walk(child, depth + 1, visit);
+    }
+    return;
+  }
+  if (schema.type === "array" && schema.items) {
+    walk(schema.items, depth + 1, visit);
+    return;
+  }
+  visit(depth, true);
+}
+function collect(prefix, schema, out, required, isRootRequired) {
+  if (schema.type === "object" && schema.properties) {
+    const requiredSet = new Set(schema.required ?? []);
+    for (const [key, child] of Object.entries(schema.properties)) {
+      const nextPrefix = prefix ? `${prefix}.${key}` : key;
+      const childRequired = isRootRequired && requiredSet.has(key);
+      collect(nextPrefix, child, out, required, childRequired);
+    }
+    return;
+  }
+  out[prefix] = schema;
+  if (isRootRequired) required.push(prefix);
+}
+function setByPath(target, path, value) {
+  let cur = target;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (typeof cur[key] !== "object" || cur[key] === null) cur[key] = {};
+    cur = cur[key];
+  }
+  cur[path[path.length - 1]] = value;
+}
+
+// src/repair/index.ts
+var ToolCallRepair = class {
+  storm;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+    this.storm = new StormBreaker(opts.stormWindow ?? 6, opts.stormThreshold ?? 3);
+  }
+  process(declaredCalls, reasoningContent) {
+    const report = {
+      scavenged: 0,
+      truncationsFixed: 0,
+      stormsBroken: 0,
+      notes: []
+    };
+    const scavenged = scavengeToolCalls(reasoningContent, {
+      allowedNames: this.opts.allowedToolNames,
+      maxCalls: this.opts.maxScavenge ?? 4
+    });
+    const seenSignatures = new Set(declaredCalls.map(signature2));
+    const merged = [...declaredCalls];
+    for (const sc of scavenged.calls) {
+      if (!seenSignatures.has(signature2(sc))) {
+        merged.push(sc);
+        report.scavenged++;
+        seenSignatures.add(signature2(sc));
+      }
+    }
+    report.notes.push(...scavenged.notes);
+    for (const call of merged) {
+      const args = call.function?.arguments ?? "";
+      const r = repairTruncatedJson(args);
+      if (r.changed) {
+        call.function.arguments = r.repaired;
+        report.truncationsFixed++;
+        report.notes.push(...r.notes.map((n) => `[${call.function.name}] ${n}`));
+      }
+    }
+    const filtered = [];
+    for (const call of merged) {
+      const verdict = this.storm.inspect(call);
+      if (verdict.suppress) {
+        report.stormsBroken++;
+        if (verdict.reason) report.notes.push(verdict.reason);
+        continue;
+      }
+      filtered.push(call);
+    }
+    return { calls: filtered, report };
+  }
+};
+function signature2(call) {
+  return `${call.function?.name ?? ""}::${call.function?.arguments ?? ""}`;
+}
+
+// src/telemetry.ts
+var DEEPSEEK_PRICING = {
+  "deepseek-chat": { inputCacheHit: 0.07, inputCacheMiss: 0.27, output: 1.1 },
+  "deepseek-reasoner": { inputCacheHit: 0.14, inputCacheMiss: 0.55, output: 2.19 }
+};
+var CLAUDE_SONNET_PRICING = { input: 3, output: 15 };
+function costUsd(model, usage) {
+  const p = DEEPSEEK_PRICING[model];
+  if (!p) return 0;
+  return (usage.promptCacheHitTokens * p.inputCacheHit + usage.promptCacheMissTokens * p.inputCacheMiss + usage.completionTokens * p.output) / 1e6;
+}
+function claudeEquivalentCost(usage) {
+  return (usage.promptTokens * CLAUDE_SONNET_PRICING.input + usage.completionTokens * CLAUDE_SONNET_PRICING.output) / 1e6;
+}
+var SessionStats = class {
+  turns = [];
+  record(turn, model, usage) {
+    const cost = costUsd(model, usage);
+    const stats = {
+      turn,
+      model,
+      usage,
+      cost,
+      cacheHitRatio: usage.cacheHitRatio
+    };
+    this.turns.push(stats);
+    return stats;
+  }
+  get totalCost() {
+    return this.turns.reduce((sum, t) => sum + t.cost, 0);
+  }
+  get totalClaudeEquivalent() {
+    return this.turns.reduce((sum, t) => sum + claudeEquivalentCost(t.usage), 0);
+  }
+  get savingsVsClaude() {
+    const c = this.totalClaudeEquivalent;
+    return c > 0 ? 1 - this.totalCost / c : 0;
+  }
+  get aggregateCacheHitRatio() {
+    let hit = 0;
+    let miss = 0;
+    for (const t of this.turns) {
+      hit += t.usage.promptCacheHitTokens;
+      miss += t.usage.promptCacheMissTokens;
+    }
+    const denom = hit + miss;
+    return denom > 0 ? hit / denom : 0;
+  }
+  summary() {
+    return {
+      turns: this.turns.length,
+      totalCostUsd: round(this.totalCost, 6),
+      claudeEquivalentUsd: round(this.totalClaudeEquivalent, 6),
+      savingsVsClaudePct: round(this.savingsVsClaude * 100, 2),
+      cacheHitRatio: round(this.aggregateCacheHitRatio, 4)
+    };
+  }
+};
+function round(n, digits) {
+  const f = 10 ** digits;
+  return Math.round(n * f) / f;
+}
+
+// src/tools.ts
+var ToolRegistry = class {
+  _tools = /* @__PURE__ */ new Map();
+  register(def) {
+    if (!def.name) throw new Error("tool requires a name");
+    this._tools.set(def.name, def);
+    return this;
+  }
+  has(name) {
+    return this._tools.has(name);
+  }
+  get(name) {
+    return this._tools.get(name);
+  }
+  get size() {
+    return this._tools.size;
+  }
+  specs() {
+    return [...this._tools.values()].map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description ?? "",
+        parameters: t.parameters ?? { type: "object", properties: {} }
+      }
+    }));
+  }
+  async dispatch(name, argumentsRaw) {
+    const tool = this._tools.get(name);
+    if (!tool) {
+      return JSON.stringify({ error: `unknown tool: ${name}` });
+    }
+    let args;
+    try {
+      args = typeof argumentsRaw === "string" ? argumentsRaw.trim() ? JSON.parse(argumentsRaw) : {} : argumentsRaw ?? {};
+    } catch (err) {
+      return JSON.stringify({
+        error: `invalid tool arguments JSON: ${err.message}`
+      });
+    }
+    try {
+      const result = await tool.fn(args);
+      return typeof result === "string" ? result : JSON.stringify(result);
+    } catch (err) {
+      return JSON.stringify({
+        error: `${err.name}: ${err.message}`
+      });
+    }
+  }
+};
+
+// src/loop.ts
+var CacheFirstLoop = class {
+  client;
+  prefix;
+  tools;
+  model;
+  maxToolIters;
+  stream;
+  log = new AppendOnlyLog();
+  scratch = new VolatileScratch();
+  stats = new SessionStats();
+  repair;
+  _turn = 0;
+  constructor(opts) {
+    this.client = opts.client;
+    this.prefix = opts.prefix;
+    this.tools = opts.tools ?? new ToolRegistry();
+    this.model = opts.model ?? "deepseek-chat";
+    this.maxToolIters = opts.maxToolIters ?? 8;
+    this.stream = opts.stream ?? true;
+    const allowedNames = /* @__PURE__ */ new Set([...this.prefix.toolSpecs.map((s) => s.function.name)]);
+    this.repair = new ToolCallRepair({ allowedToolNames: allowedNames });
+  }
+  buildMessages(pendingUser) {
+    const msgs = [...this.prefix.toMessages(), ...this.log.toMessages()];
+    if (pendingUser !== null) msgs.push({ role: "user", content: pendingUser });
+    return msgs;
+  }
+  async *step(userInput) {
+    this._turn++;
+    this.scratch.reset();
+    let pendingUser = userInput;
+    const toolSpecs = this.prefix.tools();
+    for (let iter = 0; iter < this.maxToolIters; iter++) {
+      const messages = this.buildMessages(pendingUser);
+      let assistantContent = "";
+      let reasoningContent = "";
+      let toolCalls = [];
+      let usage = null;
+      try {
+        if (this.stream) {
+          const callBuf = /* @__PURE__ */ new Map();
+          for await (const chunk of this.client.stream({
+            model: this.model,
+            messages,
+            tools: toolSpecs.length ? toolSpecs : void 0
+          })) {
+            if (chunk.contentDelta) {
+              assistantContent += chunk.contentDelta;
+              yield {
+                turn: this._turn,
+                role: "assistant_delta",
+                content: chunk.contentDelta
+              };
+            }
+            if (chunk.reasoningDelta) {
+              reasoningContent += chunk.reasoningDelta;
+              yield {
+                turn: this._turn,
+                role: "assistant_delta",
+                content: "",
+                reasoningDelta: chunk.reasoningDelta
+              };
+            }
+            if (chunk.toolCallDelta) {
+              const d = chunk.toolCallDelta;
+              const cur = callBuf.get(d.index) ?? {
+                id: d.id,
+                type: "function",
+                function: { name: "", arguments: "" }
+              };
+              if (d.id) cur.id = d.id;
+              if (d.name) cur.function.name = (cur.function.name ?? "") + d.name;
+              if (d.argumentsDelta)
+                cur.function.arguments = (cur.function.arguments ?? "") + d.argumentsDelta;
+              callBuf.set(d.index, cur);
+            }
+            if (chunk.usage) usage = chunk.usage;
+          }
+          toolCalls = [...callBuf.values()];
+        } else {
+          const resp = await this.client.chat({
+            model: this.model,
+            messages,
+            tools: toolSpecs.length ? toolSpecs : void 0
+          });
+          assistantContent = resp.content;
+          reasoningContent = resp.reasoningContent ?? "";
+          toolCalls = resp.toolCalls;
+          usage = resp.usage;
+        }
+      } catch (err) {
+        yield {
+          turn: this._turn,
+          role: "error",
+          content: "",
+          error: err.message
+        };
+        return;
+      }
+      const turnStats = this.stats.record(
+        this._turn,
+        this.model,
+        usage ?? new (await import("./client-4JTJKRDV.js")).Usage()
+      );
+      if (pendingUser !== null) {
+        this.log.append({ role: "user", content: pendingUser });
+        pendingUser = null;
+      }
+      this.scratch.reasoning = reasoningContent || null;
+      const planState = await harvest(reasoningContent || null);
+      const { calls: repairedCalls, report } = this.repair.process(
+        toolCalls,
+        reasoningContent || null
+      );
+      this.log.append(this.assistantMessage(assistantContent, repairedCalls));
+      yield {
+        turn: this._turn,
+        role: "assistant_final",
+        content: assistantContent,
+        stats: turnStats,
+        planState,
+        repair: report
+      };
+      if (repairedCalls.length === 0) {
+        yield { turn: this._turn, role: "done", content: assistantContent };
+        return;
+      }
+      for (const call of repairedCalls) {
+        const name = call.function?.name ?? "";
+        const args = call.function?.arguments ?? "{}";
+        const result = await this.tools.dispatch(name, args);
+        this.log.append({
+          role: "tool",
+          tool_call_id: call.id ?? "",
+          name,
+          content: result
+        });
+        yield { turn: this._turn, role: "tool", content: result, toolName: name };
+      }
+    }
+    yield { turn: this._turn, role: "done", content: "[max_tool_iters reached]" };
+  }
+  async run(userInput, onEvent) {
+    let final = "";
+    for await (const ev of this.step(userInput)) {
+      onEvent?.(ev);
+      if (ev.role === "assistant_final") final = ev.content;
+      if (ev.role === "done") break;
+    }
+    return final;
+  }
+  assistantMessage(content, toolCalls) {
+    const msg = { role: "assistant", content };
+    if (toolCalls.length > 0) msg.tool_calls = toolCalls;
+    return msg;
+  }
+};
+
+// src/env.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+function loadDotenv(path = ".env") {
+  let raw;
+  try {
+    raw = readFileSync(resolve(process.cwd(), path), "utf8");
+  } catch {
+    return;
+  }
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let value = trimmed.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (process.env[key] === void 0) process.env[key] = value;
+  }
+}
+
+// src/index.ts
+var VERSION = "0.0.1";
+export {
+  AppendOnlyLog,
+  CacheFirstLoop,
+  DeepSeekClient,
+  ImmutablePrefix,
+  SessionStats,
+  StormBreaker,
+  ToolCallRepair,
+  ToolRegistry,
+  Usage,
+  VERSION,
+  VolatileScratch,
+  analyzeSchema,
+  claudeEquivalentCost,
+  costUsd,
+  emptyPlanState,
+  fetchWithRetry,
+  flattenSchema,
+  harvest,
+  isPlanStateEmpty,
+  loadDotenv,
+  nestArguments,
+  repairTruncatedJson,
+  scavengeToolCalls
+};
+//# sourceMappingURL=index.js.map