@opengeni/worker-bundle 1.0.0-canary.0 → 1.0.0

package/dist/{chunk-A4XQWVZK.js → chunk-3ZTRWDMN.js}

@@ -1,7 +1,17 @@
 // src/observability-metrics.ts
 import { createHash } from "crypto";
 import { errorCodeToJSON } from "@opengeni/agent-proto";
-import { SandboxBackend } from "@opengeni/contracts";
+import {
+  BundledSkillId,
+  CREDIT_GRANT_CLASSES,
+  SandboxBackend
+} from "@opengeni/contracts";
+import {
+  ACTIVE_USER_WINDOWS
+} from "@opengeni/db";
+import {
+  natsSubscriptionTerminationCounter
+} from "@opengeni/events";
 
 // src/opensandbox-kubernetes-inventory.ts
 import { readFile } from "fs/promises";
@@ -243,6 +253,12 @@ var CONTEXT_COMPACTIONS_METRIC = {
   name: "opengeni_context_compactions_total",
   help: "Total completed context compactions, by trigger."
 };
+function observabilityEventBusOptions(observability) {
+  return {
+    logger: observabilityEventLogger(observability),
+    onSubscriptionTerminated: natsSubscriptionTerminationCounter(observability)
+  };
+}
 function observabilityEventLogger(observability) {
   return {
     debug: (message, attributes) => observability.debug(message, eventAttributes(attributes)),
@@ -272,6 +288,10 @@ function eventAttributeValue(value) {
 function runtimeMetricsHooksForObservability(observability) {
   return {
     onModelCall: ({ provider, outcome, durationSeconds }) => {
+      completedOperationSpan(observability, "worker.model.call", durationSeconds, {
+        provider,
+        outcome
+      });
       observability.incrementCounter({
         name: "opengeni_model_calls_total",
         help: "Total model calls by provider and outcome.",
@@ -304,6 +324,13 @@ function runtimeMetricsHooksForObservability(observability) {
         labels: { backend, stage }
       });
     },
+    onSandboxReadinessReplacement: ({ backend, outcome }) => {
+      observability.incrementCounter({
+        name: "opengeni_sandbox_readiness_replacements_total",
+        help: "Fresh sandbox command-readiness replacement decisions by backend and outcome.",
+        labels: { backend, outcome }
+      });
+    },
     onSandboxProviderApiThrottle: ({ backend, operation }) => {
       observability.incrementCounter({
         name: "opengeni_sandbox_provider_api_throttles_total",
@@ -325,6 +352,20 @@ function runtimeMetricsHooksForObservability(observability) {
         labels: { outcome, port: String(port) }
       });
     },
+    onWorkspaceCapture: ({ backend, outcome, durationSeconds }) => {
+      if (!Number.isFinite(durationSeconds) || durationSeconds < 0) return;
+      const safeBackend = SandboxBackend.safeParse(backend).success ? backend : "unknown";
+      completedOperationSpan(observability, "worker.workspace_capture", durationSeconds, {
+        backend: safeBackend,
+        outcome
+      });
+      observability.observeHistogram({
+        name: "opengeni_workspace_capture_duration_seconds",
+        help: "Physical warm workspace capture and publication duration, including late settlement after caller timeout.",
+        labels: { backend: safeBackend, outcome },
+        value: durationSeconds
+      });
+    },
     onWorkspaceArchiveObject: ({ outcome, backend }) => {
       observability.incrementCounter({
         name: "opengeni_workspace_archive_object_total",
@@ -333,6 +374,7 @@ function runtimeMetricsHooksForObservability(observability) {
       });
     },
     onMcpToolCall: ({ outcome, durationSeconds }) => {
+      completedOperationSpan(observability, "worker.mcp.tool_call", durationSeconds, { outcome });
       observability.incrementCounter({
         name: "opengeni_mcp_tool_calls_total",
         help: "Total physical MCP tool calls by bounded structural outcome.",
@@ -1026,6 +1068,54 @@ function recordCreditBalanceGauges(observability, balances) {
   }
   creditBalanceGaugeAccounts.set(observability, current);
 }
+function recordActiveUserGauges(observability, counts) {
+  for (const window of ACTIVE_USER_WINDOWS) {
+    observability.setGauge({
+      name: "opengeni_active_users",
+      help: "Distinct managed users with authenticated activity within the window (global; use max across pods).",
+      labels: { window },
+      value: counts[window]
+    });
+  }
+}
+function recordCreditGrantGauges(observability, totals) {
+  for (const grantClass of CREDIT_GRANT_CLASSES) {
+    const total = totals[grantClass];
+    observability.setGauge({
+      name: "opengeni_credit_grants_total",
+      help: "Positive credit grants observed in the ledger since migration 0565, by grant class (global cumulative; use max across pods).",
+      labels: { grant_class: grantClass },
+      value: total.count
+    });
+    observability.setGauge({
+      name: "opengeni_credit_granted_micros_total",
+      help: "Credit micros granted in the ledger since migration 0565, by grant class (global cumulative; use max across pods).",
+      labels: { grant_class: grantClass },
+      value: total.micros
+    });
+  }
+}
+function recordVerifiedSignupTrialSwitchGauge(observability, grantsEnabled) {
+  observability.setGauge({
+    name: "opengeni_verified_signup_trial_credits_runtime_enabled",
+    help: "Whether the runtime switch allows new verified signup trial credit grants (1) or blocks them (0).",
+    value: grantsEnabled ? 1 : 0
+  });
+}
+function recordManagedAuthNewSignupsSwitchGauge(observability, signupsEnabled) {
+  observability.setGauge({
+    name: "opengeni_managed_auth_new_signups_runtime_enabled",
+    help: "Whether the runtime switch allows new managed account sign-ups (1) or has paused them (0).",
+    value: signupsEnabled ? 1 : 0
+  });
+}
+function recordVerifiedSignupTrialDeploymentFlagGauge(observability, enabled) {
+  observability.setGauge({
+    name: "opengeni_verified_signup_trial_credits_deployment_enabled",
+    help: "Whether the OPENGENI_VERIFIED_SIGNUP_TRIAL_CREDITS_ENABLED master opt-in is on (1) or off (0) in this deployment's configuration.",
+    value: enabled ? 1 : 0
+  });
+}
 function recordSandboxOrphansTerminated(observability, count) {
   if (count <= 0) {
     return;
@@ -1071,6 +1161,47 @@ function recordSandboxDeadlineRotationsRequested(observability, count) {
     amount: count
   });
 }
+function recordSandboxCommandContainment(observability, outcome) {
+  observability.incrementCounter({
+    name: "opengeni_sandbox_command_containment_total",
+    help: "Legacy retained-command containment inspections and enrolled drain commits by fixed outcome.",
+    labels: { outcome }
+  });
+}
+function recordSandboxProviderMissingBeforeCapture(observability, backend) {
+  const safeBackend = SandboxBackend.safeParse(backend).success ? backend : "unknown";
+  observability.incrementCounter({
+    name: "opengeni_sandbox_provider_missing_before_capture_total",
+    help: "Exact sandbox cold commits after definitive provider disappearance before workspace capture.",
+    labels: { backend: safeBackend }
+  });
+}
+function recordSandboxRecoveryObservationGauges(observability, observations) {
+  for (const [kind, value] of [
+    ["provider_missing_before_capture", observations.providerLosses],
+    ["checkpoint_fallback_selected", observations.fallbackSelections],
+    ["fresh_workspace_selected", observations.freshWorkspaceSelections ?? 0]
+  ]) {
+    observability.setGauge({
+      name: "opengeni_sandbox_recovery_observations_recent",
+      help: "Committed sandbox recovery observations in the last 30 minutes by fixed kind.",
+      labels: { kind },
+      value
+    });
+  }
+}
+function sandboxAutomaticRecoveryOutcome(input) {
+  if (input.lane === "fresh_workspace") return "fresh_workspace";
+  return input.groupSessionCount > 1 ? "selected_shared" : "selected";
+}
+function recordSandboxAutomaticRecoverySelected(observability, backend, outcome) {
+  const safeBackend = SandboxBackend.safeParse(backend).success ? backend : "unknown";
+  observability.incrementCounter({
+    name: "opengeni_sandbox_checkpoint_fallback_total",
+    help: "System-selected continuity after managed provider loss: verified checkpoint or empty workspace.",
+    labels: { backend: safeBackend, outcome }
+  });
+}
 function recordSandboxRotationBacklogGauges(observability, backlog) {
   const values = {
     requested: backlog.requested,
@@ -1241,6 +1372,12 @@ function turnStartupCountBucket(count) {
   return "21+";
 }
 function recordTurnStartupPhase(observability, input) {
+  completedOperationSpan(observability, `worker.prepare.${input.phase}`, input.durationSeconds, {
+    provider: input.provider,
+    backend: input.backend,
+    outcome: input.outcome,
+    ...input.phase === "claim_and_policy" && /^turn_[0-9a-f]{32}$/.test(input.executionCorrelationId ?? "") ? { correlationId: input.executionCorrelationId } : {}
+  });
   observability.observeHistogram({
     name: "opengeni_turn_startup_phase_duration_seconds",
     help: "Turn startup phase duration before the model response stream begins.",
@@ -1256,6 +1393,74 @@ function recordTurnStartupPhase(observability, input) {
     value: Math.max(0, input.durationSeconds)
   });
 }
+async function measureTurnStartupPhase(observability, input, work) {
+  const started = performance.now();
+  let outcome = "failed";
+  try {
+    const result = await work();
+    outcome = "completed";
+    return result;
+  } finally {
+    try {
+      recordTurnStartupPhase(observability, {
+        ...input,
+        outcome,
+        durationSeconds: (performance.now() - started) / 1e3
+      });
+    } catch {
+    }
+  }
+}
+function recordToolPreparationPhase(observability, input) {
+  if (input.execution === "blocking") {
+    recordTurnStartupPhase(observability, {
+      ...input,
+      phase: `tool_${input.phase}`
+    });
+    return;
+  }
+  completedOperationSpan(
+    observability,
+    `worker.tool_prepare.${input.phase}`,
+    input.durationSeconds,
+    {
+      provider: input.provider,
+      backend: input.backend,
+      outcome: input.outcome
+    }
+  );
+  observability.observeHistogram({
+    name: "opengeni_tool_background_preparation_duration_seconds",
+    help: "Nonblocking MCP preparation operations; may overlap startup and later execution.",
+    buckets: TURN_STARTUP_PHASE_BUCKETS,
+    labels: {
+      phase: input.phase,
+      provider: input.provider,
+      backend: input.backend,
+      outcome: input.outcome
+    },
+    value: Math.max(0, input.durationSeconds)
+  });
+}
+function completedOperationSpan(observability, name, durationSeconds, attributes) {
+  if (!Number.isFinite(durationSeconds) || durationSeconds < 0) return;
+  try {
+    const failed = [
+      "failed",
+      "error",
+      "provider_declared_error",
+      "auth_needed",
+      "outcome_uncertain",
+      "timeout",
+      "thrown_transport_error",
+      "thrown_protocol_error"
+    ].includes(attributes.outcome);
+    observability.startSpan(name, attributes, { startTimeMs: Date.now() - durationSeconds * 1e3 }).end({
+      ...failed ? { error: true } : {}
+    });
+  } catch {
+  }
+}
 function recordTurnSandboxEstablishPolicy(observability, input) {
   observability.incrementCounter({
     name: "opengeni_turn_sandbox_establish_policy_total",
@@ -1647,10 +1852,93 @@ function modelCallAccountContext(input) {
     accountChangedFromPrevCall
   };
 }
+function recordCodeSearchCall(observability, input) {
+  observability.incrementCounter({
+    name: "opengeni_code_search_calls_total",
+    help: "Jev-backed code_search tool calls by outcome.",
+    labels: { outcome: input.outcome }
+  });
+  observability.observeHistogram({
+    name: "opengeni_code_search_duration_seconds",
+    help: "Wall time of one code_search tool call.",
+    buckets: [0.5, 1, 2, 4, 8, 15, 30, 60],
+    labels: { outcome: input.outcome },
+    value: Math.max(0, input.durationSeconds)
+  });
+  if (input.jevRequests > 0) {
+    observability.incrementCounter({
+      name: "opengeni_code_search_jev_requests_total",
+      help: "Jev requests made by code_search.",
+      amount: input.jevRequests
+    });
+  }
+  if (input.jevCostUsd > 0) {
+    observability.incrementCounter({
+      name: "opengeni_code_search_jev_cost_micro_usd_total",
+      help: "Estimated Jev list-price cost of code_search, in micro-USD.",
+      amount: Math.round(input.jevCostUsd * 1e6)
+    });
+  }
+}
+function recordSkillRead(observability, read) {
+  observability.incrementCounter({
+    name: "opengeni_skill_reads_total",
+    help: "skill_read calls by Skill source, built-in Skill id (custom for any other Skill), result kind, and caller.",
+    labels: {
+      source: read.source ?? "unknown",
+      skill: skillReadMetricLabel(read.source, read.skill),
+      kind: read.kind,
+      caller: read.caller
+    }
+  });
+}
+function recordSkillCheckout(observability, checkout) {
+  observability.incrementCounter({
+    name: "opengeni_skill_checkouts_total",
+    help: "skill_checkout calls by outcome and whether they selected specific paths.",
+    labels: { outcome: checkout.outcome, selection: checkout.selection }
+  });
+  const phases = [
+    ["resolve", checkout.resolveSeconds],
+    ["sandbox", checkout.sandboxSeconds],
+    ["write", checkout.writeSeconds],
+    ["total", checkout.totalSeconds]
+  ];
+  for (const [phase, seconds] of phases) {
+    if (seconds === null) continue;
+    observability.observeHistogram({
+      name: "opengeni_skill_checkout_duration_seconds",
+      help: "Wall time of skill_checkout phases: resolve (authority and Skill read), sandbox (filesystem handle, including lazy box start), write (batched file write), and total.",
+      buckets: [0.05, 0.1, 0.25, 0.5, 1, 2, 4, 8, 15, 30, 60],
+      labels: { phase, outcome: checkout.outcome },
+      value: Math.max(0, seconds)
+    });
+  }
+  for (const [result, amount] of [
+    ["written", checkout.written],
+    ["unchanged", checkout.unchanged]
+  ]) {
+    if (amount <= 0) continue;
+    observability.incrementCounter({
+      name: "opengeni_skill_checkout_files_total",
+      help: "Files skill_checkout wrote or found already present with the same content.",
+      labels: { result },
+      amount
+    });
+  }
+}
+function skillReadMetricLabel(source, skill) {
+  if (source !== null && source !== "builtin") return "custom";
+  for (const candidate of source === null ? [skill, `builtin:${skill}`] : [skill]) {
+    const parsed = BundledSkillId.safeParse(candidate);
+    if (parsed.success) return parsed.data;
+  }
+  return "custom";
+}
 
 export {
   inspectOpenSandboxKubernetesInventory,
-  observabilityEventLogger,
+  observabilityEventBusOptions,
   runtimeMetricsHooksForObservability,
   makeMachineOpObserver,
   turnLifecycleMetricsFor,
@@ -1668,10 +1956,20 @@ export {
   recordSandboxInventoryProjectionSuccess,
   recordSandboxInventoryProjectionFailure,
   recordCreditBalanceGauges,
+  recordActiveUserGauges,
+  recordCreditGrantGauges,
+  recordVerifiedSignupTrialSwitchGauge,
+  recordManagedAuthNewSignupsSwitchGauge,
+  recordVerifiedSignupTrialDeploymentFlagGauge,
   recordSandboxOrphansTerminated,
   recordSandboxCheckpointArtifactGauges,
   recordSandboxCheckpointArtifactOutcome,
   recordSandboxDeadlineRotationsRequested,
+  recordSandboxCommandContainment,
+  recordSandboxProviderMissingBeforeCapture,
+  recordSandboxRecoveryObservationGauges,
+  sandboxAutomaticRecoveryOutcome,
+  recordSandboxAutomaticRecoverySelected,
   recordSandboxRotationBacklogGauges,
   recordRetainedProcessInventoryGauges,
   recordExpiredDrainingSandboxLeaseGauges,
@@ -1679,6 +1977,8 @@ export {
   recordCreditMicros,
   recordModelRequestPhase,
   recordTurnStartupPhase,
+  measureTurnStartupPhase,
+  recordToolPreparationPhase,
   recordTurnSandboxEstablishPolicy,
   recordSandboxProvisionAttempt,
   recordSandboxLogicalProvision,
@@ -1695,6 +1995,9 @@ export {
   recordContextCompactionStarted,
   recordCompanyBrainContributions,
   recordModelCacheTokens,
-  modelCallAccountContext
+  modelCallAccountContext,
+  recordCodeSearchCall,
+  recordSkillRead,
+  recordSkillCheckout
 };
-//# sourceMappingURL=chunk-A4XQWVZK.js.map
+//# sourceMappingURL=chunk-3ZTRWDMN.js.map