@stjbrown/agent-knowledge 0.1.0-beta.4 → 0.1.0-beta.5

package/dist/{chunk-H4H6S4AV.js → chunk-EBMACGJV.js}

@@ -59,13 +59,237 @@ function bundledSkillsDir() {
   return resolve(here, "..", "..", "..", "..", "skills");
 }
 
+// src/observability/config.ts
+import { z } from "zod";
+
+// src/observability/types.ts
+var OBSERVABILITY_CAPTURE_MODES = ["off", "metadata", "full"];
+var OBSERVABILITY_REMOTE_KINDS = ["phoenix", "otlp"];
+
+// src/observability/config.ts
+var DEFAULT_OBSERVABILITY_SETTINGS = {
+  capture: "off",
+  sampleRate: 1,
+  local: {
+    enabled: false,
+    retentionDays: 7
+  }
+};
+var captureModeSchema = z.enum(OBSERVABILITY_CAPTURE_MODES);
+var remoteKindSchema = z.enum(OBSERVABILITY_REMOTE_KINDS);
+var persistedEndpointSchema = z.string().min(1).refine((value) => {
+  try {
+    const url = new URL(value);
+    return (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password && !url.search && !url.hash;
+  } catch {
+    return false;
+  }
+});
+var observabilitySettingsSchema = z.object({
+  capture: captureModeSchema,
+  sampleRate: z.number().min(0).max(1).optional(),
+  local: z.object({
+    enabled: z.boolean(),
+    retentionDays: z.number().int().min(1).max(3650).optional()
+  }).optional(),
+  remote: z.object({
+    kind: remoteKindSchema,
+    endpoint: persistedEndpointSchema,
+    projectName: z.string().min(1).optional()
+  }).optional()
+});
+function normalizeObservabilitySettings(value) {
+  if (value === void 0) return void 0;
+  const parsed = observabilitySettingsSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+function enumValue(value, allowed) {
+  const normalized = value?.trim().toLowerCase();
+  return normalized && allowed.includes(normalized) ? normalized : void 0;
+}
+function numberValue(value) {
+  if (value === void 0 || value.trim() === "") return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function validHttpEndpoint(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function decodeHeaderValue(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function parseOtelHeaders(value) {
+  if (!value?.trim()) return {};
+  const headers = {};
+  for (const item of value.split(",")) {
+    const separator = item.indexOf("=");
+    if (separator <= 0) continue;
+    const key = item.slice(0, separator).trim();
+    const rawValue = item.slice(separator + 1).trim();
+    if (key) headers[key] = decodeHeaderValue(rawValue);
+  }
+  return headers;
+}
+function remoteFromEnvironment(kind, env, saved) {
+  const endpoint = kind === "phoenix" ? env["PHOENIX_COLLECTOR_ENDPOINT"]?.trim() || env["OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"]?.trim() || env["OTEL_EXPORTER_OTLP_ENDPOINT"]?.trim() || saved?.endpoint || "http://localhost:6006" : env["OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"]?.trim() || env["OTEL_EXPORTER_OTLP_ENDPOINT"]?.trim() || saved?.endpoint;
+  if (!endpoint) return void 0;
+  const projectName = kind === "phoenix" ? env["PHOENIX_PROJECT_NAME"]?.trim() || saved?.projectName || "janet" : saved?.projectName;
+  const headers = parseOtelHeaders(env["OTEL_EXPORTER_OTLP_HEADERS"]);
+  const hasProjectHeader = Object.keys(headers).some(
+    (key) => key.toLowerCase() === "x-project-name"
+  );
+  if (kind === "phoenix" && projectName && !hasProjectHeader) {
+    headers["x-project-name"] = projectName;
+  }
+  return {
+    kind,
+    endpoint,
+    ...projectName ? { projectName } : {},
+    headers
+  };
+}
+function resolveObservabilityConfig(saved, env = process.env) {
+  const warnings = [];
+  const savedSettings = saved ?? DEFAULT_OBSERVABILITY_SETTINGS;
+  const captureEnv = enumValue(env["JANET_OBSERVABILITY"], OBSERVABILITY_CAPTURE_MODES);
+  if (env["JANET_OBSERVABILITY"] && !captureEnv) {
+    warnings.push(
+      "Ignoring invalid JANET_OBSERVABILITY value; use off, metadata, or full."
+    );
+  }
+  const capture = captureEnv ?? savedSettings.capture;
+  const rateEnv = numberValue(env["JANET_OBSERVABILITY_SAMPLE_RATE"]);
+  if (env["JANET_OBSERVABILITY_SAMPLE_RATE"] !== void 0 && (rateEnv === void 0 || rateEnv < 0 || rateEnv > 1)) {
+    warnings.push("Ignoring invalid JANET_OBSERVABILITY_SAMPLE_RATE; use a value from 0 to 1.");
+  }
+  const sampleRate = rateEnv !== void 0 && rateEnv >= 0 && rateEnv <= 1 ? rateEnv : savedSettings.sampleRate ?? 1;
+  let local = {
+    enabled: savedSettings.local?.enabled ?? false,
+    retentionDays: savedSettings.local?.retentionDays ?? 7
+  };
+  let remote;
+  let explicitRemoteBackend = false;
+  const backendEnv = enumValue(
+    env["JANET_OBSERVABILITY_BACKEND"],
+    ["local", ...OBSERVABILITY_REMOTE_KINDS]
+  );
+  if (env["JANET_OBSERVABILITY_BACKEND"] && !backendEnv) {
+    warnings.push(
+      "Ignoring invalid JANET_OBSERVABILITY_BACKEND value; use local, phoenix, or otlp."
+    );
+  }
+  if (backendEnv === "local") {
+    local = { ...local, enabled: true };
+  } else if (backendEnv === "phoenix" || backendEnv === "otlp") {
+    explicitRemoteBackend = true;
+    local = { ...local, enabled: false };
+    remote = remoteFromEnvironment(backendEnv, env, savedSettings.remote);
+  } else if (savedSettings.remote) {
+    remote = remoteFromEnvironment(savedSettings.remote.kind, env, savedSettings.remote);
+  } else if (capture !== "off" && env["PHOENIX_COLLECTOR_ENDPOINT"]) {
+    remote = remoteFromEnvironment("phoenix", env);
+    local = { ...local, enabled: false };
+  } else if (capture !== "off" && (env["OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"] || env["OTEL_EXPORTER_OTLP_ENDPOINT"])) {
+    remote = remoteFromEnvironment("otlp", env);
+    local = { ...local, enabled: false };
+  }
+  if (remote && !validHttpEndpoint(remote.endpoint)) {
+    warnings.push("The observability endpoint is not a valid HTTP(S) URL.");
+    remote = void 0;
+  }
+  if (capture !== "off" && !local.enabled && !remote && !explicitRemoteBackend) {
+    local = { ...local, enabled: true };
+  }
+  if (capture !== "off" && explicitRemoteBackend && !remote) {
+    warnings.push("The selected remote observability backend has no endpoint.");
+  }
+  const enabled = capture !== "off" && (local.enabled || remote !== void 0);
+  return {
+    enabled,
+    capture,
+    sampleRate,
+    local: enabled ? local : { ...local, enabled: false },
+    ...enabled && remote ? { remote } : {},
+    warnings
+  };
+}
+
+// src/onboarding/settings.ts
+import { mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+var ONBOARDING_VERSION = 1;
+function settingsPath() {
+  return join2(appDataDir(), "settings.json");
+}
+function loadSettings() {
+  try {
+    const value = JSON.parse(readFileSync(settingsPath(), "utf-8"));
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+    const raw = value;
+    const settings = {};
+    if (typeof raw["onboarding"] === "object" && raw["onboarding"] !== null && !Array.isArray(raw["onboarding"])) {
+      const onboarding = raw["onboarding"];
+      if (typeof onboarding["completedAt"] === "string" && typeof onboarding["version"] === "number") {
+        settings.onboarding = {
+          completedAt: onboarding["completedAt"],
+          version: onboarding["version"]
+        };
+      }
+    }
+    if (typeof raw["defaultModelId"] === "string") {
+      settings.defaultModelId = raw["defaultModelId"];
+    }
+    if (Array.isArray(raw["customModels"]) && raw["customModels"].every((model) => typeof model === "string")) {
+      settings.customModels = raw["customModels"];
+    }
+    const observability = normalizeObservabilitySettings(raw["observability"]);
+    if (observability) settings.observability = observability;
+    return settings;
+  } catch {
+    return {};
+  }
+}
+function saveSettings(settings) {
+  const p = settingsPath();
+  mkdirSync2(dirname2(p), { recursive: true });
+  writeFileSync(p, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+}
+function completeOnboarding(modelId, stampedAt) {
+  const settings = loadSettings();
+  settings.defaultModelId = modelId;
+  settings.onboarding = { completedAt: stampedAt, version: ONBOARDING_VERSION };
+  saveSettings(settings);
+}
+function rememberModel(modelId) {
+  const id = modelId.trim();
+  if (!id) return;
+  const settings = loadSettings();
+  const rest = (settings.customModels ?? []).filter((m) => m !== id);
+  settings.customModels = [id, ...rest].slice(0, 20);
+  saveSettings(settings);
+}
+function rememberObservability(observability) {
+  const settings = loadSettings();
+  settings.observability = observability;
+  saveSettings(settings);
+}
+
 // src/gateways/oauth/claude-max.ts
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { wrapLanguageModel } from "ai";
 
 // src/auth/storage.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync, chmodSync } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2, chmodSync } from "fs";
+import { dirname as dirname3, join as join3 } from "path";
 
 // src/auth/authorization-input.ts
 function parseAuthorizationInput(input) {
@@ -739,7 +963,7 @@ function getOAuthProvider(id) {
   return oauthProviderRegistry.get(id);
 }
 var AuthStorage = class {
-  constructor(authPath = join2(appDataDir(), "auth.json")) {
+  constructor(authPath = join3(appDataDir(), "auth.json")) {
     this.authPath = authPath;
     this.reload();
   }
@@ -754,7 +978,7 @@ var AuthStorage = class {
       return;
     }
     try {
-      this.data = JSON.parse(readFileSync(this.authPath, "utf-8"));
+      this.data = JSON.parse(readFileSync2(this.authPath, "utf-8"));
     } catch {
       this.data = {};
     }
@@ -763,11 +987,11 @@ var AuthStorage = class {
    * Save credentials to disk.
    */
   save() {
-    const dir = dirname2(this.authPath);
+    const dir = dirname3(this.authPath);
     if (!existsSync2(dir)) {
-      mkdirSync2(dir, { recursive: true, mode: 448 });
+      mkdirSync3(dir, { recursive: true, mode: 448 });
     }
-    writeFileSync(this.authPath, JSON.stringify(this.data, null, 2), "utf-8");
+    writeFileSync2(this.authPath, JSON.stringify(this.data, null, 2), "utf-8");
     chmodSync(this.authPath, 384);
   }
   /**
@@ -1075,18 +1299,226 @@ Never repeat a tool call that already failed the same way. If fetching or scrapi
 Answer from the bundle. When you state something the bundle records, cite the concept it came from. If the bundle doesn't cover something, say so plainly rather than guessing \u2014 "I don't have that in the bundle yet, but I can ingest a source about it."`;
 var GREETING = "Hi there! I'm Janet.";
 
+// src/version.ts
+import { readFileSync as readFileSync3 } from "fs";
+var packageJsonUrl = new URL("../package.json", import.meta.url);
+function packageVersion() {
+  const metadata = JSON.parse(readFileSync3(packageJsonUrl, "utf8"));
+  if (typeof metadata !== "object" || metadata === null || !("version" in metadata) || typeof metadata.version !== "string") {
+    throw new Error("Janet's package metadata does not contain a version");
+  }
+  return metadata.version;
+}
+
+// src/observability/runtime.ts
+import { SpanType } from "@mastra/core/observability";
+import {
+  MastraStorageExporter,
+  Observability,
+  SamplingStrategyType
+} from "@mastra/observability";
+import { OtelExporter } from "@mastra/otel-exporter";
+
+// src/agent/storage.ts
+import { join as join4 } from "path";
+import { LibSQLStore } from "@mastra/libsql";
+import { MastraCompositeStore } from "@mastra/core/storage";
+function observabilityDbPath(globalConfigDir) {
+  return join4(globalConfigDir, "observability.db");
+}
+var JanetCompositeStorage = class extends MastraCompositeStore {
+  constructor(threadStore, observabilityStore, retentionDays) {
+    super({
+      id: "agent-knowledge-storage",
+      default: threadStore,
+      domains: {
+        observability: observabilityStore.stores.observability
+      },
+      retention: {
+        observability: {
+          spans: { maxAge: `${retentionDays}d` }
+        }
+      }
+    });
+    this.threadStore = threadStore;
+    this.observabilityStore = observabilityStore;
+  }
+  threadStore;
+  observabilityStore;
+  async close() {
+    const results = await Promise.allSettled([
+      this.threadStore.close(),
+      this.observabilityStore.close()
+    ]);
+    const failure = results.find(
+      (result) => result.status === "rejected"
+    );
+    if (failure) throw failure.reason;
+  }
+};
+function createStorage(globalConfigDir, options = {}) {
+  ensureDir(globalConfigDir);
+  const threadStore = new LibSQLStore({
+    id: "agent-knowledge-threads",
+    url: `file:${join4(globalConfigDir, "threads.db")}`
+  });
+  if (!options.localObservability?.enabled) return threadStore;
+  const observabilityStore = new LibSQLStore({
+    id: "agent-knowledge-observability",
+    url: `file:${observabilityDbPath(globalConfigDir)}`
+  });
+  return new JanetCompositeStorage(
+    threadStore,
+    observabilityStore,
+    options.localObservability.retentionDays
+  );
+}
+
+// src/observability/runtime.ts
+function safeObservabilityEndpoint(endpoint) {
+  try {
+    const url = new URL(endpoint);
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/$/, "");
+  } catch {
+    return "(invalid endpoint)";
+  }
+}
+function statusFor(config) {
+  const destinations = [];
+  if (config.local.enabled) destinations.push("local");
+  if (config.remote) {
+    destinations.push(
+      config.remote.kind === "phoenix" ? `phoenix (${safeObservabilityEndpoint(config.remote.endpoint)})` : `otlp (${safeObservabilityEndpoint(config.remote.endpoint)})`
+    );
+  }
+  return {
+    enabled: config.enabled,
+    capture: config.capture,
+    sampleRate: config.sampleRate,
+    destinations,
+    warnings: [...config.warnings]
+  };
+}
+function formatObservabilityStatus(status) {
+  if (!status.enabled) {
+    return status.warnings.length ? `off (${status.warnings.join(" ")})` : "off";
+  }
+  const sample = status.sampleRate === 1 ? "" : `, ${Math.round(status.sampleRate * 100)}% sampling`;
+  return `${status.capture} to ${status.destinations.join(" + ")}${sample}`;
+}
+function createObservabilityRuntime(globalConfigDir, config) {
+  const storage = createStorage(globalConfigDir, {
+    localObservability: config.local
+  });
+  let observability;
+  if (config.enabled) {
+    const exporters = [];
+    if (config.local.enabled) {
+      exporters.push(
+        new MastraStorageExporter({
+          maxBatchSize: 50,
+          maxBufferSize: 500,
+          maxBatchWaitMs: 1e3,
+          strategy: "auto"
+        })
+      );
+    }
+    if (config.remote) {
+      exporters.push(
+        new OtelExporter({
+          provider: {
+            custom: {
+              endpoint: config.remote.endpoint,
+              protocol: "http/protobuf",
+              headers: config.remote.headers
+            }
+          },
+          signals: {
+            traces: true,
+            logs: false
+          },
+          timeout: 1e4,
+          batchSize: 50,
+          resourceAttributes: config.remote.kind === "phoenix" && config.remote.projectName ? { "openinference.project.name": config.remote.projectName } : void 0
+        })
+      );
+    }
+    observability = new Observability({
+      configs: {
+        janet: {
+          serviceName: "janet",
+          sampling: config.sampleRate === 1 ? { type: SamplingStrategyType.ALWAYS } : {
+            type: SamplingStrategyType.RATIO,
+            probability: config.sampleRate
+          },
+          exporters,
+          includeInternalSpans: false,
+          excludeSpanTypes: [SpanType.MODEL_CHUNK],
+          requestContextKeys: [],
+          serializationOptions: {
+            maxStringLength: 2e3,
+            maxDepth: 5,
+            maxArrayLength: 50,
+            maxObjectKeys: 50
+          },
+          logging: {
+            enabled: false
+          }
+        }
+      },
+      sensitiveDataFilter: true
+    });
+  }
+  return {
+    config,
+    status: statusFor(config),
+    observability,
+    storage,
+    tracingOptionsForTurn(context) {
+      if (!config.enabled) return void 0;
+      return {
+        metadata: {
+          "janet.version": packageVersion(),
+          "janet.mode": context.interactive ? "interactive" : "headless",
+          "janet.operation": context.operation,
+          "janet.capture": config.capture,
+          "janet.resource_id": context.resourceId,
+          ...context.threadId ? { "janet.thread_id": context.threadId } : {}
+        },
+        tags: ["janet", context.operation],
+        hideInput: config.capture !== "full",
+        hideOutput: config.capture !== "full"
+      };
+    },
+    async flush() {
+      await observability?.flush();
+    },
+    async prune() {
+      if (!config.local.enabled) return;
+      await storage.prune({
+        maxBatches: 1,
+        maxRows: 1e3
+      });
+    }
+  };
+}
+
 // src/agent/controller.ts
 import { AgentController } from "@mastra/core/agent-controller";
-import { z } from "zod";
+import { z as z2 } from "zod";
 
 // src/agent/agent.ts
 import { Agent } from "@mastra/core/agent";
 import { Memory } from "@mastra/memory";
 
 // src/gateways/vertex.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 import { createVertex } from "@ai-sdk/google-vertex";
 import { createVertexAnthropic } from "@ai-sdk/google-vertex/anthropic";
 import { wrapLanguageModel as wrapLanguageModel2 } from "ai";
@@ -1097,13 +1529,13 @@ function hasGoogleCredentials() {
     return true;
   }
   const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir2();
-  return existsSync3(join3(home, ".config", "gcloud", "application_default_credentials.json"));
+  return existsSync3(join5(home, ".config", "gcloud", "application_default_credentials.json"));
 }
 function adcQuotaProject() {
   const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir2();
-  const adcPath = join3(home, ".config", "gcloud", "application_default_credentials.json");
+  const adcPath = join5(home, ".config", "gcloud", "application_default_credentials.json");
   try {
-    const adc = JSON.parse(readFileSync2(adcPath, "utf-8"));
+    const adc = JSON.parse(readFileSync4(adcPath, "utf-8"));
     return adc.quota_project_id || void 0;
   } catch {
     return void 0;
@@ -1200,7 +1632,7 @@ function createVertexGateway() {
 // src/gateways/bedrock.ts
 import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
 import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
 import { MastraModelGateway as MastraModelGateway2 } from "@mastra/core/llm";
@@ -1211,9 +1643,9 @@ function hasAwsCredentials() {
   }
   const home = process.env["HOME"] || process.env["USERPROFILE"] || homedir3();
   if (home) {
-    const awsDir = join4(home, ".aws");
-    const credentialsPath = process.env["AWS_SHARED_CREDENTIALS_FILE"] ?? join4(awsDir, "credentials");
-    const configPath = process.env["AWS_CONFIG_FILE"] ?? join4(awsDir, "config");
+    const awsDir = join6(home, ".aws");
+    const credentialsPath = process.env["AWS_SHARED_CREDENTIALS_FILE"] ?? join6(awsDir, "credentials");
+    const configPath = process.env["AWS_CONFIG_FILE"] ?? join6(awsDir, "config");
     if (existsSync4(credentialsPath) || existsSync4(configPath)) return true;
   }
   return false;
@@ -1604,15 +2036,6 @@ function createJanetAgent(opts) {
   });
 }
 
-// src/agent/storage.ts
-import { join as join5 } from "path";
-import { LibSQLStore } from "@mastra/libsql";
-function createStorage(globalConfigDir) {
-  ensureDir(globalConfigDir);
-  const dbPath = join5(globalConfigDir, "threads.db");
-  return new LibSQLStore({ id: "agent-knowledge-threads", url: `file:${dbPath}` });
-}
-
 // src/agent/workspace.ts
 import {
   LocalFilesystem,
@@ -1879,19 +2302,19 @@ function attachHerdrReporter(session, opts) {
 }
 
 // src/agent/controller.ts
-var policy = z.enum(["allow", "ask", "deny"]);
-var permissionRules = z.object({
-  categories: z.record(z.string(), policy),
-  tools: z.record(z.string(), policy)
+var policy = z2.enum(["allow", "ask", "deny"]);
+var permissionRules = z2.object({
+  categories: z2.record(z2.string(), policy),
+  tools: z2.record(z2.string(), policy)
 });
-var stateSchema = z.object({
-  projectPath: z.string(),
-  bundlePath: z.string(),
-  configDir: z.string(),
+var stateSchema = z2.object({
+  projectPath: z2.string(),
+  bundlePath: z2.string(),
+  configDir: z2.string(),
   // Core's approval gate reads `state.yolo === true`. Janet enables normal
   // in-loop tool execution and puts approval on the dangerous tools themselves;
   // denied headless categories are still removed from the active tool set.
-  yolo: z.boolean(),
+  yolo: z2.boolean(),
   // Tool-approval rules by category/tool. Must be in the schema or session state
   // strips it, and setForCategory / getRules silently no-op.
   permissionRules: permissionRules.optional()
@@ -1919,7 +2342,12 @@ async function resumeThread(session, threadId) {
 }
 async function bootJanet(opts) {
   const paths = resolveProjectPaths({ dir: opts.dir, bundle: opts.bundle });
-  const storage = createStorage(paths.globalConfigDir);
+  const observabilityConfig = resolveObservabilityConfig(loadSettings().observability);
+  const observability = createObservabilityRuntime(
+    paths.globalConfigDir,
+    observabilityConfig
+  );
+  const storage = observability.storage;
   const skills = ensureSkillLinks(paths.projectPath);
   const workspace = createWorkspace({
     projectPath: paths.projectPath,
@@ -1952,16 +2380,19 @@ async function bootJanet(opts) {
       yolo: true,
       permissionRules: permissionRulesFor(opts)
     },
-    workspace: () => workspace
+    workspace: () => workspace,
+    ...observability.observability ? { observability: observability.observability } : {}
   });
   await controller.init();
+  await observability.prune().catch(() => {
+  });
   const session = await controller.createSession({
     resourceId: paths.resourceId,
     ownerId: paths.ownerId
   });
   await resumeThread(session, opts.threadId);
   const herdrDetach = attachHerdrReporter(session, { projectPath: paths.projectPath });
-  return { controller, session, paths, herdrDetach };
+  return { controller, session, paths, herdrDetach, observability };
 }
 
 // src/headless/format.ts
@@ -2001,13 +2432,20 @@ function messageToolNames(message) {
 
 export {
   resolveProjectPaths,
-  appDataDir,
+  resolveObservabilityConfig,
+  loadSettings,
+  completeOnboarding,
+  rememberModel,
+  rememberObservability,
   hasGoogleCredentials,
   hasAwsCredentials,
   getAuthStorage,
   GREETING,
+  packageVersion,
+  safeObservabilityEndpoint,
+  formatObservabilityStatus,
   bootJanet,
   messageText,
   messageToolNames
 };
-//# sourceMappingURL=chunk-H4H6S4AV.js.map
+//# sourceMappingURL=chunk-EBMACGJV.js.map