orchajs 0.21.0 → 0.22.0

package/dist/runtime/create-orcha.d.ts

@@ -4,6 +4,10 @@ import type { AgentRuntime, CompiledBundle, OrchaInitConfiguration } from "../ty
 export interface Orcha {
     init(configuration: OrchaInitConfiguration): OrchaClient;
     isInitialized(): boolean;
+    /** Flushes queued Amarsia telemetry without blocking normal agent runs. */
+    flushTelemetry(options?: {
+        timeoutMs?: number;
+    }): Promise<void>;
     /** @internal Used by the development compiler. */
     getCompiledBundle(): CompiledBundle;
 }

package/dist/runtime/create-orcha.js

@@ -1,9 +1,11 @@
 import { RuntimeAgent } from "./agent.js";
+import { AmarsiaTelemetryClient, withAmarsiaTelemetry, } from "../amarsia/analytics.js";
 import { setOrchaRuntimeContext } from "./context.js";
 class OrchaRuntimeCore {
     #agents = new Map();
     #bundle;
     #client;
+    #telemetry;
     #activeSessions = new Set();
     #sessionControls = new Map();
     #resolveBundle;
@@ -18,6 +20,9 @@ class OrchaRuntimeCore {
         this.#client = client;
     }
     init(configuration) {
+        if (this.#telemetry) {
+            void this.#telemetry.close();
+        }
         const projectRoot = this.#platform.projectRoot(configuration);
         const bundle = configuration.bundle ?? this.#resolveBundle(configuration);
         if (configuration.amarsia?.key && this.#platform.syncProject) {
@@ -47,6 +52,16 @@ class OrchaRuntimeCore {
             projectRoot,
             manifest,
         });
+        const telemetry = configuration.amarsia?.key
+            ? new AmarsiaTelemetryClient(configuration.amarsia)
+            : undefined;
+        this.#telemetry = telemetry;
+        const createRuntimeStore = (manifest) => {
+            const store = createStore(manifest);
+            return telemetry
+                ? withAmarsiaTelemetry({ store, manifest, client: telemetry })
+                : store;
+        };
         const agents = new Map();
         for (const [name, manifest] of Object.entries(bundle.agents)) {
             const subagents = Object.fromEntries(Object.entries(manifest.subagents ?? {}).map(([subagentName, subagentManifest]) => [
@@ -54,7 +69,7 @@ class OrchaRuntimeCore {
                 new RuntimeAgent({
                     manifest: subagentManifest,
                     configuration: runtimeConfiguration,
-                    store: createStore(subagentManifest),
+                    store: createRuntimeStore(subagentManifest),
                     activeSessions: this.#activeSessions,
                     sessionControls: this.#sessionControls,
                     generateProviderResponse: this.#generateProviderResponse,
@@ -66,7 +81,7 @@ class OrchaRuntimeCore {
             agents.set(name, new RuntimeAgent({
                 manifest,
                 configuration: runtimeConfiguration,
-                store: createStore(manifest),
+                store: createRuntimeStore(manifest),
                 activeSessions: this.#activeSessions,
                 sessionControls: this.#sessionControls,
                 generateProviderResponse: this.#generateProviderResponse,
@@ -89,6 +104,9 @@ class OrchaRuntimeCore {
     isInitialized() {
         return this.#bundle !== undefined;
     }
+    async flushTelemetry(options) {
+        await this.#telemetry?.drain(options);
+    }
     getCompiledBundle() {
         if (!this.#bundle) {
             throw new Error("Orcha has not been initialized.");

package/dist/types.d.ts

@@ -64,6 +64,57 @@ export interface OrchaInitConfiguration {
     storage?: ProjectConfiguration["storage"];
     root?: string;
 }
+/** Privacy-safe, versioned run fact sent to Amarsia when `amarsia.key` is set. */
+export interface AmarsiaTelemetryRunV1 {
+    event_id: string;
+    agent_external_id: string;
+    session_id: string;
+    run_number: number;
+    parent_agent_external_id?: string;
+    parent_session_id?: string;
+    status: string;
+    provider: string;
+    model: string;
+    region?: string;
+    output_type?: string;
+    stop_reason?: string;
+    started_at: string;
+    ended_at?: string;
+    duration_ms?: number;
+    model_duration_ms: number;
+    action_duration_ms: number;
+    input_tokens: number;
+    output_tokens: number;
+    reasoning_tokens?: number;
+    cache_read_tokens: number;
+    cache_write_tokens: number;
+    user_message_count: number;
+    assistant_message_count: number;
+    action_count: number;
+    action_success_count: number;
+    action_failure_count: number;
+    subagent_count: number;
+    actions: AmarsiaTelemetryActionV1[];
+    evaluation_count: number;
+    evaluation_pass_count: number;
+    error_code?: string;
+    error_message?: string;
+    error_retryable?: boolean;
+}
+export interface AmarsiaTelemetryActionV1 {
+    call_id: string;
+    name: string;
+    status: "completed" | "failed";
+    started_at: string;
+    ended_at: string;
+    duration_ms: number;
+    error_code?: string;
+    error_message?: string;
+}
+export interface AmarsiaTelemetryBatchV1 {
+    schema_version: 1;
+    runs: AmarsiaTelemetryRunV1[];
+}
 export interface SubagentConfiguration {
     maxPerRun?: number;
 }

package/dist-cjs/amarsia/analytics.js

@@ -0,0 +1,447 @@
+"use strict"; const __orchaImportMetaUrl = require("url").pathToFileURL(__filename).href;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var analytics_exports = {};
+__export(analytics_exports, {
+  AmarsiaTelemetryClient: () => AmarsiaTelemetryClient,
+  withAmarsiaTelemetry: () => withAmarsiaTelemetry
+});
+module.exports = __toCommonJS(analytics_exports);
+var import_endpoint = require("./endpoint.js");
+const RELEVANT_EVENTS = /* @__PURE__ */ new Set([
+  "run.started",
+  "run.completed",
+  "run.failed",
+  "run.paused",
+  "evaluation.completed",
+  "evaluation.failed"
+]);
+const MAX_BATCH_RUNS = 100;
+const MAX_KEEPALIVE_BYTES = 48 * 1024;
+const HEARTBEAT_INTERVAL_MS = 3e4;
+class AmarsiaTelemetryClient {
+  #key;
+  #baseUrl;
+  #queue = /* @__PURE__ */ new Map();
+  #activeRuns = /* @__PURE__ */ new Map();
+  #timer;
+  #heartbeatTimer;
+  #attempt = 0;
+  #flushPromise;
+  constructor(options) {
+    this.#key = options.key;
+    this.#baseUrl = (0, import_endpoint.resolveAmarsiaEndpoint)(options.endpoint);
+  }
+  enqueue(fact) {
+    this.#queue.set(fact.event_id, fact);
+    if (fact.status === "running") {
+      this.#activeRuns.set(fact.event_id, fact);
+      this.#scheduleHeartbeat();
+    } else {
+      this.#activeRuns.delete(fact.event_id);
+      if (this.#activeRuns.size === 0 && this.#heartbeatTimer) {
+        clearTimeout(this.#heartbeatTimer);
+        this.#heartbeatTimer = void 0;
+      }
+    }
+    if (fact.status !== "running") {
+      this.#scheduleTerminal();
+      return;
+    }
+    if (this.#queue.size >= 20) {
+      void this.#flush();
+      return;
+    }
+    this.#schedule(250);
+  }
+  #schedule(delay) {
+    if (this.#timer) return;
+    this.#timer = setTimeout(() => {
+      this.#timer = void 0;
+      void this.#flush();
+    }, delay);
+    const timer = this.#timer;
+    timer.unref?.();
+  }
+  #scheduleTerminal() {
+    if (this.#timer) clearTimeout(this.#timer);
+    this.#timer = setTimeout(() => {
+      this.#timer = void 0;
+      void this.#flush();
+    }, 0);
+  }
+  #scheduleHeartbeat() {
+    if (this.#heartbeatTimer || this.#activeRuns.size === 0) return;
+    this.#heartbeatTimer = setTimeout(() => {
+      this.#heartbeatTimer = void 0;
+      for (const fact of this.#activeRuns.values()) {
+        this.#queue.set(fact.event_id, fact);
+      }
+      void this.#flush();
+      this.#scheduleHeartbeat();
+    }, HEARTBEAT_INTERVAL_MS);
+    const timer = this.#heartbeatTimer;
+    timer.unref?.();
+  }
+  async drain(options = {}) {
+    const timeoutMs = Math.max(0, options.timeoutMs ?? 2e3);
+    const deadline = Date.now() + timeoutMs;
+    if (this.#timer) {
+      clearTimeout(this.#timer);
+      this.#timer = void 0;
+    }
+    while (this.#queue.size > 0 || this.#flushPromise) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) return;
+      await Promise.race([
+        this.#flush(),
+        new Promise((resolve) => setTimeout(resolve, remaining))
+      ]);
+    }
+  }
+  async close(options = {}) {
+    if (this.#heartbeatTimer) {
+      clearTimeout(this.#heartbeatTimer);
+      this.#heartbeatTimer = void 0;
+    }
+    this.#activeRuns.clear();
+    await this.drain(options);
+  }
+  async #flush() {
+    if (this.#flushPromise) return this.#flushPromise;
+    if (this.#queue.size === 0) return;
+    this.#flushPromise = this.#performFlush();
+    try {
+      await this.#flushPromise;
+    } finally {
+      this.#flushPromise = void 0;
+      if (this.#queue.size > 0 && !this.#timer) {
+        const hasTerminalFact = [...this.#queue.values()].some(
+          (fact) => fact.status !== "running"
+        );
+        if (hasTerminalFact) {
+          void this.#flush();
+        } else {
+          this.#schedule(250);
+        }
+      }
+    }
+  }
+  async #performFlush() {
+    const batch = takeBatch(this.#queue);
+    if (batch.length === 0) return;
+    const body = JSON.stringify({
+      schema_version: 1,
+      runs: batch
+    });
+    for (const fact of batch) this.#queue.delete(fact.event_id);
+    try {
+      const response = await fetch(
+        `${this.#baseUrl}/v3/project-analytics/runs/batch`,
+        {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "x-amarsia-project-key": this.#key
+          },
+          keepalive: utf8ByteLength(body) <= MAX_KEEPALIVE_BYTES,
+          body
+        }
+      );
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      this.#attempt = 0;
+    } catch {
+      this.#attempt += 1;
+      if (this.#attempt <= 6) {
+        for (const fact of batch) {
+          if (!this.#queue.has(fact.event_id)) {
+            this.#queue.set(fact.event_id, fact);
+          }
+        }
+        this.#schedule(Math.min(3e4, 500 * 2 ** this.#attempt));
+      } else {
+        this.#attempt = 0;
+        console.warn(
+          `Amarsia telemetry delivery failed after 6 retries; dropping ${batch.length} run update(s).`
+        );
+      }
+    }
+  }
+}
+function withAmarsiaTelemetry(options) {
+  const { store, manifest, client } = options;
+  const projections = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  return {
+    read: (sessionId) => store.read(sessionId),
+    listSessionIds: () => store.listSessionIds(),
+    describeLocation: store.describeLocation?.bind(store),
+    subscribe: store.subscribe?.bind(store),
+    subscribeAll: store.subscribeAll?.bind(store),
+    async append(sessionId, events) {
+      await store.append(sessionId, events);
+      const runs = relevantRuns(events);
+      if (runs.size === 0 && !projections.has(sessionId) && !pending.has(sessionId)) {
+        return;
+      }
+      const previous = pending.get(sessionId) ?? Promise.resolve();
+      const processing = previous.then(async () => {
+        let projection = projections.get(sessionId);
+        if (!projection) {
+          projection = createProjection(await store.read(sessionId));
+          projections.set(sessionId, projection);
+        } else {
+          appendToProjection(projection, events);
+        }
+        if (projection.isTest) return;
+        for (const run of runs) {
+          const fact = projectRunFact(
+            manifest,
+            sessionId,
+            run,
+            projection
+          );
+          if (fact) client.enqueue(fact);
+        }
+      }).catch(() => void 0);
+      pending.set(sessionId, processing);
+      void processing.finally(() => {
+        if (pending.get(sessionId) === processing) {
+          pending.delete(sessionId);
+        }
+      });
+    }
+  };
+}
+function createProjection(events) {
+  const projection = {
+    seenSequences: /* @__PURE__ */ new Set(),
+    runs: /* @__PURE__ */ new Map(),
+    isTest: false
+  };
+  appendToProjection(projection, events);
+  return projection;
+}
+function appendToProjection(projection, events) {
+  for (const event of events) {
+    if (projection.seenSequences.has(event.sequence)) continue;
+    projection.seenSequences.add(event.sequence);
+    if (event.type === "session.created") {
+      projection.sessionCreated = event;
+      const metadata = asRecord(event.data.metadata);
+      projection.isTest = metadata?.orchaTest === true;
+    }
+    if (typeof event.run !== "number") continue;
+    const runEvents = projection.runs.get(event.run);
+    if (runEvents) {
+      runEvents.push(event);
+    } else {
+      projection.runs.set(event.run, [event]);
+    }
+  }
+}
+function relevantRuns(events) {
+  const runs = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (typeof event.run === "number" && RELEVANT_EVENTS.has(event.type)) {
+      runs.add(event.run);
+    }
+  }
+  return runs;
+}
+function projectRunFact(manifest, sessionId, run, projection) {
+  const runEvents = projection.runs.get(run);
+  if (!runEvents) return void 0;
+  const started = runEvents.find((event) => event.type === "run.started");
+  if (!started) return void 0;
+  const terminal = [...runEvents].reverse().find(
+    (event) => ["run.completed", "run.failed", "run.paused"].includes(event.type)
+  );
+  const lineage = asRecord(projection.sessionCreated?.data.lineage);
+  const assistants = runEvents.filter(
+    (event) => event.type === "message.created" && event.data.role === "assistant"
+  );
+  const usage = normalizeUsage(terminal?.data.usage, assistants);
+  const completedActions = runEvents.filter(
+    (event) => event.type === "action.completed"
+  );
+  const failedActions = runEvents.filter(
+    (event) => event.type === "action.failed"
+  );
+  const evaluations = runEvents.filter(
+    (event) => event.type === "evaluation.completed" || event.type === "evaluation.failed"
+  );
+  const error = asRecord(terminal?.data.error);
+  const lastAssistant = assistants.at(-1);
+  const status = terminal?.type === "run.completed" ? "completed" : terminal?.type === "run.failed" ? "failed" : terminal?.type === "run.paused" ? "paused" : "running";
+  return {
+    event_id: `${manifest.key}:${sessionId}:${run}`,
+    agent_external_id: manifest.key,
+    session_id: sessionId,
+    run_number: run,
+    ...typeof lineage?.parentAgent === "string" ? { parent_agent_external_id: lineage.parentAgent } : {},
+    ...typeof lineage?.parentSessionId === "string" ? { parent_session_id: lineage.parentSessionId } : {},
+    status,
+    provider: typeof started.data.provider === "string" ? started.data.provider : manifest.provider,
+    model: typeof started.data.model === "string" ? started.data.model : manifest.model,
+    ...typeof started.data.region === "string" ? { region: started.data.region } : {},
+    ...typeof started.data.outputType === "string" ? { output_type: started.data.outputType } : {},
+    ...typeof lastAssistant?.data.stopReason === "string" ? { stop_reason: lastAssistant.data.stopReason } : {},
+    started_at: started.timestamp,
+    ...terminal ? { ended_at: terminal.timestamp } : {},
+    ...typeof terminal?.data.durationMs === "number" ? { duration_ms: terminal.data.durationMs } : {},
+    model_duration_ms: sumNumber(assistants, "durationMs"),
+    action_duration_ms: sumNumber(
+      [...completedActions, ...failedActions],
+      "durationMs"
+    ),
+    ...usage,
+    user_message_count: runEvents.filter(
+      (event) => event.type === "message.created" && event.data.role === "user"
+    ).length,
+    assistant_message_count: assistants.length,
+    action_count: runEvents.filter(
+      (event) => event.type === "action.requested"
+    ).length,
+    action_success_count: completedActions.length,
+    action_failure_count: failedActions.length,
+    subagent_count: runEvents.filter(
+      (event) => event.type === "subagent.initiated"
+    ).length,
+    actions: projectActionLogs(runEvents),
+    evaluation_count: evaluations.length,
+    evaluation_pass_count: evaluations.filter(
+      (event) => event.type === "evaluation.completed" && event.data.status === "passed"
+    ).length,
+    ...typeof error?.code === "string" ? { error_code: error.code } : {},
+    ...typeof error?.message === "string" ? { error_message: sanitizeErrorMessage(error.message) } : {},
+    ...typeof error?.retryable === "boolean" ? { error_retryable: error.retryable } : {}
+  };
+}
+function normalizeUsage(terminalUsage, assistants) {
+  const direct = asRecord(terminalUsage);
+  if (direct) {
+    return usageFields(direct);
+  }
+  const total = {
+    inputTokens: 0,
+    outputTokens: 0,
+    reasoningTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0
+  };
+  for (const event of assistants) {
+    const usage = asRecord(event.data.usage);
+    if (!usage) continue;
+    total.inputTokens += numberValue(usage.inputTokens);
+    total.outputTokens += numberValue(usage.outputTokens);
+    total.reasoningTokens = (total.reasoningTokens ?? 0) + numberValue(usage.reasoningTokens);
+    total.cacheReadTokens += numberValue(usage.cacheReadTokens);
+    total.cacheWriteTokens += numberValue(usage.cacheWriteTokens);
+  }
+  return usageFields(total);
+}
+function usageFields(usage) {
+  const reasoning = numberValue(usage.reasoningTokens);
+  return {
+    input_tokens: numberValue(usage.inputTokens),
+    output_tokens: numberValue(usage.outputTokens),
+    ...reasoning > 0 ? { reasoning_tokens: reasoning } : {},
+    cache_read_tokens: numberValue(usage.cacheReadTokens),
+    cache_write_tokens: numberValue(usage.cacheWriteTokens)
+  };
+}
+function sumNumber(events, key) {
+  return events.reduce((sum, event) => sum + numberValue(event.data[key]), 0);
+}
+function projectActionLogs(events) {
+  const requestedByCallId = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type === "action.requested" && typeof event.data.callId === "string") {
+      requestedByCallId.set(event.data.callId, event);
+    }
+  }
+  return events.filter(
+    (event) => event.type === "action.completed" || event.type === "action.failed"
+  ).slice(0, 100).map((event) => {
+    const error = asRecord(event.data.error);
+    const requested = typeof event.data.callId === "string" ? requestedByCallId.get(event.data.callId) : void 0;
+    return {
+      call_id: typeof event.data.callId === "string" ? event.data.callId : `action-${event.sequence}`,
+      name: typeof event.data.name === "string" ? event.data.name : "unknown",
+      status: event.type === "action.completed" ? "completed" : "failed",
+      started_at: requested?.timestamp ?? event.timestamp,
+      ended_at: event.timestamp,
+      duration_ms: numberValue(event.data.durationMs),
+      ...typeof error?.code === "string" ? { error_code: error.code } : {},
+      ...typeof error?.message === "string" ? { error_message: sanitizeErrorMessage(error.message) } : {}
+    };
+  });
+}
+function takeBatch(queue) {
+  const batch = [];
+  let bytes = utf8ByteLength('{"schema_version":1,"runs":[]}');
+  for (const fact of queue.values()) {
+    const factBytes = utf8ByteLength(JSON.stringify(fact)) + 1;
+    if (batch.length > 0 && (batch.length >= MAX_BATCH_RUNS || bytes + factBytes > MAX_KEEPALIVE_BYTES)) {
+      break;
+    }
+    batch.push(fact);
+    bytes += factBytes;
+  }
+  return batch;
+}
+function utf8ByteLength(value) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(value).byteLength;
+  }
+  let bytes = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code < 128) bytes += 1;
+    else if (code < 2048) bytes += 2;
+    else if (code >= 55296 && code <= 56319) {
+      bytes += 4;
+      index += 1;
+    } else bytes += 3;
+  }
+  return bytes;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function sanitizeErrorMessage(value) {
+  return value.replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, "Bearer [redacted]").replace(
+    /\b(authorization|api[-_ ]?key|token|secret|password)\b\s*[:=]\s*[^\s,;]+/gi,
+    "$1=[redacted]"
+  ).replace(
+    /\b(?:sk|pk|amarsia)_[A-Za-z0-9_-]{12,}\b/gi,
+    "[redacted]"
+  ).slice(0, 8e3);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AmarsiaTelemetryClient,
+  withAmarsiaTelemetry
+});

package/dist-cjs/amarsia/endpoint.js

@@ -0,0 +1,32 @@
+"use strict"; const __orchaImportMetaUrl = require("url").pathToFileURL(__filename).href;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var endpoint_exports = {};
+__export(endpoint_exports, {
+  resolveAmarsiaEndpoint: () => resolveAmarsiaEndpoint
+});
+module.exports = __toCommonJS(endpoint_exports);
+const DEFAULT_AMARSIA_API_URL = "https://api.amarsia.com";
+function resolveAmarsiaEndpoint(endpoint) {
+  return (endpoint?.trim() || (typeof process !== "undefined" ? process.env?.AMARSIA_API_URL : void 0) || DEFAULT_AMARSIA_API_URL).replace(/\/$/, "");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveAmarsiaEndpoint
+});

package/dist-cjs/amarsia/sync.js

@@ -23,14 +23,14 @@ __export(sync_exports, {
 });
 module.exports = __toCommonJS(sync_exports);
 var import_metadata = require("./metadata.js");
-const DEFAULT_AMARSIA_API_URL = "https://api.amarsia.com";
+var import_endpoint = require("./endpoint.js");
 const syncedHashes = /* @__PURE__ */ new Map();
 function syncAmarsiaProject(options) {
   const metadata = (0, import_metadata.createAmarsiaProjectMetadata)(
     options.bundle,
     options.projectRoot
   );
-  const baseUrl = resolveAmarsiaEndpoint(options.endpoint);
+  const baseUrl = (0, import_endpoint.resolveAmarsiaEndpoint)(options.endpoint);
   const dedupeKey = `${baseUrl}:${options.key}`;
   if (syncedHashes.get(dedupeKey) === metadata.content_hash) {
     return;
@@ -46,9 +46,6 @@ function syncAmarsiaProject(options) {
     console.warn(`[orcha] Amarsia project sync failed: ${message}`);
   });
 }
-function resolveAmarsiaEndpoint(endpoint) {
-  return (endpoint?.trim() || process.env.AMARSIA_API_URL || DEFAULT_AMARSIA_API_URL).replace(/\/$/, "");
-}
 async function postProjectMetadata(options) {
   const response = await fetch(`${options.baseUrl}/v3/project-sync`, {
     method: "PUT",