querysub 0.443.0 → 0.446.0

package/src/diagnostics/logs/errorNotifications2/openRouterHelper.ts

@@ -1,3 +1,130 @@
+export type OpenRouterEffort = "none" | "low" | "medium" | "high";
+
+export type OpenRouterResult = {
+    text: string;
+    /** Total cost of the call in USD, if OpenRouter reported it. */
+    cost: number | undefined;
+};
+
+/** Calls OpenRouter with an explicit model and reasoning effort.
+ *      If `onProgress` is provided, the response is streamed and `onProgress` is
+ *      called repeatedly with the accumulated text so far. The final full text
+ *      (and cost) is returned regardless. */
+export async function callOpenRouterModel(config: {
+    apiKey: string;
+    model: string;
+    prompt: string;
+    /** OpenRouter reasoning effort. "none" disables reasoning entirely. */
+    effort?: OpenRouterEffort;
+    /** Called with the accumulated text each time more is streamed in. */
+    onProgress?: (partial: string) => void;
+}): Promise<OpenRouterResult> {
+    let body: Record<string, unknown> = {
+        model: config.model,
+        messages: [
+            {
+                role: "user",
+                content: config.prompt,
+            },
+        ],
+        // Ask OpenRouter to include usage (and therefore cost) in the response.
+        usage: { include: true },
+    };
+    if (config.effort === "none") {
+        body.reasoning = { enabled: false };
+    } else if (config.effort) {
+        body.reasoning = { effort: config.effort };
+    }
+
+    let streaming = !!config.onProgress;
+    if (streaming) {
+        body.stream = true;
+    }
+
+    const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+        method: "POST",
+        headers: {
+            "Authorization": `Bearer ${config.apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`OpenRouter API error: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+
+    if (!streaming) {
+        const data = await response.json();
+
+        if (!data.choices || !data.choices[0] || !data.choices[0].message || !data.choices[0].message.content) {
+            throw new Error(`Unexpected OpenRouter API response format: ${JSON.stringify(data)}`);
+        }
+
+        let cost = typeof data.usage?.cost === "number" ? data.usage.cost as number : undefined;
+        return {
+            text: String(data.choices[0].message.content).trim(),
+            cost,
+        };
+    }
+
+    let reader = response.body?.getReader();
+    if (!reader) {
+        throw new Error(`OpenRouter streaming response had no body`);
+    }
+    let decoder = new TextDecoder();
+    let pending = "";
+    let full = "";
+    let cost: number | undefined;
+
+    function onLine(line: string) {
+        line = line.trim();
+        if (!line.startsWith("data: ")) return;
+        if (line === "data: [DONE]") return;
+        let data = JSON.parse(line.slice("data: ".length));
+        if (data?.error) {
+            throw new Error(`OpenRouter mid-stream error: ${JSON.stringify(data.error)}`);
+        }
+        if (typeof data?.usage?.cost === "number") {
+            cost = data.usage.cost;
+        }
+        let delta = data?.choices?.[0]?.delta?.content;
+        if (typeof delta === "string" && delta) {
+            full += delta;
+            config.onProgress?.(full);
+        }
+    }
+
+    while (true) {
+        let { done, value } = await reader.read();
+        if (done) break;
+        pending += decoder.decode(value, { stream: true });
+        let lines = pending.split("\n");
+        for (let i = 0; i < lines.length - 1; i++) {
+            try {
+                onLine(lines[i]);
+            } catch (e) {
+                // OpenRouter mixes the occasional non-JSON keep-alive comment into the stream.
+                if (!String(e).includes("SyntaxError")) throw e;
+            }
+        }
+        pending = lines[lines.length - 1];
+    }
+    if (pending.trim()) {
+        try {
+            onLine(pending);
+        } catch (e) {
+            if (!String(e).includes("SyntaxError")) throw e;
+        }
+    }
+
+    return {
+        text: full.trim(),
+        cost,
+    };
+}
+
 export async function callOpenRouter(apiKey: string, prompt: string): Promise<string> {
     const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
         method: "POST",

package/src/diagnostics/pathAuditer.ts

@@ -278,6 +278,7 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
     for (let pathObj of pathsToAudit) {
         let path = pathObj.path;
         let ourLatest = authorityStorage.getValueAtTime(path);
+        if (ourLatest?.event) continue;
         originalValues.set(path, ourLatest);
 
         // Ask for their latest valid (time: undefined means latest)
@@ -310,6 +311,8 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
         let originalValue = originalValues.get(response.path);
         let ourValue = authorityStorage.getValueAtTime(response.path) || createMissingEpochValue(response.path);
 
+        if (ourValue.event || response.event) continue;
+
         let localValueChanged = false;
         if (originalValue === undefined && ourValue.time !== epochTime) {
             localValueChanged = true;
@@ -439,6 +442,7 @@ type ValidStateResponse = {
     time?: { time: number; version: number; creatorId: number };
     valid: boolean | undefined;
     isTransparent: boolean;
+    event: boolean;
 };
 
 class PathAuditerService {
@@ -451,6 +455,7 @@ class PathAuditerService {
                 time: value?.time,
                 valid: value === undefined ? undefined : value.valid,
                 isTransparent: !!value?.isTransparent,
+                event: !!value?.event,
             });
         }
         return results;

package/test.ts

@@ -3,7 +3,7 @@ chdir("D:/repos/qs-cyoa/");
 
 import "./inject";
 import { SocketFunction } from "socket-function/SocketFunction";
-import { getControllerNodeIdList } from "./src/-g-core-values/NodeCapabilities";
+import { NodeCapabilitiesController, getControllerNodeIdList } from "./src/-g-core-values/NodeCapabilities";
 import { delay } from "socket-function/src/batching";
 import { green, yellow } from "socket-function/src/formatting/logColors";
 import { Querysub, t } from "./src/4-querysub/Querysub";
@@ -19,6 +19,9 @@ import { shutdown } from "./src/diagnostics/periodic";
 import { getShardPrefixes } from "./src/0-path-value-core/ShardPrefixes";
 import { PathValue, epochTime } from "./src/0-path-value-core/pathValueCore";
 import { pathValueSerializer } from "./src/-h-path-value-serialize/PathValueSerializer";
+import { getAllNodeIds } from "./src/-f-node-discovery/NodeDiscovery";
+import { errorToUndefinedSilent } from "./src/errors";
+import { timeoutToUndefinedSilent } from "socket-function/src/misc";
 
 let tempTestSchema = Querysub.createSchema({
     value: t.number,
@@ -30,13 +33,19 @@ let tempTestSchema = Querysub.createSchema({
 });
 
 async function main() {
-    // await Querysub.hostService("test");
+    await Querysub.hostService("test");
 
     // let testValues: PathValue[] = [];
     // let buffers = await pathValueSerializer.serialize(testValues);
     // let values = await pathValueSerializer.deserialize(buffers);
 
-    let values = await pathValueArchives.loadValues(await getAllAuthoritySpec());
+    //let values = await pathValueArchives.loadValues(await getAllAuthoritySpec());
+
+    let nodes = await getAllNodeIds();
+    let values = await Promise.all(nodes.map(async node => {
+        return timeoutToUndefinedSilent(5000, NodeCapabilitiesController.nodes[node].getEntryPoint());
+    }));
+    console.log({ values });
 
     // let path = getProxyPath(() => tempTestSchema.data().value);
     // console.log({ path });