agentxjs 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1292 @@
+'use strict';
+
+var common = require('@agentxjs/common');
+var ky = require('ky');
+var agent = require('@agentxjs/agent');
+var engine = require('@agentxjs/engine');
+var types = require('@agentxjs/types');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var ky__default = /*#__PURE__*/_interopDefault(ky);
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/defineAgent.ts
+function defineAgent(input) {
+  const { name, description, systemPrompt } = input;
+  return {
+    name,
+    description,
+    systemPrompt
+  };
+}
+var logger = common.createLogger("agentx/DefinitionManager");
+function generateMetaImageId(definitionName) {
+  return `meta_${definitionName}`;
+}
+function toDefinitionRecord(definition) {
+  const now = /* @__PURE__ */ new Date();
+  return {
+    name: definition.name,
+    description: definition.description,
+    systemPrompt: definition.systemPrompt,
+    definition,
+    source: "code",
+    createdAt: now,
+    updatedAt: now
+  };
+}
+var DefinitionManagerImpl = class {
+  constructor(repository) {
+    this.repository = repository;
+    // Local cache for sync access
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
+  }
+  register(definition) {
+    if (this.cache.has(definition.name)) {
+      throw new Error(`Definition already exists: ${definition.name}`);
+    }
+    this.cache.set(definition.name, definition);
+    const definitionRecord = toDefinitionRecord(definition);
+    this.repository.saveDefinition(definitionRecord).catch((err) => {
+      logger.error("Failed to save definition", { name: definition.name, error: err });
+    });
+    const metaImageId = generateMetaImageId(definition.name);
+    const imageRecord = {
+      imageId: metaImageId,
+      type: "meta",
+      definitionName: definition.name,
+      parentImageId: null,
+      definition,
+      config: {},
+      messages: [],
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    this.repository.saveImage(imageRecord).catch((err) => {
+      logger.error("Failed to save MetaImage", { definitionName: definition.name, error: err });
+    });
+    logger.info("Definition registered", {
+      name: definition.name,
+      metaImageId
+    });
+  }
+  get(name) {
+    return this.cache.get(name);
+  }
+  list() {
+    return Array.from(this.cache.values());
+  }
+  has(name) {
+    return this.cache.has(name);
+  }
+  unregister(name) {
+    const definition = this.cache.get(name);
+    if (!definition) {
+      return false;
+    }
+    this.cache.delete(name);
+    this.repository.deleteDefinition(name).catch((err) => {
+      logger.error("Failed to delete definition", { name, error: err });
+    });
+    const metaImageId = generateMetaImageId(name);
+    this.repository.deleteImage(metaImageId).catch((err) => {
+      logger.error("Failed to delete MetaImage", { definitionName: name, error: err });
+    });
+    logger.info("Definition unregistered", { name });
+    return true;
+  }
+};
+var logger2 = common.createLogger("agentx/ImageManager");
+function generateMetaImageId2(definitionName) {
+  return `meta_${definitionName}`;
+}
+function toAgentImage(record) {
+  const definition = record.definition;
+  if (record.type === "meta") {
+    const metaImage = {
+      type: "meta",
+      imageId: record.imageId,
+      definitionName: record.definitionName,
+      definition,
+      config: record.config,
+      messages: [],
+      createdAt: record.createdAt
+    };
+    return metaImage;
+  } else {
+    return {
+      type: "derived",
+      imageId: record.imageId,
+      parentImageId: record.parentImageId,
+      definitionName: record.definitionName,
+      definition,
+      config: record.config,
+      messages: record.messages,
+      createdAt: record.createdAt
+    };
+  }
+}
+var ImageManagerImpl = class {
+  constructor(repository, containerManager, defaultContainerId) {
+    __publicField(this, "repository");
+    __publicField(this, "containerManager");
+    __publicField(this, "defaultContainerId");
+    this.repository = repository;
+    this.containerManager = containerManager;
+    this.defaultContainerId = defaultContainerId;
+  }
+  async get(imageId) {
+    const record = await this.repository.findImageById(imageId);
+    if (!record) {
+      return void 0;
+    }
+    return toAgentImage(record);
+  }
+  async getMetaImage(definitionName) {
+    const metaImageId = generateMetaImageId2(definitionName);
+    const record = await this.repository.findImageById(metaImageId);
+    if (!record || record.type !== "meta") {
+      return void 0;
+    }
+    return toAgentImage(record);
+  }
+  async list() {
+    const records = await this.repository.findAllImages();
+    return records.map(toAgentImage);
+  }
+  async listByDefinition(definitionName) {
+    const allRecords = await this.repository.findAllImages();
+    const filtered = allRecords.filter((r) => r.definitionName === definitionName);
+    return filtered.map(toAgentImage);
+  }
+  async exists(imageId) {
+    return this.repository.imageExists(imageId);
+  }
+  async delete(imageId) {
+    const record = await this.repository.findImageById(imageId);
+    if (!record) {
+      return false;
+    }
+    if (record.type === "meta") {
+      logger2.warn("Cannot delete MetaImage directly", { imageId });
+      return false;
+    }
+    await this.repository.deleteImage(imageId);
+    logger2.info("Image deleted", { imageId });
+    return true;
+  }
+  async run(imageId, options) {
+    logger2.info("Running agent from image", { imageId, containerId: options?.containerId });
+    const image = await this.get(imageId);
+    if (!image) {
+      throw new Error(`Image not found: ${imageId}`);
+    }
+    let containerId = options?.containerId || this.defaultContainerId;
+    if (!containerId) {
+      const container = await this.containerManager.create();
+      containerId = container.containerId;
+      this.defaultContainerId = containerId;
+      logger2.debug("Auto-created default container", { containerId });
+    }
+    return this.containerManager.run(image, containerId);
+  }
+};
+var logger3 = common.createLogger("agentx/AgentManager");
+var AgentManager = class {
+  constructor(containerManager) {
+    this.containerManager = containerManager;
+  }
+  /**
+   * Get an existing agent by ID
+   */
+  get(agentId) {
+    return this.containerManager.getAgent(agentId);
+  }
+  /**
+   * Check if an agent exists
+   */
+  has(agentId) {
+    return this.containerManager.hasAgent(agentId);
+  }
+  /**
+   * List all agents
+   */
+  list() {
+    return this.containerManager.listAgents();
+  }
+  /**
+   * Destroy an agent by ID
+   */
+  async destroy(agentId) {
+    logger3.debug("Destroying agent", { agentId });
+    await this.containerManager.destroyAgent(agentId);
+    logger3.info("Agent destroyed", { agentId });
+  }
+  /**
+   * Destroy all agents
+   */
+  async destroyAll() {
+    const agents = this.containerManager.listAgents();
+    logger3.debug("Destroying all agents", { count: agents.length });
+    await this.containerManager.destroyAllAgents();
+    logger3.info("All agents destroyed", { count: agents.length });
+  }
+};
+var logger4 = common.createLogger("agentx/SessionManager");
+function generateSessionId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `session_${timestamp}_${random}`;
+}
+function generateImageId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `image_${timestamp}_${random}`;
+}
+var SessionImpl = class _SessionImpl {
+  constructor(record, repository, containerManager, defaultContainerId) {
+    __publicField(this, "sessionId");
+    __publicField(this, "userId");
+    __publicField(this, "imageId");
+    __publicField(this, "createdAt");
+    __publicField(this, "_title");
+    __publicField(this, "_updatedAt");
+    __publicField(this, "repository");
+    __publicField(this, "containerManager");
+    __publicField(this, "defaultContainerId");
+    this.sessionId = record.sessionId;
+    this.userId = record.userId;
+    this.imageId = record.imageId;
+    this._title = record.title;
+    this.createdAt = record.createdAt.getTime();
+    this._updatedAt = record.updatedAt.getTime();
+    this.repository = repository;
+    this.containerManager = containerManager;
+    this.defaultContainerId = defaultContainerId;
+  }
+  get title() {
+    return this._title;
+  }
+  get updatedAt() {
+    return this._updatedAt;
+  }
+  async resume(options) {
+    logger4.info("Resuming agent from session", {
+      sessionId: this.sessionId,
+      imageId: this.imageId,
+      containerId: options?.containerId
+    });
+    let containerId = options?.containerId || this.defaultContainerId;
+    if (!containerId) {
+      const container = await this.containerManager.create();
+      containerId = container.containerId;
+      logger4.debug("Auto-created default container for session", {
+        containerId,
+        sessionId: this.sessionId
+      });
+    }
+    const agent = await this.containerManager.resume(this, containerId);
+    this.collect(agent);
+    return agent;
+  }
+  collect(agent) {
+    logger4.debug("Collecting messages from agent", {
+      sessionId: this.sessionId,
+      agentId: agent.agentId
+    });
+    const sessionId = this.sessionId;
+    const repository = this.repository;
+    const saveMessage = (data, role) => {
+      const record = {
+        messageId: data.id,
+        sessionId,
+        role,
+        content: data,
+        createdAt: new Date(data.timestamp ?? Date.now())
+      };
+      repository.saveMessage(record).catch((error) => {
+        logger4.error("Failed to persist message", {
+          sessionId,
+          messageId: record.messageId,
+          error
+        });
+      });
+    };
+    agent.on("user_message", (event) => saveMessage(event.data, "user"));
+    agent.on("assistant_message", (event) => saveMessage(event.data, "assistant"));
+    agent.on("tool_call_message", (event) => saveMessage(event.data, "tool"));
+    agent.on("tool_result_message", (event) => saveMessage(event.data, "tool"));
+  }
+  async getMessages() {
+    logger4.debug("Getting messages for session", { sessionId: this.sessionId });
+    const records = await this.repository.findMessagesBySessionId(this.sessionId);
+    return records.map((record) => record.content);
+  }
+  async fork() {
+    logger4.info("Forking session", { sessionId: this.sessionId });
+    const imageRecord = await this.repository.findImageById(this.imageId);
+    if (!imageRecord) {
+      throw new Error(`Image not found: ${this.imageId}`);
+    }
+    const newImageId = generateImageId();
+    const newImageRecord = {
+      imageId: newImageId,
+      type: "derived",
+      definitionName: imageRecord.definitionName,
+      parentImageId: imageRecord.imageId,
+      definition: imageRecord.definition,
+      config: imageRecord.config,
+      messages: [...imageRecord.messages],
+      // Copy messages
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    await this.repository.saveImage(newImageRecord);
+    const newSessionId = generateSessionId();
+    const now = /* @__PURE__ */ new Date();
+    const newSessionRecord = {
+      sessionId: newSessionId,
+      userId: this.userId,
+      imageId: newImageId,
+      title: this._title ? `Fork of ${this._title}` : null,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.repository.saveSession(newSessionRecord);
+    logger4.info("Session forked", {
+      originalSessionId: this.sessionId,
+      newSessionId,
+      newImageId
+    });
+    return new _SessionImpl(
+      newSessionRecord,
+      this.repository,
+      this.containerManager,
+      this.defaultContainerId
+    );
+  }
+  async setTitle(title) {
+    logger4.debug("Setting session title", { sessionId: this.sessionId, title });
+    const now = /* @__PURE__ */ new Date();
+    await this.repository.saveSession({
+      sessionId: this.sessionId,
+      userId: this.userId,
+      imageId: this.imageId,
+      title,
+      createdAt: new Date(this.createdAt),
+      updatedAt: now
+    });
+    this._title = title;
+    this._updatedAt = now.getTime();
+    logger4.info("Session title updated", { sessionId: this.sessionId, title });
+  }
+};
+var SessionManagerImpl = class {
+  constructor(repository, containerManager, defaultContainerId) {
+    __publicField(this, "repository");
+    __publicField(this, "containerManager");
+    __publicField(this, "defaultContainerId");
+    this.repository = repository;
+    this.containerManager = containerManager;
+    this.defaultContainerId = defaultContainerId;
+  }
+  async create(imageId, userId) {
+    const sessionId = generateSessionId();
+    const now = /* @__PURE__ */ new Date();
+    const record = {
+      sessionId,
+      userId,
+      imageId,
+      title: null,
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.repository.saveSession(record);
+    logger4.info("Session created", { sessionId, imageId, userId });
+    return new SessionImpl(record, this.repository, this.containerManager, this.defaultContainerId);
+  }
+  async get(sessionId) {
+    const record = await this.repository.findSessionById(sessionId);
+    if (!record) return void 0;
+    return new SessionImpl(record, this.repository, this.containerManager, this.defaultContainerId);
+  }
+  async has(sessionId) {
+    return this.repository.sessionExists(sessionId);
+  }
+  async list() {
+    const records = await this.repository.findAllSessions();
+    return records.map(
+      (r) => new SessionImpl(r, this.repository, this.containerManager, this.defaultContainerId)
+    );
+  }
+  async listByImage(imageId) {
+    const records = await this.repository.findSessionsByImageId(imageId);
+    return records.map(
+      (r) => new SessionImpl(r, this.repository, this.containerManager, this.defaultContainerId)
+    );
+  }
+  async listByUser(userId) {
+    const records = await this.repository.findSessionsByUserId(userId);
+    return records.map(
+      (r) => new SessionImpl(r, this.repository, this.containerManager, this.defaultContainerId)
+    );
+  }
+  async destroy(sessionId) {
+    await this.repository.deleteSession(sessionId);
+    logger4.info("Session destroyed", { sessionId });
+  }
+  async destroyByImage(imageId) {
+    await this.repository.deleteSessionsByImageId(imageId);
+    logger4.info("Sessions destroyed by image", { imageId });
+  }
+  async destroyAll() {
+    const sessions = await this.repository.findAllSessions();
+    for (const session of sessions) {
+      await this.repository.deleteSession(session.sessionId);
+    }
+    logger4.info("All sessions destroyed");
+  }
+};
+var logger5 = common.createLogger("agentx/ErrorManager");
+var ErrorManager = class {
+  constructor() {
+    __publicField(this, "handlers", /* @__PURE__ */ new Set());
+  }
+  /**
+   * Handle an error from any agent
+   *
+   * Called internally when an agent emits an error event.
+   * 1. Default logging (always)
+   * 2. Custom handlers (user-registered)
+   */
+  handle(agentId, error, event) {
+    this.logError(agentId, error);
+    for (const handler of this.handlers) {
+      try {
+        handler.handle(agentId, error, event);
+      } catch (e) {
+        logger5.error("ErrorHandler failed", { error: e });
+      }
+    }
+  }
+  /**
+   * Add a custom error handler
+   */
+  addHandler(handler) {
+    this.handlers.add(handler);
+    return () => {
+      this.handlers.delete(handler);
+    };
+  }
+  /**
+   * Remove an error handler
+   */
+  removeHandler(handler) {
+    this.handlers.delete(handler);
+  }
+  /**
+   * Default error logging
+   */
+  logError(agentId, error) {
+    const prefix = `[${agentId}] ${error.category}/${error.code}`;
+    if (error.severity === "fatal") {
+      logger5.error(`${prefix}: ${error.message}`, { error });
+    } else if (error.severity === "error") {
+      logger5.error(`${prefix}: ${error.message}`);
+    } else {
+      logger5.warn(`${prefix}: ${error.message}`);
+    }
+  }
+};
+var ApiError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "ApiError";
+  }
+};
+function createHttpClient(options) {
+  return ky__default.default.create({
+    prefixUrl: options.baseUrl.replace(/\/+$/, ""),
+    headers: options.headers,
+    timeout: options.timeout || 3e4,
+    hooks: {
+      afterResponse: [
+        async (_request, _options, response) => {
+          if (!response.ok) {
+            const data = await response.json().catch(() => ({}));
+            throw new ApiError(
+              data.error?.code || "UNKNOWN_ERROR",
+              data.error?.message || `Request failed: ${response.status}`,
+              data.error?.details
+            );
+          }
+          return response;
+        }
+      ]
+    }
+  });
+}
+var logger6 = common.createLogger("agentx/ContainerManager");
+function generateContainerId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `container_${timestamp}_${random}`;
+}
+function generateAgentId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `agent_${timestamp}_${random}`;
+}
+var ContainerManagerImpl = class {
+  constructor(runtime, repository) {
+    __publicField(this, "agents", /* @__PURE__ */ new Map());
+    __publicField(this, "engine");
+    __publicField(this, "runtime");
+    __publicField(this, "repository");
+    this.runtime = runtime;
+    this.repository = repository;
+    this.engine = new engine.AgentEngine();
+  }
+  // ==================== Container Lifecycle ====================
+  async create(config) {
+    const containerId = generateContainerId();
+    const now = Date.now();
+    const record = {
+      containerId,
+      createdAt: now,
+      updatedAt: now,
+      config
+    };
+    await this.repository.saveContainer(record);
+    logger6.info("Container created", { containerId });
+    return record;
+  }
+  async get(containerId) {
+    return this.repository.findContainerById(containerId);
+  }
+  async list() {
+    return this.repository.findAllContainers();
+  }
+  async delete(containerId) {
+    const exists = await this.repository.containerExists(containerId);
+    if (!exists) {
+      return false;
+    }
+    await this.repository.deleteContainer(containerId);
+    logger6.info("Container deleted", { containerId });
+    return true;
+  }
+  async exists(containerId) {
+    return this.repository.containerExists(containerId);
+  }
+  // ==================== Agent Runtime ====================
+  async run(image, containerId) {
+    logger6.info("Running agent from image", {
+      imageId: image.imageId,
+      containerId
+    });
+    const container = await this.repository.findContainerById(containerId);
+    if (!container) {
+      throw new Error(`Container not found: ${containerId}`);
+    }
+    let agentId;
+    if (this.runtime.agentIdResolver) {
+      agentId = await this.runtime.agentIdResolver.resolveForRun(image.imageId, containerId);
+    } else {
+      agentId = generateAgentId();
+    }
+    const context = {
+      agentId,
+      createdAt: Date.now()
+    };
+    const sandbox = this.runtime.createSandbox(containerId);
+    const driver = this.runtime.createDriver(image.definition, context, sandbox);
+    const agent$1 = new agent.AgentInstance(image.definition, context, this.engine, driver, sandbox);
+    this.agents.set(agentId, agent$1);
+    logger6.info("Agent started", {
+      agentId,
+      imageId: image.imageId,
+      containerId,
+      definitionName: image.definition.name
+    });
+    return agent$1;
+  }
+  async resume(session, containerId) {
+    logger6.info("Resuming agent from session", {
+      sessionId: session.sessionId,
+      imageId: session.imageId,
+      containerId
+    });
+    const container = await this.repository.findContainerById(containerId);
+    if (!container) {
+      throw new Error(`Container not found: ${containerId}`);
+    }
+    const imageRecord = await this.repository.findImageById(session.imageId);
+    if (!imageRecord) {
+      throw new Error(`Image not found: ${session.imageId}`);
+    }
+    let agentId;
+    if (this.runtime.agentIdResolver) {
+      agentId = await this.runtime.agentIdResolver.resolveForResume(session.sessionId, containerId);
+    } else {
+      agentId = generateAgentId();
+    }
+    const context = {
+      agentId,
+      createdAt: Date.now()
+    };
+    const sandbox = this.runtime.createSandbox(containerId);
+    const definition = imageRecord.definition;
+    const driver = this.runtime.createDriver(definition, context, sandbox);
+    const agent$1 = new agent.AgentInstance(definition, context, this.engine, driver, sandbox);
+    this.agents.set(agentId, agent$1);
+    logger6.info("Agent resumed", {
+      agentId,
+      sessionId: session.sessionId,
+      imageId: session.imageId,
+      containerId
+    });
+    return agent$1;
+  }
+  async destroyAgent(agentId) {
+    const agent = this.agents.get(agentId);
+    if (!agent) {
+      logger6.warn("Agent not found for destroy", { agentId });
+      return;
+    }
+    logger6.debug("Destroying agent", { agentId });
+    await agent.destroy();
+    this.agents.delete(agentId);
+    logger6.info("Agent destroyed", { agentId });
+  }
+  getAgent(agentId) {
+    return this.agents.get(agentId);
+  }
+  hasAgent(agentId) {
+    return this.agents.has(agentId);
+  }
+  listAgents() {
+    return Array.from(this.agents.values());
+  }
+  async destroyAllAgents() {
+    const agentIds = Array.from(this.agents.keys());
+    logger6.debug("Destroying all agents", { count: agentIds.length });
+    await Promise.all(agentIds.map((id) => this.destroyAgent(id)));
+    logger6.info("All agents destroyed", { count: agentIds.length });
+  }
+};
+
+// src/AgentX.ts
+var logger7 = common.createLogger("agentx/AgentX");
+function createAgentX(runtime, options) {
+  logger7.info("Creating AgentX instance", { runtime: runtime.name });
+  if (!runtime.repository) {
+    throw new Error("Runtime must have a repository for persistence");
+  }
+  const repository = runtime.repository;
+  const containerManager = new ContainerManagerImpl(runtime, repository);
+  const errorManager = new ErrorManager();
+  const definitionManager = new DefinitionManagerImpl(repository);
+  const agentManager = new AgentManager(containerManager);
+  const imageManager = new ImageManagerImpl(repository, containerManager, options?.containerId);
+  const sessionManager = new SessionManagerImpl(repository, containerManager, options?.containerId);
+  logger7.debug("AgentX instance created", { runtime: runtime.name });
+  return {
+    mode: "local",
+    containers: containerManager,
+    definitions: definitionManager,
+    images: imageManager,
+    agents: agentManager,
+    sessions: sessionManager,
+    errors: errorManager
+  };
+}
+var PersistentSSEConnection = class {
+  constructor(serverUrl, agentId, sseParams = {}) {
+    this.serverUrl = serverUrl;
+    this.agentId = agentId;
+    this.sseParams = sseParams;
+    __publicField(this, "eventSource", null);
+    __publicField(this, "messageQueue", []);
+    __publicField(this, "activeIterators", /* @__PURE__ */ new Set());
+    __publicField(this, "isDone", false);
+  }
+  /**
+   * Initialize SSE connection
+   */
+  connect() {
+    if (this.eventSource) {
+      return;
+    }
+    let sseUrl = `${this.serverUrl}/agents/${this.agentId}/sse`;
+    if (Object.keys(this.sseParams).length > 0) {
+      const params = new URLSearchParams(this.sseParams);
+      sseUrl += `?${params.toString()}`;
+    }
+    this.eventSource = new EventSource(sseUrl);
+    const handleEvent = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (this.activeIterators.size > 0) {
+          const iterator = this.activeIterators.values().next().value;
+          if (iterator) {
+            this.activeIterators.delete(iterator);
+            iterator.resolve({ value: data, done: false });
+          }
+        } else {
+          this.messageQueue.push(data);
+        }
+      } catch {
+      }
+    };
+    const handleError = () => {
+      this.isDone = true;
+      this.eventSource?.close();
+      this.eventSource = null;
+      for (const iterator of this.activeIterators) {
+        iterator.reject(new Error("SSE connection error"));
+      }
+      this.activeIterators.clear();
+    };
+    for (const eventType of types.STREAM_EVENT_TYPE_NAMES) {
+      this.eventSource.addEventListener(eventType, handleEvent);
+    }
+    this.eventSource.addEventListener("error", handleEvent);
+    this.eventSource.onmessage = handleEvent;
+    this.eventSource.onerror = handleError;
+  }
+  /**
+   * Create an async iterable for a single receive() call
+   *
+   * This iterator continues until a final message_stop is received (stopReason !== "tool_use").
+   * For tool calls, this means it will span multiple message_start/message_stop cycles.
+   * The SSE connection itself remains open for future receive() calls.
+   */
+  createIterator() {
+    const connection = this;
+    return {
+      [Symbol.asyncIterator]() {
+        let turnComplete = false;
+        return {
+          async next() {
+            if (connection.messageQueue.length > 0) {
+              const event = connection.messageQueue.shift();
+              if (event.type === "message_stop") {
+                const stopReason = event.data.stopReason;
+                if (stopReason !== "tool_use") {
+                  turnComplete = true;
+                }
+              }
+              return { value: event, done: false };
+            }
+            if (turnComplete) {
+              return { done: true, value: void 0 };
+            }
+            if (connection.isDone) {
+              return { done: true, value: void 0 };
+            }
+            return new Promise((resolve, reject) => {
+              const wrappedResolve = (result) => {
+                if (!result.done) {
+                  if (result.value.type === "message_stop") {
+                    const stopReason = result.value.data.stopReason;
+                    if (stopReason !== "tool_use") {
+                      turnComplete = true;
+                    }
+                  }
+                }
+                resolve(result);
+              };
+              const iterator = { resolve: wrappedResolve, reject };
+              connection.activeIterators.add(iterator);
+            });
+          },
+          async return() {
+            return { done: true, value: void 0 };
+          }
+        };
+      }
+    };
+  }
+  /**
+   * Close the connection
+   */
+  close() {
+    this.isDone = true;
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+    for (const iterator of this.activeIterators) {
+      iterator.reject(new Error("Connection closed"));
+    }
+    this.activeIterators.clear();
+    this.messageQueue = [];
+  }
+};
+function createSSEDriver(config) {
+  const { serverUrl, agentId, headers = {}, sseParams = {} } = config;
+  let connection = null;
+  return {
+    name: "SSEDriver",
+    async *receive(message) {
+      if (!connection) {
+        connection = new PersistentSSEConnection(serverUrl, agentId, sseParams);
+        connection.connect();
+      }
+      const messageUrl = `${serverUrl}/agents/${agentId}/messages`;
+      const response = await fetch(messageUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        },
+        body: JSON.stringify({
+          content: typeof message.content === "string" ? message.content : message.content
+        })
+      });
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        throw new Error(errorBody.error?.message || `HTTP ${response.status}`);
+      }
+      yield* connection.createIterator();
+    },
+    interrupt() {
+      const interruptUrl = `${serverUrl}/agents/${agentId}/interrupt`;
+      fetch(interruptUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...headers
+        }
+      }).catch(() => {
+      });
+    }
+  };
+}
+var logger8 = common.createLogger("agentx/RemoteRepository");
+var RemoteRepository = class {
+  constructor(options) {
+    __publicField(this, "client");
+    this.client = createHttpClient({
+      baseUrl: options.serverUrl,
+      headers: options.headers
+    });
+    logger8.debug("RemoteRepository created", { serverUrl: options.serverUrl });
+  }
+  // ==================== Definition ====================
+  async saveDefinition(record) {
+    await this.client.put(`definitions/${record.name}`, { json: record });
+  }
+  async findDefinitionByName(name) {
+    try {
+      const result = await this.client.get(`definitions/${name}`).json();
+      return this.parseDefinitionRecord(result);
+    } catch (error) {
+      if (this.isNotFound(error)) return null;
+      throw error;
+    }
+  }
+  async findAllDefinitions() {
+    const result = await this.client.get("definitions").json();
+    return result.map((r) => this.parseDefinitionRecord(r));
+  }
+  async deleteDefinition(name) {
+    await this.client.delete(`definitions/${name}`);
+  }
+  async definitionExists(name) {
+    try {
+      await this.client.head(`definitions/${name}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ==================== Image ====================
+  async saveImage(record) {
+    await this.client.put(`images/${record.imageId}`, { json: record });
+  }
+  async findImageById(imageId) {
+    try {
+      const result = await this.client.get(`images/${imageId}`).json();
+      return this.parseImageRecord(result);
+    } catch (error) {
+      if (this.isNotFound(error)) return null;
+      throw error;
+    }
+  }
+  async findAllImages() {
+    const result = await this.client.get("images").json();
+    return result.map((r) => this.parseImageRecord(r));
+  }
+  async deleteImage(imageId) {
+    await this.client.delete(`images/${imageId}`);
+  }
+  async imageExists(imageId) {
+    try {
+      await this.client.head(`images/${imageId}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ==================== Session ====================
+  async saveSession(record) {
+    await this.client.put(`sessions/${record.sessionId}`, { json: record });
+  }
+  async findSessionById(sessionId) {
+    try {
+      const result = await this.client.get(`sessions/${sessionId}`).json();
+      return this.parseSessionRecord(result);
+    } catch (error) {
+      if (this.isNotFound(error)) return null;
+      throw error;
+    }
+  }
+  async findSessionsByImageId(imageId) {
+    const result = await this.client.get(`images/${imageId}/sessions`).json();
+    return result.map((r) => this.parseSessionRecord(r));
+  }
+  async findSessionsByUserId(userId) {
+    const result = await this.client.get(`users/${userId}/sessions`).json();
+    return result.map((r) => this.parseSessionRecord(r));
+  }
+  async findAllSessions() {
+    const result = await this.client.get("sessions").json();
+    return result.map((r) => this.parseSessionRecord(r));
+  }
+  async deleteSession(sessionId) {
+    await this.client.delete(`sessions/${sessionId}`);
+  }
+  async deleteSessionsByImageId(imageId) {
+    await this.client.delete(`images/${imageId}/sessions`);
+  }
+  async sessionExists(sessionId) {
+    try {
+      await this.client.head(`sessions/${sessionId}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ==================== Message ====================
+  /**
+   * Save message - noop in browser
+   *
+   * Messages are persisted by server-side SessionCollector.
+   * Browser-side calls this but it does nothing to avoid duplicate saves.
+   */
+  async saveMessage(_record) {
+    logger8.debug("saveMessage called (noop in browser)");
+  }
+  async findMessageById(messageId) {
+    try {
+      const result = await this.client.get(`messages/${messageId}`).json();
+      return this.parseMessageRecord(result);
+    } catch (error) {
+      if (this.isNotFound(error)) return null;
+      throw error;
+    }
+  }
+  async findMessagesBySessionId(sessionId) {
+    const result = await this.client.get(`sessions/${sessionId}/messages`).json();
+    return result.map((r) => this.parseMessageRecord(r));
+  }
+  async deleteMessage(messageId) {
+    await this.client.delete(`messages/${messageId}`);
+  }
+  async deleteMessagesBySessionId(sessionId) {
+    await this.client.delete(`sessions/${sessionId}/messages`);
+  }
+  async countMessagesBySessionId(sessionId) {
+    const result = await this.client.get(`sessions/${sessionId}/messages/count`).json();
+    return result.count;
+  }
+  // ==================== Container ====================
+  async saveContainer(record) {
+    await this.client.put(`containers/${record.containerId}`, { json: record });
+  }
+  async findContainerById(containerId) {
+    try {
+      const result = await this.client.get(`containers/${containerId}`).json();
+      return this.parseContainerRecord(result);
+    } catch (error) {
+      if (this.isNotFound(error)) return null;
+      throw error;
+    }
+  }
+  async findAllContainers() {
+    const result = await this.client.get("containers").json();
+    return result.map((r) => this.parseContainerRecord(r));
+  }
+  async deleteContainer(containerId) {
+    await this.client.delete(`containers/${containerId}`);
+  }
+  async containerExists(containerId) {
+    try {
+      await this.client.head(`containers/${containerId}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // ==================== Helpers ====================
+  isNotFound(error) {
+    return error?.response?.status === 404;
+  }
+  parseDefinitionRecord(raw) {
+    return {
+      ...raw,
+      createdAt: new Date(raw.createdAt),
+      updatedAt: new Date(raw.updatedAt)
+    };
+  }
+  parseImageRecord(raw) {
+    return {
+      ...raw,
+      createdAt: new Date(raw.createdAt)
+    };
+  }
+  parseSessionRecord(raw) {
+    return {
+      ...raw,
+      createdAt: new Date(raw.createdAt),
+      updatedAt: new Date(raw.updatedAt)
+    };
+  }
+  parseMessageRecord(raw) {
+    return {
+      ...raw,
+      createdAt: new Date(raw.createdAt)
+    };
+  }
+  parseContainerRecord(raw) {
+    return {
+      ...raw
+      // ContainerRecord uses number timestamps, no conversion needed
+    };
+  }
+};
+var _BrowserLogger = class _BrowserLogger {
+  constructor(name, options = {}) {
+    __publicField(this, "name");
+    __publicField(this, "level");
+    __publicField(this, "collapsed");
+    this.name = name;
+    this.level = options.level ?? types.LogLevel.INFO;
+    this.collapsed = options.collapsed ?? true;
+  }
+  debug(message, context) {
+    if (this.isDebugEnabled()) {
+      this.log("DEBUG", message, context);
+    }
+  }
+  info(message, context) {
+    if (this.isInfoEnabled()) {
+      this.log("INFO", message, context);
+    }
+  }
+  warn(message, context) {
+    if (this.isWarnEnabled()) {
+      this.log("WARN", message, context);
+    }
+  }
+  error(message, context) {
+    if (this.isErrorEnabled()) {
+      if (message instanceof Error) {
+        this.log("ERROR", message.message, { ...context, stack: message.stack });
+      } else {
+        this.log("ERROR", message, context);
+      }
+    }
+  }
+  isDebugEnabled() {
+    return this.level <= types.LogLevel.DEBUG;
+  }
+  isInfoEnabled() {
+    return this.level <= types.LogLevel.INFO;
+  }
+  isWarnEnabled() {
+    return this.level <= types.LogLevel.WARN;
+  }
+  isErrorEnabled() {
+    return this.level <= types.LogLevel.ERROR;
+  }
+  log(level, message, context) {
+    const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+    const consoleMethod = this.getConsoleMethod(level);
+    const badgeStyle = _BrowserLogger.BADGE_STYLES[level];
+    const format = `%c${timestamp} %c${level}%c %c[${this.name}]%c ${message}`;
+    const styles = [
+      _BrowserLogger.STYLES.TIMESTAMP,
+      badgeStyle,
+      "",
+      // reset after badge
+      _BrowserLogger.STYLES.NAME,
+      _BrowserLogger.STYLES.MESSAGE
+    ];
+    if (context && Object.keys(context).length > 0) {
+      const groupMethod = this.collapsed ? console.groupCollapsed : console.group;
+      groupMethod.call(console, format, ...styles);
+      console.log("Context:", context);
+      console.groupEnd();
+    } else {
+      consoleMethod(format, ...styles);
+    }
+  }
+  getConsoleMethod(level) {
+    switch (level) {
+      case "DEBUG":
+        return console.debug.bind(console);
+      case "INFO":
+        return console.info.bind(console);
+      case "WARN":
+        return console.warn.bind(console);
+      case "ERROR":
+        return console.error.bind(console);
+      default:
+        return console.log.bind(console);
+    }
+  }
+};
+// CSS styles for different log levels
+__publicField(_BrowserLogger, "STYLES", {
+  DEBUG: "color: #6B7280; font-weight: normal;",
+  // gray
+  INFO: "color: #10B981; font-weight: normal;",
+  // green
+  WARN: "color: #F59E0B; font-weight: bold;",
+  // amber
+  ERROR: "color: #EF4444; font-weight: bold;",
+  // red
+  TIMESTAMP: "color: #9CA3AF; font-weight: normal;",
+  // light gray
+  NAME: "color: #8B5CF6; font-weight: normal;",
+  // purple
+  MESSAGE: "color: inherit; font-weight: normal;"
+});
+// Badge styles for level indicators
+__publicField(_BrowserLogger, "BADGE_STYLES", {
+  DEBUG: "background: #E5E7EB; color: #374151; padding: 2px 6px; border-radius: 3px; font-size: 11px;",
+  INFO: "background: #D1FAE5; color: #065F46; padding: 2px 6px; border-radius: 3px; font-size: 11px;",
+  WARN: "background: #FEF3C7; color: #92400E; padding: 2px 6px; border-radius: 3px; font-size: 11px;",
+  ERROR: "background: #FEE2E2; color: #991B1B; padding: 2px 6px; border-radius: 3px; font-size: 11px;"
+});
+var BrowserLogger = _BrowserLogger;
+
+// src/runtime/sse/logger/BrowserLoggerFactory.ts
+var BrowserLoggerFactory = class {
+  constructor(options = {}) {
+    __publicField(this, "options");
+    __publicField(this, "loggers", /* @__PURE__ */ new Map());
+    this.options = options;
+  }
+  getLogger(name) {
+    if (this.loggers.has(name)) {
+      return this.loggers.get(name);
+    }
+    const logger10 = new BrowserLogger(name, this.options);
+    this.loggers.set(name, logger10);
+    return logger10;
+  }
+};
+var logger9 = common.createLogger("agentx/RemoteAgentIdResolver");
+var RemoteAgentIdResolver = class {
+  constructor(options) {
+    __publicField(this, "client");
+    this.client = createHttpClient({
+      baseUrl: options.serverUrl,
+      headers: options.headers
+    });
+  }
+  async resolveForRun(imageId, containerId) {
+    logger9.debug("Resolving agent ID for run", { imageId, containerId });
+    const response = await this.client.post(`images/${imageId}/run`, {
+      json: { containerId }
+    }).json();
+    logger9.info("Agent ID resolved for run", { imageId, agentId: response.agentId });
+    return response.agentId;
+  }
+  async resolveForResume(sessionId, containerId) {
+    logger9.debug("Resolving agent ID for resume", { sessionId, containerId });
+    const response = await this.client.post(`sessions/${sessionId}/resume`, {
+      json: { containerId }
+    }).json();
+    logger9.info("Agent ID resolved for resume", { sessionId, agentId: response.agentId });
+    return response.agentId;
+  }
+};
+
+// src/runtime/sse/SSERuntime.ts
+var noopSandbox = {
+  name: "browser-noop",
+  workspace: {
+    id: "noop",
+    name: "noop",
+    path: ""
+    // Browser has no local workspace
+  },
+  llm: {
+    name: "noop",
+    provide: () => ({})
+  }
+};
+var SSERuntime = class {
+  constructor(config) {
+    __publicField(this, "name", "sse");
+    __publicField(this, "repository");
+    __publicField(this, "loggerFactory");
+    __publicField(this, "agentIdResolver");
+    __publicField(this, "serverUrl");
+    __publicField(this, "headers");
+    __publicField(this, "sseParams");
+    this.serverUrl = config.serverUrl.replace(/\/+$/, "");
+    this.headers = config.headers ?? {};
+    this.sseParams = config.sseParams ?? {};
+    this.loggerFactory = new BrowserLoggerFactory({
+      collapsed: true
+    });
+    common.setLoggerFactory(this.loggerFactory);
+    this.repository = new RemoteRepository({
+      serverUrl: this.serverUrl,
+      headers: this.headers
+    });
+    this.agentIdResolver = new RemoteAgentIdResolver({
+      serverUrl: this.serverUrl,
+      headers: this.headers
+    });
+  }
+  createSandbox(_containerId) {
+    return noopSandbox;
+  }
+  createDriver(_definition, context, _sandbox) {
+    const driver = createSSEDriver({
+      serverUrl: this.serverUrl,
+      agentId: context.agentId,
+      headers: this.headers,
+      sseParams: this.sseParams
+    });
+    return {
+      ...driver,
+      sandbox: noopSandbox
+    };
+  }
+  createLogger(name) {
+    return this.loggerFactory.getLogger(name);
+  }
+};
+function sseRuntime(config) {
+  return new SSERuntime(config);
+}
+var createSSERuntime = sseRuntime;
+
+exports.createAgentX = createAgentX;
+exports.createSSERuntime = createSSERuntime;
+exports.defineAgent = defineAgent;
+exports.sseRuntime = sseRuntime;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map