unbrowse 2.1.2 → 2.1.3

package/dist/cli.js

@@ -1302,7 +1302,7 @@ async function handleMessage(msg, unbrowseBin, timeoutMs) {
 loadEnv({ quiet: true });
 loadEnv({ path: ".env.runtime", quiet: true });
 var BASE_URL = process.env.UNBROWSE_URL || "http://localhost:6969";
-var CLI_CLIENT_ID = process.env.UNBROWSE_CLIENT_ID || `cli-${process.ppid || process.pid}`;
+var CLI_CLIENT_ID = process.env.UNBROWSE_CLIENT_ID || "cli-local";
 function parseArgs(argv) {
   const raw = argv.slice(2);
   const command = raw[0] && !raw[0].startsWith("--") ? raw[0] : "help";

package/dist/index.js

@@ -14177,6 +14177,25 @@ function promoteResultSnapshot(cacheKey, skill, endpointId, result, trace, respo
     expires: Date.now() + ROUTE_CACHE_TTL
   });
 }
+function buildCachedResultResponse(cached, source, timing) {
+  const now = new Date().toISOString();
+  return {
+    result: cached.result,
+    trace: {
+      ...cached.trace,
+      trace_id: nanoid6(),
+      started_at: now,
+      completed_at: now,
+      endpoint_id: cached.endpointId ?? cached.trace.endpoint_id,
+      skill_id: cached.skill.skill_id
+    },
+    source,
+    skill: cached.skill,
+    timing,
+    response_schema: cached.response_schema,
+    extraction_hints: cached.extraction_hints
+  };
+}
 function invalidateResolveCacheEntries(cacheKeys, domainKeys = []) {
   let routeCacheDirty = false;
   let domainCacheDirty = false;
@@ -14401,6 +14420,11 @@ async function withDomainCaptureLock(domain, fn) {
 function shouldFallbackToLiveCaptureAfterAutoexecFailure(autoexecFailedAll, contextUrl) {
   return autoexecFailedAll && !!contextUrl;
 }
+function shouldReuseRouteResultSnapshot(cached, intent, contextUrl, now = Date.now()) {
+  if (cached.expires <= now)
+    return false;
+  return isCachedSkillRelevantForIntent(cached.skill, intent, contextUrl);
+}
 function computeCompositeScore(embeddingScore, skill) {
   const reliabilities = skill.endpoints.map((e) => e.reliability_score);
   const avgReliability = reliabilities.length > 0 ? reliabilities.reduce((a, b) => a + b, 0) / reliabilities.length : 0.5;
@@ -15328,18 +15352,18 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
   if (!forceCapture && !agentChoseEndpoint) {
     const cachedResult = routeResultCache.get(cacheKey);
     if (cachedResult) {
-      if (cachedResult.expires <= Date.now() || !isAcceptableIntentResult(cachedResult.result, intent) || !isCachedSkillRelevantForIntent(cachedResult.skill, intent, context?.url)) {
+      if (!shouldReuseRouteResultSnapshot(cachedResult, intent, context?.url)) {
         routeResultCache.delete(cacheKey);
       } else {
-        const deferred2 = await buildDeferralWithAutoExec(cachedResult.skill, "marketplace");
-        if (shouldFallbackToLiveCaptureAfterAutoexecFailure(deferred2.autoexecFailedAll, context?.url)) {
-          console.log("[route-result-cache] stale cached skill; retrying via live capture");
-          invalidateResolveCacheEntries([cacheKey], requestedDomainCacheKey ? [requestedDomainCacheKey] : []);
-        } else {
-          timing.cache_hit = true;
-          deferred2.orchestratorResult.timing.cache_hit = true;
-          return deferred2.orchestratorResult;
-        }
+        timing.cache_hit = true;
+        writeDebugTrace("resolve", {
+          ...decisionTrace,
+          outcome: "route_result_cache_hit",
+          source: "route-cache",
+          skill_id: cachedResult.skill.skill_id,
+          selected_endpoint_id: cachedResult.endpointId ?? cachedResult.trace.endpoint_id
+        });
+        return buildCachedResultResponse(cachedResult, "marketplace", finalize2("route-cache", cachedResult.result, cachedResult.skill.skill_id, cachedResult.skill, cachedResult.trace));
       }
     }
   }
@@ -16202,7 +16226,7 @@ async function fetchStats() {
   return data;
 }
 async function registerRoutes(app) {
-  const clientScopeFor = (req) => typeof req.headers["x-unbrowse-client-id"] === "string" && req.headers["x-unbrowse-client-id"].trim() ? req.headers["x-unbrowse-client-id"].trim() : req.id;
+  const clientScopeFor = (req) => typeof req.headers["x-unbrowse-client-id"] === "string" && req.headers["x-unbrowse-client-id"].trim() ? req.headers["x-unbrowse-client-id"].trim() : "global";
   app.addHook("onRequest", async (req, reply) => {
     if (req.url === "/health" || req.url === "/v1/stats")
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unbrowse",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "Reverse-engineer any website into reusable API skills. npm CLI + local engine.",
   "type": "module",
   "bin": {

package/runtime-src/api/routes.ts

@@ -141,7 +141,7 @@ export async function registerRoutes(app: FastifyInstance) {
   const clientScopeFor = (req: { headers: Record<string, unknown>; id: string }) =>
     (typeof req.headers["x-unbrowse-client-id"] === "string" && req.headers["x-unbrowse-client-id"].trim())
       ? req.headers["x-unbrowse-client-id"].trim()
-      : req.id;
+      : "global";
 
   // Auth gate: block all routes except /health when no API key is configured
   app.addHook("onRequest", async (req, reply) => {

package/runtime-src/cli.ts

@@ -18,7 +18,7 @@ loadEnv({ quiet: true });
 loadEnv({ path: ".env.runtime", quiet: true });
 
 const BASE_URL = process.env.UNBROWSE_URL || "http://localhost:6969";
-const CLI_CLIENT_ID = process.env.UNBROWSE_CLIENT_ID || `cli-${process.ppid || process.pid}`;
+const CLI_CLIENT_ID = process.env.UNBROWSE_CLIENT_ID || "cli-local";
 
 // ---------------------------------------------------------------------------
 // Arg parser

package/runtime-src/orchestrator/index.ts

@@ -329,6 +329,37 @@ function promoteResultSnapshot(
   });
 }
 
+function buildCachedResultResponse(
+  cached: {
+    skill: SkillManifest;
+    endpointId?: string;
+    result: unknown;
+    trace: ExecutionTrace;
+    response_schema?: ResponseSchema;
+    extraction_hints?: OrchestratorResult["extraction_hints"];
+  },
+  source: "marketplace" | "live-capture",
+  timing: OrchestrationTiming,
+): OrchestratorResult {
+  const now = new Date().toISOString();
+  return {
+    result: cached.result,
+    trace: {
+      ...cached.trace,
+      trace_id: nanoid(),
+      started_at: now,
+      completed_at: now,
+      endpoint_id: cached.endpointId ?? cached.trace.endpoint_id,
+      skill_id: cached.skill.skill_id,
+    },
+    source,
+    skill: cached.skill,
+    timing,
+    response_schema: cached.response_schema,
+    extraction_hints: cached.extraction_hints,
+  };
+}
+
 function invalidateResolveCacheEntries(cacheKeys: string[], domainKeys: string[] = []): void {
   let routeCacheDirty = false;
   let domainCacheDirty = false;
@@ -670,6 +701,19 @@ export function shouldFallbackToLiveCaptureAfterAutoexecFailure(
   return autoexecFailedAll && !!contextUrl;
 }
 
+export function shouldReuseRouteResultSnapshot(
+  cached: {
+    expires: number;
+    skill: SkillManifest;
+  },
+  intent: string,
+  contextUrl?: string,
+  now = Date.now(),
+): boolean {
+  if (cached.expires <= now) return false;
+  return isCachedSkillRelevantForIntent(cached.skill, intent, contextUrl);
+}
+
 function computeCompositeScore(embeddingScore: number, skill: SkillManifest): number {
   // Average reliability across endpoints
   const reliabilities = skill.endpoints.map((e) => e.reliability_score);
@@ -1940,22 +1984,28 @@ export async function resolveAndExecute(
   if (!forceCapture && !agentChoseEndpoint) {
     const cachedResult = routeResultCache.get(cacheKey);
     if (cachedResult) {
-      if (
-        cachedResult.expires <= Date.now() ||
-        !isAcceptableIntentResult(cachedResult.result, intent) ||
-        !isCachedSkillRelevantForIntent(cachedResult.skill, intent, context?.url)
-      ) {
+      if (!shouldReuseRouteResultSnapshot(cachedResult, intent, context?.url)) {
         routeResultCache.delete(cacheKey);
       } else {
-        const deferred = await buildDeferralWithAutoExec(cachedResult.skill, "marketplace");
-        if (shouldFallbackToLiveCaptureAfterAutoexecFailure(deferred.autoexecFailedAll, context?.url)) {
-          console.log("[route-result-cache] stale cached skill; retrying via live capture");
-          invalidateResolveCacheEntries([cacheKey], requestedDomainCacheKey ? [requestedDomainCacheKey] : []);
-        } else {
-          timing.cache_hit = true;
-          deferred.orchestratorResult.timing.cache_hit = true;
-          return deferred.orchestratorResult;
-        }
+        timing.cache_hit = true;
+        writeDebugTrace("resolve", {
+          ...decisionTrace,
+          outcome: "route_result_cache_hit",
+          source: "route-cache",
+          skill_id: cachedResult.skill.skill_id,
+          selected_endpoint_id: cachedResult.endpointId ?? cachedResult.trace.endpoint_id,
+        });
+        return buildCachedResultResponse(
+          cachedResult,
+          "marketplace",
+          finalize(
+            "route-cache",
+            cachedResult.result,
+            cachedResult.skill.skill_id,
+            cachedResult.skill,
+            cachedResult.trace,
+          ),
+        );
       }
     }
   }