@marshmallo/marlo 0.1.0

package/dist/index.js

@@ -0,0 +1,660 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MarloClient: () => MarloClient,
+  TaskContext: () => TaskContext,
+  agent: () => registerAgent,
+  generateId: () => generateId,
+  getAgent: () => getAgent,
+  getClient: () => getClient,
+  init: () => init,
+  isEnabled: () => isEnabled,
+  jsonDigest: () => jsonDigest,
+  registerAgent: () => registerAgent,
+  shutdown: () => shutdown,
+  task: () => task
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/buffered-sender.ts
+var DEFAULT_BATCH_SIZE = 50;
+var DEFAULT_FLUSH_INTERVAL_MS = 1e3;
+var DEFAULT_RETRIES = 3;
+var DEFAULT_RETRY_BACKOFF_MS = 500;
+var DEFAULT_TIMEOUT_MS = 5e3;
+function warn(message) {
+  console.warn(`[marlo] ${message}`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var BufferedEventSender = class {
+  constructor(config) {
+    this.queue = [];
+    this.flushTimer = null;
+    this.isShutdown = false;
+    this.eventsUrl = config.eventsUrl;
+    this.headers = { Authorization: `Bearer ${config.apiKey}` };
+    this.batchSize = Math.max(1, config.batchSize ?? DEFAULT_BATCH_SIZE);
+    this.flushIntervalMs = Math.max(
+      100,
+      config.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS
+    );
+    this.maxRetries = Math.max(1, config.maxRetries ?? DEFAULT_RETRIES);
+    this.retryBackoffMs = Math.max(
+      100,
+      config.retryBackoffMs ?? DEFAULT_RETRY_BACKOFF_MS
+    );
+    this.flushTimer = setInterval(() => {
+      this.flushAsync().catch(() => {
+      });
+    }, this.flushIntervalMs);
+  }
+  enqueue(events) {
+    if (!events.length || this.isShutdown) {
+      return;
+    }
+    this.queue.push(...events);
+    if (this.queue.length >= this.batchSize) {
+      this.flushAsync().catch(() => {
+      });
+    }
+  }
+  async flush() {
+    await this.flushAsync();
+  }
+  async shutdown() {
+    this.isShutdown = true;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flushAsync();
+  }
+  async flushAsync() {
+    while (this.queue.length > 0) {
+      const batch = this.queue.splice(0, this.batchSize);
+      const success = await this.sendWithRetry(batch);
+      if (!success) {
+        this.queue.unshift(...batch);
+        return;
+      }
+    }
+  }
+  async sendWithRetry(batch) {
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      if (await this.sendBatch(batch)) {
+        return true;
+      }
+      await sleep(this.retryBackoffMs * 2 ** attempt);
+    }
+    return false;
+  }
+  async sendBatch(batch) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+      const response = await fetch(this.eventsUrl, {
+        method: "POST",
+        headers: {
+          ...this.headers,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(batch),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status >= 200 && response.status < 300) {
+        return true;
+      }
+      warn(`Event send returned ${response.status}`);
+      return false;
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          warn("Event send timed out");
+        } else {
+          warn(`Event send failed: ${error.message}`);
+        }
+      } else {
+        warn("Event send failed");
+      }
+      return false;
+    }
+  }
+};
+
+// src/client.ts
+var DEFAULT_ENDPOINT = "https://marlo.marshmallo.ai";
+var DEFAULT_TIMEOUT_MS2 = 5e3;
+function warn2(message) {
+  console.warn(`[marlo] ${message}`);
+}
+function info(message) {
+  console.info(`[marlo] ${message}`);
+}
+var _client = null;
+var _enabled = false;
+var MarloClient = class {
+  constructor(apiKey, endpoint, scope) {
+    this.apiKey = apiKey;
+    this.endpoint = endpoint.replace(/\/+$/, "");
+    this._scope = scope;
+    this.sender = new BufferedEventSender({
+      eventsUrl: `${this.endpoint}/events`,
+      apiKey
+    });
+  }
+  get scope() {
+    return this._scope;
+  }
+  sendEvents(events) {
+    this.sender.enqueue(events);
+  }
+  async flush() {
+    await this.sender.flush();
+  }
+  async shutdown() {
+    await this.sender.shutdown();
+  }
+  async fetchLearnings(learningKey) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS2);
+      const response = await fetch(`${this.endpoint}/learnings`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ learning_key: learningKey }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status < 200 || response.status >= 300) {
+        return null;
+      }
+      const data = await response.json();
+      return data.learning_state ?? null;
+    } catch (error) {
+      if (error instanceof Error) {
+        warn2(`Fetch learnings failed: ${error.message}`);
+      } else {
+        warn2("Fetch learnings failed");
+      }
+      return null;
+    }
+  }
+};
+async function init(apiKey, endpoint = DEFAULT_ENDPOINT) {
+  const normalizedEndpoint = endpoint.replace(/\/+$/, "");
+  const scopeUrl = `${normalizedEndpoint}/scope`;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS2);
+    const response = await fetch(scopeUrl, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.status !== 200) {
+      warn2(`Marlo init failed: scope request returned ${response.status}`);
+      _enabled = false;
+      return;
+    }
+    const payload = await response.json();
+    const scopeData = payload.scope ?? {};
+    const projectId = scopeData.project_id;
+    const orgId = scopeData.org_id;
+    const userId = scopeData.user_id;
+    if (typeof projectId !== "string" || !projectId.trim() || typeof orgId !== "string" || !orgId.trim() || typeof userId !== "string" || !userId.trim()) {
+      warn2("Marlo init failed: invalid scope response");
+      _enabled = false;
+      return;
+    }
+    const scope = {
+      project_id: projectId.trim(),
+      org_id: orgId.trim(),
+      user_id: userId.trim()
+    };
+    _client = new MarloClient(apiKey, normalizedEndpoint, scope);
+    _enabled = true;
+    info(`Marlo SDK initialized for project ${projectId}`);
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        warn2("Marlo init failed: timeout");
+      } else if (error.message.includes("ECONNREFUSED") || error.message.includes("fetch failed")) {
+        warn2("Marlo init failed: connection error");
+      } else {
+        warn2(`Marlo init failed: ${error.message}`);
+      }
+    } else {
+      warn2("Marlo init failed");
+    }
+    _enabled = false;
+  }
+}
+function getClient() {
+  return _client;
+}
+function isEnabled() {
+  return _enabled;
+}
+async function shutdown() {
+  if (_client) {
+    await _client.shutdown();
+    _client = null;
+  }
+  _enabled = false;
+}
+
+// src/digest.ts
+var import_crypto = require("crypto");
+function sortObject(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(sortObject);
+  }
+  if (typeof value === "object") {
+    const sorted = {};
+    const keys = Object.keys(value).sort();
+    for (const key of keys) {
+      sorted[key] = sortObject(value[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function jsonDigest(payload) {
+  const sorted = sortObject(payload);
+  const encoded = JSON.stringify(sorted);
+  return (0, import_crypto.createHash)("sha256").update(encoded, "utf-8").digest("hex");
+}
+
+// src/ids.ts
+var ID_EPOCH_MS = 17e11;
+var WORKER_ID_BITS = 10;
+var SEQUENCE_BITS = 12;
+var MAX_WORKER_ID = (1 << WORKER_ID_BITS) - 1;
+var MAX_SEQUENCE = (1 << SEQUENCE_BITS) - 1;
+var WORKER_ID_SHIFT = SEQUENCE_BITS;
+var TIMESTAMP_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;
+function parseWorkerId() {
+  const raw = (process.env.MARLO_WORKER_ID ?? "0").trim();
+  if (!raw) {
+    return 0;
+  }
+  const workerId = parseInt(raw, 10);
+  if (isNaN(workerId) || workerId < 0 || workerId > MAX_WORKER_ID) {
+    return 0;
+  }
+  return workerId;
+}
+var WORKER_ID = parseWorkerId();
+var IdGenerator = class {
+  constructor() {
+    this.lastTs = 0;
+    this.sequence = 0;
+  }
+  nextId() {
+    let ts = Date.now();
+    if (ts < this.lastTs) {
+      ts = this.waitUntil(this.lastTs);
+    }
+    if (ts === this.lastTs) {
+      this.sequence = this.sequence + 1 & MAX_SEQUENCE;
+      if (this.sequence === 0) {
+        ts = this.waitUntil(this.lastTs + 1);
+      }
+    } else {
+      this.sequence = 0;
+    }
+    this.lastTs = ts;
+    return ts - ID_EPOCH_MS << TIMESTAMP_SHIFT | WORKER_ID << WORKER_ID_SHIFT | this.sequence;
+  }
+  waitUntil(targetMs) {
+    let ts = Date.now();
+    while (ts < targetMs) {
+      ts = Date.now();
+    }
+    return ts;
+  }
+};
+var idGenerator = new IdGenerator();
+function generateId() {
+  return idGenerator.nextId();
+}
+
+// src/registry.ts
+var AgentRegistry = class {
+  constructor() {
+    this.agents = /* @__PURE__ */ new Map();
+  }
+  register(definition) {
+    const existing = this.agents.get(definition.name);
+    if (!existing) {
+      this.agents.set(definition.name, definition);
+    } else if (existing.definition_hash !== definition.definition_hash) {
+      definition.sent = false;
+      this.agents.set(definition.name, definition);
+    } else {
+      definition.sent = existing.sent;
+      this.agents.set(definition.name, definition);
+    }
+  }
+  get(name) {
+    return this.agents.get(name) ?? null;
+  }
+  markSent(name) {
+    const agent = this.agents.get(name);
+    if (agent) {
+      agent.sent = true;
+    }
+  }
+  needsResend(name) {
+    const agent = this.agents.get(name);
+    return agent !== null && agent !== void 0 && !agent.sent;
+  }
+};
+var registry = null;
+function getRegistry() {
+  if (!registry) {
+    registry = new AgentRegistry();
+  }
+  return registry;
+}
+function registerAgent(name, systemPrompt, tools, mcp, modelConfig) {
+  const definitionHash = jsonDigest({
+    name,
+    system_prompt: systemPrompt,
+    tool_definitions: tools,
+    mcp_definitions: mcp ?? null,
+    model_config: modelConfig ?? null
+  });
+  const definition = {
+    name,
+    system_prompt: systemPrompt,
+    tools,
+    mcp: mcp ?? null,
+    model_config: modelConfig ?? null,
+    definition_hash: definitionHash,
+    sent: false
+  };
+  getRegistry().register(definition);
+  return definitionHash;
+}
+function getAgent(name) {
+  return getRegistry().get(name);
+}
+function markAgentSent(name) {
+  getRegistry().markSent(name);
+}
+function needsResend(name) {
+  return getRegistry().needsResend(name);
+}
+
+// src/context.ts
+function warn3(message) {
+  console.warn(`[marlo] ${message}`);
+}
+function generateInvocationId() {
+  return crypto.randomUUID();
+}
+function computeSessionId(projectId, threadId) {
+  const digest = jsonDigest(`${projectId}:${threadId}`);
+  return parseInt(digest.slice(0, 16), 16);
+}
+function task(threadId, agent, threadName) {
+  return new TaskContext(threadId, agent, threadName);
+}
+var TaskContext = class _TaskContext {
+  constructor(threadId, agent, threadName, parent) {
+    this.taskId = null;
+    this.sessionId = null;
+    this.invocationId = null;
+    this.inputText = null;
+    this.outputText = null;
+    this.errorMessage = null;
+    this.events = [];
+    this.threadId = threadId;
+    this.agentName = agent;
+    this.threadName = threadName;
+    this.parent = parent;
+  }
+  start() {
+    try {
+      const client = getClient();
+      const projectId = client?.scope.project_id ?? "";
+      this.sessionId = computeSessionId(projectId, this.threadId);
+      this.taskId = generateId();
+      this.invocationId = generateInvocationId();
+      if (needsResend(this.agentName)) {
+        const agentDef = getAgent(this.agentName);
+        if (agentDef) {
+          this.emit("agent_definition", {
+            name: agentDef.name,
+            system_prompt: agentDef.system_prompt,
+            tool_definitions: agentDef.tools,
+            mcp_definitions: agentDef.mcp,
+            model_config: agentDef.model_config,
+            definition_hash: agentDef.definition_hash
+          });
+          markAgentSent(this.agentName);
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        warn3(`TaskContext start failed: ${error.message}`);
+      } else {
+        warn3("TaskContext start failed");
+      }
+    }
+    return this;
+  }
+  end(hasError) {
+    try {
+      const status = hasError || this.errorMessage !== null ? "error" : "success";
+      const payload = { status };
+      if (this.outputText !== null) {
+        payload.final_answer = this.outputText;
+      }
+      if (this.errorMessage !== null) {
+        payload.error = this.errorMessage;
+      }
+      this.emit("task_end", payload);
+      this.flush();
+    } catch (error) {
+      if (error instanceof Error) {
+        warn3(`TaskContext end failed: ${error.message}`);
+      } else {
+        warn3("TaskContext end failed");
+      }
+    }
+  }
+  input(text) {
+    try {
+      this.inputText = text;
+      const metadata = { thread_id: this.threadId };
+      if (this.threadName !== void 0) {
+        metadata.thread_name = this.threadName;
+      }
+      this.emit("task_start", { task: text, metadata });
+    } catch (error) {
+      if (error instanceof Error) {
+        warn3(`TaskContext input failed: ${error.message}`);
+      } else {
+        warn3("TaskContext input failed");
+      }
+    }
+  }
+  output(text) {
+    try {
+      this.outputText = text;
+    } catch (error) {
+      if (error instanceof Error) {
+        warn3(`TaskContext output failed: ${error.message}`);
+      } else {
+        warn3("TaskContext output failed");
+      }
+    }
+  }
+  tool(name, input, output, error) {
+    try {
+      const payload = {
+        tool_name: name,
+        input,
+        output
+      };
+      if (error !== void 0) {
+        payload.error = error;
+      }
+      this.emit("tool_call", payload);
+    } catch (err) {
+      if (err instanceof Error) {
+        warn3(`TaskContext tool failed: ${err.message}`);
+      } else {
+        warn3("TaskContext tool failed");
+      }
+    }
+  }
+  reasoning(text) {
+    try {
+      this.emit("log", { reasoning: text });
+    } catch (error) {
+      if (error instanceof Error) {
+        warn3(`TaskContext reasoning failed: ${error.message}`);
+      } else {
+        warn3("TaskContext reasoning failed");
+      }
+    }
+  }
+  llm(params) {
+    try {
+      if (params.messages === void 0) {
+        warn3("llm() called without messages");
+      }
+      if (params.response === void 0) {
+        warn3("llm() called without response");
+      }
+      const payload = {
+        model: params.model,
+        usage: params.usage
+      };
+      if (params.messages !== void 0) {
+        payload.messages = params.messages;
+      }
+      if (params.response !== void 0) {
+        payload.response = params.response;
+      }
+      this.emit("llm_call", payload);
+    } catch (error) {
+      if (error instanceof Error) {
+        warn3(`TaskContext llm failed: ${error.message}`);
+      } else {
+        warn3("TaskContext llm failed");
+      }
+    }
+  }
+  error(message) {
+    try {
+      this.errorMessage = message;
+    } catch (error) {
+      if (error instanceof Error) {
+        warn3(`TaskContext error failed: ${error.message}`);
+      } else {
+        warn3("TaskContext error failed");
+      }
+    }
+  }
+  child(agent) {
+    return new _TaskContext(this.threadId, agent, this.threadName, this);
+  }
+  async getLearnings() {
+    try {
+      const client = getClient();
+      if (!client) {
+        return null;
+      }
+      return await client.fetchLearnings(this.agentName);
+    } catch (error) {
+      if (error instanceof Error) {
+        warn3(`TaskContext getLearnings failed: ${error.message}`);
+      } else {
+        warn3("TaskContext getLearnings failed");
+      }
+      return null;
+    }
+  }
+  emit(eventType, payload) {
+    const agentDef = getAgent(this.agentName);
+    const agentId = agentDef?.name ?? this.agentName;
+    const parentAgentId = this.parent?.agentName ?? null;
+    const event = {
+      run_id: this.sessionId,
+      agent_id: agentId,
+      parent_agent_id: parentAgentId,
+      invocation_id: this.invocationId,
+      task_id: this.taskId,
+      event_type: eventType,
+      payload
+    };
+    this.events.push(event);
+  }
+  flush() {
+    const client = getClient();
+    if (!client || !isEnabled()) {
+      this.events = [];
+      return;
+    }
+    try {
+      client.sendEvents(this.events);
+      client.flush();
+    } catch (error) {
+      if (error instanceof Error) {
+        warn3(`TaskContext flush failed: ${error.message}`);
+      } else {
+        warn3("TaskContext flush failed");
+      }
+    } finally {
+      this.events = [];
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MarloClient,
+  TaskContext,
+  agent,
+  generateId,
+  getAgent,
+  getClient,
+  init,
+  isEnabled,
+  jsonDigest,
+  registerAgent,
+  shutdown,
+  task
+});
+//# sourceMappingURL=index.js.map