march-ai-sdk 0.3.0

package/dist/index.js

@@ -0,0 +1,1695 @@
+import { z } from 'zod';
+import * as grpc from '@grpc/grpc-js';
+import * as protoLoader from '@grpc/proto-loader';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+// src/conversation-message.ts
+var ConversationMessage = class _ConversationMessage {
+  id;
+  conversationId;
+  role;
+  content;
+  from;
+  to;
+  createdAt;
+  metadata;
+  constructor(data) {
+    this.id = data.id;
+    this.conversationId = data.conversationId;
+    this.role = data.role;
+    this.content = data.content;
+    this.from = data.from;
+    this.to = data.to;
+    this.createdAt = new Date(data.createdAt);
+    this.metadata = data.metadata;
+  }
+  /**
+   * Create from API response
+   */
+  static fromApiResponse(data) {
+    return new _ConversationMessage({
+      id: data.id,
+      conversationId: data.conversation_id,
+      role: data.role,
+      content: data.content,
+      from: data.from,
+      to: data.to,
+      createdAt: data.created_at,
+      metadata: data.metadata
+    });
+  }
+  /**
+   * Check if this is a user message
+   */
+  isUser() {
+    return this.role === "user";
+  }
+  /**
+   * Check if this is an assistant message
+   */
+  isAssistant() {
+    return this.role === "assistant";
+  }
+};
+
+// src/conversation.ts
+var Conversation = class {
+  conversationId;
+  client;
+  agentName;
+  constructor(conversationId, client, agentName) {
+    this.conversationId = conversationId;
+    this.client = client;
+    this.agentName = agentName;
+  }
+  /**
+   * Get all messages in the conversation.
+   */
+  async getHistory(options = {}) {
+    const messages = await this.client.getMessages(this.conversationId, {
+      limit: options.limit ?? 100,
+      offset: options.offset ?? 0
+    });
+    return messages.map((m) => ConversationMessage.fromApiResponse(m));
+  }
+  /**
+   * Get messages to/from the current agent.
+   * Useful for getting conversation history for a specific agent.
+   */
+  async getAgentHistory(options = {}) {
+    const targetAgent = options.agentName ?? this.agentName;
+    if (!targetAgent) {
+      return this.getHistory(options);
+    }
+    const [toAgent, fromAgent] = await Promise.all([
+      this.client.getMessages(this.conversationId, {
+        to: targetAgent,
+        limit: options.limit ?? 50,
+        offset: options.offset ?? 0
+      }),
+      this.client.getMessages(this.conversationId, {
+        from: targetAgent,
+        limit: options.limit ?? 50,
+        offset: options.offset ?? 0
+      })
+    ]);
+    const allMessages = [...toAgent, ...fromAgent];
+    const uniqueMessages = Array.from(
+      new Map(allMessages.map((m) => [m.id, m])).values()
+    );
+    uniqueMessages.sort((a, b) => {
+      const dateA = new Date(a.createdAt).getTime();
+      const dateB = new Date(b.createdAt).getTime();
+      return dateA - dateB;
+    });
+    return uniqueMessages.map(
+      (m) => ConversationMessage.fromApiResponse(m)
+    );
+  }
+  /**
+   * Get the last N messages.
+   */
+  async getLastMessages(count) {
+    return this.getHistory({ limit: count });
+  }
+  /**
+   * Get user messages only.
+   */
+  async getUserMessages(options = {}) {
+    const messages = await this.client.getMessages(this.conversationId, {
+      ...options,
+      role: "user"
+    });
+    return messages.map((m) => ConversationMessage.fromApiResponse(m));
+  }
+  /**
+   * Get assistant messages only.
+   */
+  async getAssistantMessages(options = {}) {
+    const messages = await this.client.getMessages(this.conversationId, {
+      ...options,
+      role: "assistant"
+    });
+    return messages.map((m) => ConversationMessage.fromApiResponse(m));
+  }
+};
+
+// src/memory.ts
+var Memory = class {
+  userId;
+  conversationId;
+  client;
+  constructor(userId, conversationId, client) {
+    this.userId = userId;
+    this.conversationId = conversationId;
+    this.client = client;
+  }
+  /**
+   * Add messages to memory.
+   */
+  async addMessages(messages) {
+    const result = await this.client.addMessages(
+      this.userId,
+      this.conversationId,
+      messages
+    );
+    return result.added;
+  }
+  /**
+   * Add a single message to memory.
+   */
+  async addMessage(role, content) {
+    await this.addMessages([{ role, content }]);
+  }
+  /**
+   * Search memory for relevant content.
+   */
+  async search(query, limit = 10) {
+    return this.client.search(this.userId, query, limit);
+  }
+  /**
+   * Get user summary.
+   */
+  async getSummary() {
+    return this.client.getUserSummary(this.userId);
+  }
+  /**
+   * Clear all memories for this user.
+   */
+  async clear() {
+    const result = await this.client.clearMemory(this.userId);
+    return result.deleted;
+  }
+};
+
+// src/exceptions.ts
+var MarchAgentError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MarchAgentError";
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+};
+var RegistrationError = class extends MarchAgentError {
+  constructor(message) {
+    super(message);
+    this.name = "RegistrationError";
+  }
+};
+var KafkaError = class extends MarchAgentError {
+  constructor(message) {
+    super(message);
+    this.name = "KafkaError";
+  }
+};
+var ConfigurationError = class extends MarchAgentError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+  }
+};
+var APIException = class extends MarchAgentError {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message);
+    this.name = "APIException";
+    this.statusCode = statusCode;
+  }
+};
+var HeartbeatError = class extends MarchAgentError {
+  constructor(message) {
+    super(message);
+    this.name = "HeartbeatError";
+  }
+};
+var GatewayError = class extends MarchAgentError {
+  constructor(message) {
+    super(message);
+    this.name = "GatewayError";
+  }
+};
+var AttachmentInfoSchema = z.object({
+  url: z.string(),
+  filename: z.string(),
+  contentType: z.string(),
+  size: z.number().optional(),
+  fileType: z.string().optional()
+});
+
+// src/attachment-client.ts
+function createAttachmentInfo(data) {
+  return AttachmentInfoSchema.parse({
+    url: data.url,
+    filename: data.filename || data.file_name,
+    contentType: data.content_type || data.contentType,
+    size: data.size,
+    fileType: data.file_type || data.fileType
+  });
+}
+var AttachmentClient = class {
+  baseUrl;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  /**
+   * Build full URL for an attachment.
+   */
+  buildUrl(attachmentUrl) {
+    if (attachmentUrl.startsWith("http://") || attachmentUrl.startsWith("https://")) {
+      return attachmentUrl;
+    }
+    return `${this.baseUrl}${attachmentUrl.startsWith("/") ? "" : "/"}${attachmentUrl}`;
+  }
+  /**
+   * Download attachment as bytes (Buffer).
+   */
+  async download(url) {
+    const fullUrl = this.buildUrl(url);
+    try {
+      const response = await fetch(fullUrl);
+      if (!response.ok) {
+        throw new APIException(`Failed to download attachment: ${response.status}`, response.status);
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to download attachment: ${error}`);
+    }
+  }
+  /**
+   * Download attachment as base64 string.
+   * Useful for LLM vision APIs.
+   */
+  async downloadAsBase64(url) {
+    const buffer = await this.download(url);
+    return buffer.toString("base64");
+  }
+};
+
+// src/message.ts
+var Message = class _Message {
+  content;
+  conversationId;
+  userId;
+  headers;
+  rawBody;
+  conversation;
+  memory;
+  metadata;
+  schema;
+  attachment;
+  attachmentClient;
+  constructor(options) {
+    this.content = options.content;
+    this.conversationId = options.conversationId;
+    this.userId = options.userId;
+    this.headers = options.headers;
+    this.rawBody = options.rawBody;
+    this.conversation = options.conversation;
+    this.memory = options.memory;
+    this.metadata = options.metadata;
+    this.schema = options.schema;
+    this.attachment = options.attachment;
+    this.attachmentClient = options.attachmentClient;
+  }
+  /**
+   * Create Message from Kafka message data.
+   */
+  static fromKafkaMessage(body, headers, options = {}) {
+    const conversationId = headers.conversationId ?? "";
+    const userId = headers.userId ?? "anonymous";
+    let metadata;
+    if (headers.messageMetadata) {
+      try {
+        metadata = JSON.parse(headers.messageMetadata);
+      } catch {
+      }
+    }
+    let schema;
+    if (headers.messageSchema) {
+      try {
+        schema = JSON.parse(headers.messageSchema);
+      } catch {
+      }
+    }
+    let attachment;
+    if (headers.attachment) {
+      try {
+        const attachmentData = JSON.parse(headers.attachment);
+        attachment = createAttachmentInfo(attachmentData);
+      } catch {
+      }
+    }
+    if (!attachment && body.attachment) {
+      try {
+        attachment = createAttachmentInfo(body.attachment);
+      } catch {
+      }
+    }
+    let conversation;
+    if (conversationId && options.conversationClient) {
+      conversation = new Conversation(
+        conversationId,
+        options.conversationClient,
+        options.agentName
+      );
+    }
+    let memory;
+    if (options.memoryClient && userId && conversationId) {
+      memory = new Memory(userId, conversationId, options.memoryClient);
+    }
+    return new _Message({
+      content: body.content ?? "",
+      conversationId,
+      userId,
+      headers,
+      rawBody: body,
+      conversation,
+      memory,
+      metadata,
+      schema,
+      attachment,
+      attachmentClient: options.attachmentClient
+    });
+  }
+  /**
+   * Check if message has an attachment.
+   */
+  hasAttachment() {
+    return this.attachment !== void 0;
+  }
+  /**
+   * Download attachment as bytes (Buffer).
+   * 
+   * @throws Error if no attachment is available
+   */
+  async getAttachmentBytes() {
+    if (!this.attachment) {
+      throw new Error("No attachment available");
+    }
+    if (!this.attachmentClient) {
+      throw new Error("AttachmentClient not available");
+    }
+    return this.attachmentClient.download(this.attachment.url);
+  }
+  /**
+   * Get attachment as base64 string (for LLM vision APIs).
+   * 
+   * @throws Error if no attachment is available
+   */
+  async getAttachmentBase64() {
+    if (!this.attachment) {
+      throw new Error("No attachment available");
+    }
+    if (!this.attachmentClient) {
+      throw new Error("AttachmentClient not available");
+    }
+    return this.attachmentClient.downloadAsBase64(this.attachment.url);
+  }
+};
+var ArtifactTypeSchema = z.enum([
+  "document",
+  "image",
+  "iframe",
+  "video",
+  "audio",
+  "code",
+  "link",
+  "file"
+]);
+var ArtifactSchema = z.object({
+  url: z.string(),
+  type: ArtifactTypeSchema,
+  title: z.string().optional(),
+  description: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+function toArtifact(input) {
+  return ArtifactSchema.parse({
+    url: input.url,
+    type: input.type,
+    title: input.title,
+    description: input.description,
+    metadata: input.metadata
+  });
+}
+
+// src/streamer.ts
+var Streamer = class {
+  agentName;
+  originalMessage;
+  gatewayClient;
+  conversationClient;
+  sendTo;
+  awaiting;
+  responseSchema;
+  messageMetadata;
+  artifacts = [];
+  streamedContent = "";
+  firstChunkSent = false;
+  finished = false;
+  constructor(options) {
+    this.agentName = options.agentName;
+    this.originalMessage = options.originalMessage;
+    this.gatewayClient = options.gatewayClient;
+    this.conversationClient = options.conversationClient;
+    this.awaiting = options.awaiting ?? false;
+    this.sendTo = options.sendTo ?? "user";
+  }
+  /**
+   * Set response schema for form rendering (fluent API).
+   */
+  setResponseSchema(schema) {
+    this.responseSchema = schema;
+    return this;
+  }
+  /**
+   * Set message metadata (fluent API).
+   */
+  setMessageMetadata(metadata) {
+    this.messageMetadata = metadata;
+    return this;
+  }
+  /**
+   * Add an artifact to the message (fluent API).
+   */
+  addArtifact(artifact) {
+    this.artifacts.push(toArtifact(artifact));
+    return this;
+  }
+  /**
+   * Set all artifacts at once (replaces any existing).
+   */
+  setArtifacts(artifacts) {
+    this.artifacts = artifacts.map(toArtifact);
+    return this;
+  }
+  /**
+   * Stream a content chunk.
+   */
+  stream(content, options = {}) {
+    const { persist = true, eventType } = options;
+    if (this.finished) {
+      console.warn("Streamer.stream() called after finish()");
+      return;
+    }
+    if (persist) {
+      this.streamedContent += content;
+    }
+    this.send(content, false, persist, eventType);
+  }
+  /**
+   * Alias for stream() - write a content chunk.
+   */
+  write(content, persist = true) {
+    this.stream(content, { persist });
+  }
+  /**
+   * Finish streaming with done=true signal.
+   */
+  async finish(awaitingOverride) {
+    if (this.finished) {
+      return;
+    }
+    this.finished = true;
+    let finalAwaiting = awaitingOverride ?? this.awaiting;
+    if (this.responseSchema && awaitingOverride !== false) {
+      finalAwaiting = true;
+    }
+    this.send("", true, false);
+    if (this.responseSchema && this.conversationClient) {
+      await this.setPendingResponseSchema();
+    }
+    if (finalAwaiting && this.conversationClient) {
+      await this.setAwaitingRoute();
+    }
+  }
+  /**
+   * Send message to router via gateway.
+   */
+  send(content, done, persist = true, eventType) {
+    const headers = {
+      conversationId: this.originalMessage.conversationId,
+      userId: this.originalMessage.userId,
+      from_: this.agentName,
+      to_: this.sendTo,
+      nextRoute: this.sendTo
+    };
+    if (eventType) {
+      headers.eventType = eventType;
+    }
+    if (!this.firstChunkSent) {
+      this.firstChunkSent = true;
+      if (this.messageMetadata) {
+        headers.messageMetadata = JSON.stringify(this.messageMetadata);
+      }
+      if (this.artifacts.length > 0) {
+        headers.artifacts = JSON.stringify(this.artifacts);
+      }
+      if (this.responseSchema) {
+        headers.responseSchema = JSON.stringify(this.responseSchema);
+      }
+    }
+    const body = {
+      content,
+      done,
+      persist
+    };
+    if (eventType) {
+      body.eventType = eventType;
+    }
+    this.gatewayClient.produce(
+      "router.inbox",
+      this.originalMessage.conversationId,
+      headers,
+      body
+    );
+  }
+  /**
+   * Store response schema on conversation for form validation.
+   */
+  async setPendingResponseSchema() {
+    if (!this.conversationClient || !this.responseSchema) return;
+    try {
+      await this.conversationClient.updateConversation(
+        this.originalMessage.conversationId,
+        { pendingResponseSchema: this.responseSchema }
+      );
+    } catch (error) {
+      console.error("Failed to set pending response schema:", error);
+    }
+  }
+  /**
+   * Set awaiting_route to this agent's name.
+   */
+  async setAwaitingRoute() {
+    if (!this.conversationClient) return;
+    try {
+      await this.conversationClient.updateConversation(
+        this.originalMessage.conversationId,
+        { awaitingRoute: this.agentName }
+      );
+    } catch (error) {
+      console.error("Failed to set awaiting route:", error);
+    }
+  }
+  /**
+   * Get the accumulated streamed content.
+   */
+  getStreamedContent() {
+    return this.streamedContent;
+  }
+  /**
+   * Support for async disposal (TypeScript 5.2+ "using" syntax).
+   */
+  async [Symbol.asyncDispose]() {
+    if (!this.finished) {
+      await this.finish();
+    }
+  }
+};
+
+// src/api-paths.ts
+var AI_INVENTORY_PATHS = {
+  /** Register a new agent */
+  AGENT_REGISTER: "/api/v1/agents/register",
+  /** Send heartbeat */
+  HEALTH_HEARTBEAT: "/api/v1/health/heartbeat"
+};
+var CONVERSATION_STORE_PATHS = {
+  /** Get/update conversation by ID */
+  CONVERSATION: (conversationId) => `/conversations/${conversationId}`,
+  /** Get messages for a conversation */
+  CONVERSATION_MESSAGES: (conversationId) => `/conversations/${conversationId}/messages`,
+  /** Checkpoints base path */
+  CHECKPOINTS: "/checkpoints/",
+  /** Checkpoint by thread ID */
+  CHECKPOINT_THREAD: (threadId) => `/checkpoints/${threadId}`,
+  /** Agent state by conversation ID */
+  AGENT_STATE: (conversationId) => `/agent-state/${conversationId}`
+};
+var MEMORY_PATHS = {
+  /** User memory base */
+  USER_MEMORY: (userId) => `/memory/${userId}`,
+  /** Add messages to memory */
+  USER_MESSAGES: (userId) => `/memory/${userId}/messages`,
+  /** Search user memory */
+  USER_SEARCH: (userId) => `/memory/${userId}/search`,
+  /** Get user summary */
+  USER_SUMMARY: (userId) => `/memory/${userId}/summary`
+};
+var SERVICES = {
+  AI_INVENTORY: "ai-inventory",
+  CONVERSATION_STORE: "conversation-store",
+  AI_MEMORY: "ai-memory",
+  ATTACHMENT: "attachment"
+};
+
+// src/heartbeat.ts
+var HeartbeatManager = class {
+  gatewayClient;
+  agentName;
+  intervalMs;
+  timer;
+  running = false;
+  constructor(gatewayClient, agentName, intervalSeconds = 60) {
+    this.gatewayClient = gatewayClient;
+    this.agentName = agentName;
+    this.intervalMs = intervalSeconds * 1e3;
+  }
+  /**
+   * Start sending heartbeats.
+   */
+  start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    this.timer = setInterval(() => {
+      this.sendHeartbeat();
+    }, this.intervalMs);
+    this.sendHeartbeat();
+  }
+  /**
+   * Stop sending heartbeats.
+   */
+  stop() {
+    this.running = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+  /**
+   * Send a single heartbeat via HTTP to AI Inventory.
+   */
+  async sendHeartbeat() {
+    if (!this.running) {
+      return;
+    }
+    try {
+      const response = await this.gatewayClient.httpPost(
+        SERVICES.AI_INVENTORY,
+        AI_INVENTORY_PATHS.HEALTH_HEARTBEAT,
+        { name: this.agentName }
+      );
+      if (response.status === 404) {
+        console.warn(`Agent '${this.agentName}' not found. Re-registration may be needed.`);
+      } else if (!response.ok) {
+        console.warn(`Heartbeat returned status ${response.status}`);
+      }
+    } catch (error) {
+      console.error("Heartbeat failed:", error);
+    }
+  }
+  /**
+   * Check if heartbeat is running.
+   */
+  isRunning() {
+    return this.running;
+  }
+};
+
+// src/agent.ts
+var SenderFilter = class {
+  _include = /* @__PURE__ */ new Set();
+  _exclude = /* @__PURE__ */ new Set();
+  matchAll;
+  constructor(senders) {
+    if (!senders || senders.length === 0) {
+      this.matchAll = true;
+    } else {
+      this.matchAll = false;
+      for (const sender of senders) {
+        if (sender.startsWith("~")) {
+          this._exclude.add(sender.slice(1));
+        } else {
+          this._include.add(sender);
+        }
+      }
+    }
+  }
+  /**
+   * Get included senders as an array (for compatibility with Python tests).
+   */
+  get include() {
+    return Array.from(this._include);
+  }
+  /**
+   * Get excluded senders as an array (for compatibility with Python tests).
+   */
+  get exclude() {
+    return Array.from(this._exclude);
+  }
+  /**
+   * Check if sender matches this filter.
+   */
+  matches(sender) {
+    if (this._exclude.has(sender)) {
+      return false;
+    }
+    if (this.matchAll || this._include.size === 0) {
+      return true;
+    }
+    return this._include.has(sender);
+  }
+};
+var Agent = class {
+  name;
+  agentData;
+  sendErrorResponses = true;
+  errorMessageTemplate;
+  gatewayClient;
+  conversationClient;
+  memoryClient;
+  attachmentClient;
+  heartbeatInterval;
+  messageHandlers = [];
+  heartbeatManager;
+  initialized = false;
+  running = false;
+  constructor(options) {
+    this.name = options.name;
+    this.gatewayClient = options.gatewayClient;
+    this.agentData = options.agentData;
+    this.heartbeatInterval = options.heartbeatInterval ?? 60;
+    this.conversationClient = options.conversationClient;
+    this.memoryClient = options.memoryClient;
+    this.attachmentClient = options.attachmentClient;
+    this.errorMessageTemplate = options.errorMessageTemplate ?? "I encountered an error while processing your message. Please try again or contact support if the issue persists.";
+  }
+  onMessage(handler, options) {
+    const filter = new SenderFilter(options?.senders);
+    this.messageHandlers.push([filter, handler]);
+  }
+  /**
+   * Initialize agent after gateway connection is established.
+   */
+  initializeWithGateway() {
+    if (this.initialized) {
+      return;
+    }
+    const topic = `${this.name}.inbox`;
+    this.gatewayClient.registerHandler(topic, (msg) => {
+      this.handleKafkaMessage(msg);
+    });
+    this.heartbeatManager = new HeartbeatManager(
+      this.gatewayClient,
+      this.name,
+      this.heartbeatInterval
+    );
+    this.heartbeatManager.start();
+    this.initialized = true;
+  }
+  /**
+   * Get sender from message headers.
+   */
+  getSender(headers) {
+    return headers.from_ ?? headers.from ?? "user";
+  }
+  /**
+   * Find first handler that matches the sender.
+   */
+  findMatchingHandler(sender) {
+    for (const [filter, handler] of this.messageHandlers) {
+      if (filter.matches(sender)) {
+        return handler;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Handle incoming Kafka message.
+   */
+  handleKafkaMessage(kafkaMsg) {
+    this.handleMessageAsync(kafkaMsg).catch((error) => {
+      console.error("Error in message handler:", error);
+    });
+  }
+  /**
+   * Async message handling with error recovery.
+   */
+  async handleMessageAsync(kafkaMsg) {
+    let message;
+    try {
+      message = Message.fromKafkaMessage(
+        kafkaMsg.body,
+        kafkaMsg.headers,
+        {
+          conversationClient: this.conversationClient,
+          memoryClient: this.memoryClient,
+          attachmentClient: this.attachmentClient,
+          agentName: this.name
+        }
+      );
+      const sender = this.getSender(kafkaMsg.headers);
+      const handler = this.findMatchingHandler(sender);
+      if (!handler) {
+        console.warn(`No handler matched for sender: ${sender}`);
+        return;
+      }
+      await handler(message, sender);
+    } catch (error) {
+      console.error("Error handling message:", error);
+      if (message && this.sendErrorResponses) {
+        await this.sendErrorResponse(message, error);
+      }
+    }
+  }
+  /**
+   * Send error response to user when handler fails.
+   */
+  async sendErrorResponse(message, _error) {
+    try {
+      const streamer = this.streamer(message, { sendTo: "user" });
+      streamer.stream(this.errorMessageTemplate);
+      await streamer.finish();
+    } catch (err) {
+      console.error("Failed to send error response:", err);
+    }
+  }
+  /**
+   * Create a new Streamer for streaming responses.
+   */
+  streamer(message, options = {}) {
+    return new Streamer({
+      agentName: this.name,
+      originalMessage: message,
+      gatewayClient: this.gatewayClient,
+      conversationClient: this.conversationClient,
+      awaiting: options.awaiting ?? false,
+      sendTo: options.sendTo ?? "user"
+    });
+  }
+  /**
+   * Mark agent as ready to consume messages.
+   */
+  startConsuming() {
+    if (this.messageHandlers.length === 0) {
+      throw new ConfigurationError("No message handlers registered");
+    }
+    if (!this.initialized) {
+      throw new ConfigurationError("Agent not initialized with gateway");
+    }
+    this.running = true;
+    console.log(`Agent ${this.name} is now consuming messages`);
+  }
+  /**
+   * Shutdown agent gracefully.
+   */
+  shutdown() {
+    this.running = false;
+    if (this.heartbeatManager) {
+      this.heartbeatManager.stop();
+    }
+    console.log(`Agent ${this.name} shutdown`);
+  }
+  /**
+   * Check if agent is running.
+   */
+  isRunning() {
+    return this.running;
+  }
+};
+var __filename$1 = fileURLToPath(import.meta.url);
+var __dirname$1 = dirname(__filename$1);
+var PROTO_PATH = join(__dirname$1, "proto", "gateway.proto");
+var packageDefinition = protoLoader.loadSync(PROTO_PATH, {
+  keepCase: true,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true
+});
+var gatewayProto = grpc.loadPackageDefinition(packageDefinition);
+var GatewayClient = class {
+  gatewayUrl;
+  apiKey;
+  secure;
+  client;
+  stream;
+  _connectionId;
+  messageQueue = [];
+  pendingProduceAcks = /* @__PURE__ */ new Map();
+  pendingSubscribeAcks = /* @__PURE__ */ new Map();
+  messageHandlers = /* @__PURE__ */ new Map();
+  correlationCounter = 0;
+  connected = false;
+  constructor(gatewayUrl, apiKey, secure = false) {
+    this.gatewayUrl = gatewayUrl;
+    this.apiKey = apiKey;
+    this.secure = secure;
+  }
+  /**
+   * HTTP URL for AI Inventory service via proxy.
+   */
+  get aiInventoryUrl() {
+    const protocol = this.secure ? "https" : "http";
+    return `${protocol}://${this.gatewayUrl}/s/ai-inventory`;
+  }
+  /**
+   * HTTP URL for Conversation Store service via proxy.
+   */
+  get conversationStoreUrl() {
+    const protocol = this.secure ? "https" : "http";
+    return `${protocol}://${this.gatewayUrl}/s/conversation-store`;
+  }
+  /**
+   * HTTP URL for AI Memory service via proxy.
+   */
+  get aiMemoryUrl() {
+    const protocol = this.secure ? "https" : "http";
+    return `${protocol}://${this.gatewayUrl}/s/ai-memory`;
+  }
+  /**
+   * HTTP URL for Attachment service via proxy.
+   */
+  get attachmentUrl() {
+    const protocol = this.secure ? "https" : "http";
+    return `${protocol}://${this.gatewayUrl}/s/attachment`;
+  }
+  /**
+   * Register a handler for a topic.
+   */
+  registerHandler(topic, handler) {
+    this.messageHandlers.set(topic, handler);
+  }
+  /**
+   * Connect to the gateway and authenticate.
+   */
+  async connect(agentNames) {
+    const credentials2 = this.secure ? grpc.credentials.createSsl() : grpc.credentials.createInsecure();
+    this.client = new gatewayProto.gateway.AgentGateway(
+      this.gatewayUrl,
+      credentials2
+    );
+    this.stream = this.client.AgentStream();
+    this.stream.on("data", (msg) => {
+      this.handleServerMessage(msg);
+    });
+    this.stream.on("error", (err) => {
+      console.error("Gateway stream error:", err);
+      this.connected = false;
+    });
+    this.stream.on("end", () => {
+      console.log("Gateway stream ended");
+      this.connected = false;
+    });
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new GatewayError("Authentication timeout"));
+      }, 1e4);
+      const authHandler = (msg) => {
+        if (msg.auth_response) {
+          clearTimeout(timeout);
+          this._connectionId = msg.auth_response.connection_id;
+          this.connected = true;
+          resolve(msg.auth_response.subscribed_topics);
+        } else if (msg.error) {
+          clearTimeout(timeout);
+          reject(new GatewayError(`Authentication failed: ${msg.error.message}`));
+        }
+      };
+      const originalHandler = this.handleServerMessage.bind(this);
+      this.handleServerMessage = (msg) => {
+        if (msg.auth_response || msg.error) {
+          authHandler(msg);
+          this.handleServerMessage = originalHandler;
+        } else {
+          originalHandler(msg);
+        }
+      };
+      this.stream.write({
+        auth: {
+          api_key: this.apiKey,
+          agent_names: agentNames
+        }
+      });
+    });
+  }
+  /**
+   * Handle incoming server messages.
+   */
+  handleServerMessage(msg) {
+    if (msg.message) {
+      const kafkaMsg = {
+        topic: msg.message.topic,
+        partition: msg.message.partition,
+        offset: parseInt(msg.message.offset, 10),
+        key: msg.message.key,
+        headers: msg.message.headers,
+        body: JSON.parse(msg.message.body.toString()),
+        timestamp: parseInt(msg.message.timestamp, 10)
+      };
+      const handler = this.messageHandlers.get(kafkaMsg.topic);
+      if (handler) {
+        handler(kafkaMsg);
+      } else {
+        this.messageQueue.push(kafkaMsg);
+      }
+    } else if (msg.produce_ack) {
+      const callback = this.pendingProduceAcks.get(msg.produce_ack.correlation_id);
+      if (callback) {
+        callback({
+          topic: msg.produce_ack.topic,
+          partition: msg.produce_ack.partition,
+          offset: parseInt(msg.produce_ack.offset, 10),
+          correlationId: msg.produce_ack.correlation_id
+        });
+        this.pendingProduceAcks.delete(msg.produce_ack.correlation_id);
+      }
+    } else if (msg.subscribe_ack) {
+      const callback = this.pendingSubscribeAcks.get(msg.subscribe_ack.topic);
+      if (callback) {
+        callback(msg.subscribe_ack.topic);
+        this.pendingSubscribeAcks.delete(msg.subscribe_ack.topic);
+      }
+    } else if (msg.error) {
+      console.error("Gateway error:", msg.error.message);
+    }
+  }
+  /**
+   * Subscribe to an additional agent's topic.
+   */
+  async subscribe(agentName) {
+    if (!this.stream || !this.connected) {
+      throw new GatewayError("Not connected");
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new GatewayError("Subscribe timeout"));
+      }, 5e3);
+      const expectedTopic = `${agentName}.inbox`;
+      this.pendingSubscribeAcks.set(expectedTopic, (topic) => {
+        clearTimeout(timeout);
+        resolve(topic);
+      });
+      this.stream.write({
+        subscribe: { agent_name: agentName }
+      });
+    });
+  }
+  /**
+   * Unsubscribe from an agent's topic.
+   */
+  unsubscribe(agentName) {
+    if (!this.stream || !this.connected) {
+      throw new GatewayError("Not connected");
+    }
+    this.stream.write({
+      unsubscribe: { agent_name: agentName }
+    });
+  }
+  /**
+   * Produce a message to Kafka via the gateway.
+   */
+  produce(topic, key, headers, body, correlationId) {
+    if (!this.stream || !this.connected) {
+      throw new GatewayError("Not connected");
+    }
+    const corrId = correlationId ?? `${++this.correlationCounter}`;
+    this.stream.write({
+      produce: {
+        topic,
+        key,
+        headers,
+        body: Buffer.from(JSON.stringify(body)),
+        correlation_id: corrId
+      }
+    });
+  }
+  /**
+   * Produce a message and wait for acknowledgment.
+   */
+  async produceAndWait(topic, key, headers, body) {
+    if (!this.stream || !this.connected) {
+      throw new GatewayError("Not connected");
+    }
+    const correlationId = `${++this.correlationCounter}`;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingProduceAcks.delete(correlationId);
+        reject(new GatewayError("Produce timeout"));
+      }, 1e4);
+      this.pendingProduceAcks.set(correlationId, (ack) => {
+        clearTimeout(timeout);
+        resolve(ack);
+      });
+      this.stream.write({
+        produce: {
+          topic,
+          key,
+          headers,
+          body: Buffer.from(JSON.stringify(body)),
+          correlation_id: correlationId
+        }
+      });
+    });
+  }
+  /**
+   * Consume a single message (polling from queue).
+   */
+  consumeOne(_timeout = 1e3) {
+    if (this.messageQueue.length > 0) {
+      return this.messageQueue.shift();
+    }
+    return null;
+  }
+  /**
+   * Send a ping to the gateway.
+   */
+  ping() {
+    if (!this.stream || !this.connected) {
+      throw new GatewayError("Not connected");
+    }
+    this.stream.write({
+      ping: { timestamp: String(Date.now()) }
+    });
+  }
+  /**
+   * Make a sync POST request (used for registration).
+   */
+  async httpPost(service, path, body) {
+    const protocol = this.secure ? "https" : "http";
+    const url = `${protocol}://${this.gatewayUrl}/s/${service}${path}`;
+    return fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.apiKey
+      },
+      body: JSON.stringify(body)
+    });
+  }
+  /**
+   * Check if connected.
+   */
+  isConnected() {
+    return this.connected;
+  }
+  /**
+   * Close the gateway connection.
+   */
+  close() {
+    if (this.stream) {
+      this.stream.end();
+      this.stream = void 0;
+    }
+    this.connected = false;
+  }
+};
+
+// src/conversation-client.ts
+var ConversationClient = class {
+  baseUrl;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  /**
+   * Get conversation metadata.
+   */
+  async getConversation(conversationId) {
+    const url = `${this.baseUrl}/conversations/${conversationId}`;
+    try {
+      const response = await fetch(url);
+      if (response.status === 404) {
+        throw new APIException(`Conversation ${conversationId} not found`, 404);
+      }
+      if (!response.ok) {
+        throw new APIException(`Failed to fetch conversation: ${response.status}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to fetch conversation: ${error}`);
+    }
+  }
+  /**
+   * Get messages from a conversation.
+   */
+  async getMessages(conversationId, options = {}) {
+    const url = new URL(`${this.baseUrl}/conversations/${conversationId}/messages`);
+    const params = {
+      limit: String(Math.min(options.limit ?? 100, 1e3)),
+      offset: String(options.offset ?? 0)
+    };
+    if (options.role) params.role = options.role;
+    if (options.from) params.from = options.from;
+    if (options.to) params.to = options.to;
+    Object.entries(params).forEach(([key, value]) => {
+      url.searchParams.set(key, value);
+    });
+    try {
+      const response = await fetch(url.toString());
+      if (response.status === 404) {
+        throw new APIException(`Conversation ${conversationId} not found`, 404);
+      }
+      if (!response.ok) {
+        throw new APIException(`Failed to fetch messages: ${response.status}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to fetch messages: ${error}`);
+    }
+  }
+  /**
+   * Update conversation fields (PATCH).
+   */
+  async updateConversation(conversationId, data) {
+    const url = `${this.baseUrl}/conversations/${conversationId}`;
+    try {
+      const response = await fetch(url, {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(data)
+      });
+      if (!response.ok) {
+        throw new APIException(`Failed to update conversation: ${response.status}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to update conversation: ${error}`);
+    }
+  }
+};
+
+// src/memory-client.ts
+var MemoryClient = class {
+  baseUrl;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  /**
+   * Add messages to memory for a user/conversation.
+   */
+  async addMessages(userId, conversationId, messages) {
+    const url = `${this.baseUrl}/memory/${userId}/messages`;
+    const payload = {
+      conversation_id: conversationId,
+      messages
+    };
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new APIException(`Failed to add messages to memory: ${response.status} - ${errorText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to add messages to memory: ${error}`);
+    }
+  }
+  /**
+   * Search memory for relevant content.
+   */
+  async search(userId, query, limit = 10) {
+    const url = new URL(`${this.baseUrl}/memory/${userId}/search`);
+    url.searchParams.set("query", query);
+    url.searchParams.set("limit", String(limit));
+    try {
+      const response = await fetch(url.toString());
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new APIException(`Failed to search memory: ${response.status} - ${errorText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to search memory: ${error}`);
+    }
+  }
+  /**
+   * Get user summary.
+   */
+  async getUserSummary(userId) {
+    const url = `${this.baseUrl}/memory/${userId}/summary`;
+    try {
+      const response = await fetch(url);
+      if (response.status === 404) {
+        return null;
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new APIException(`Failed to get user summary: ${response.status} - ${errorText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to get user summary: ${error}`);
+    }
+  }
+  /**
+   * Clear user's memory.
+   */
+  async clearMemory(userId) {
+    const url = `${this.baseUrl}/memory/${userId}`;
+    try {
+      const response = await fetch(url, { method: "DELETE" });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new APIException(`Failed to clear memory: ${response.status} - ${errorText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to clear memory: ${error}`);
+    }
+  }
+};
+
+// src/app.ts
+var MarchAgentApp = class {
+  gatewayClient;
+  conversationClient;
+  memoryClient;
+  attachmentClient;
+  heartbeatInterval;
+  _maxConcurrentTasks;
+  errorMessageTemplate;
+  agents = [];
+  running = false;
+  shutdownRequested = false;
+  constructor(options) {
+    this.heartbeatInterval = options.heartbeatInterval ?? 60;
+    this._maxConcurrentTasks = options.maxConcurrentTasks ?? 100;
+    this.errorMessageTemplate = options.errorMessageTemplate ?? "I encountered an error while processing your message. Please try again or contact support if the issue persists.";
+    this.gatewayClient = new GatewayClient(
+      options.gatewayUrl,
+      options.apiKey,
+      options.secure ?? false
+    );
+    this.conversationClient = new ConversationClient(
+      this.gatewayClient.conversationStoreUrl
+    );
+    this.memoryClient = new MemoryClient(
+      this.gatewayClient.aiMemoryUrl
+    );
+    this.attachmentClient = new AttachmentClient(
+      this.gatewayClient.attachmentUrl
+    );
+  }
+  /**
+   * Register an agent with the backend.
+   */
+  async registerMe(options) {
+    const agentData = await this.registerWithInventory(options);
+    const agent = new Agent({
+      name: options.name,
+      gatewayClient: this.gatewayClient,
+      agentData,
+      heartbeatInterval: this.heartbeatInterval,
+      conversationClient: this.conversationClient,
+      memoryClient: this.memoryClient,
+      attachmentClient: this.attachmentClient,
+      errorMessageTemplate: this.errorMessageTemplate
+    });
+    this.agents.push(agent);
+    console.log(`Registered agent: ${options.name}`);
+    return agent;
+  }
+  /**
+   * Register agent with AI Inventory service.
+   */
+  async registerWithInventory(options) {
+    const payload = {
+      name: options.name,
+      about: options.about,
+      document: options.document,
+      representationName: options.representationName || options.name
+    };
+    if (options.baseUrl) {
+      payload.baseUrl = options.baseUrl;
+    }
+    if (options.metadata) {
+      payload.metadata = options.metadata;
+    }
+    if (options.relatedPages) {
+      payload.relatedPages = options.relatedPages;
+    }
+    try {
+      const response = await this.gatewayClient.httpPost(
+        SERVICES.AI_INVENTORY,
+        AI_INVENTORY_PATHS.AGENT_REGISTER,
+        payload
+      );
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error("Registration failed:", response.status, errorText);
+        throw new RegistrationError(
+          `Failed to register agent ${options.name}: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      return {
+        id: data.id,
+        name: data.name,
+        about: data.about,
+        document: data.document,
+        representationName: data.representationName,
+        baseUrl: data.baseUrl,
+        metadata: data.metadata,
+        relatedPages: data.relatedPages
+      };
+    } catch (error) {
+      if (error instanceof RegistrationError) throw error;
+      throw new RegistrationError(`Failed to register agent ${options.name}: ${error}`);
+    }
+  }
+  /**
+   * Start all registered agents and block until shutdown.
+   */
+  async run() {
+    if (this.agents.length === 0) {
+      throw new ConfigurationError("No agents registered");
+    }
+    const agentNames = this.agents.map((a) => a.name);
+    console.log(`Connecting to gateway with agents: ${agentNames.join(", ")}`);
+    try {
+      const topics = await this.gatewayClient.connect(agentNames);
+      console.log(`Connected. Subscribed to topics: ${topics.join(", ")}`);
+    } catch (error) {
+      throw new ConfigurationError(`Failed to connect to gateway: ${error}`);
+    }
+    for (const agent of this.agents) {
+      agent.initializeWithGateway();
+      agent.startConsuming();
+    }
+    this.running = true;
+    console.log("Agent app is running. Press Ctrl+C to stop.");
+    process.on("SIGINT", () => this.shutdown());
+    process.on("SIGTERM", () => this.shutdown());
+    await this.consumeLoop();
+  }
+  /**
+   * Main consume loop.
+   */
+  async consumeLoop() {
+    while (this.running && !this.shutdownRequested) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  /**
+   * Shutdown all agents gracefully.
+   */
+  shutdown() {
+    if (this.shutdownRequested) {
+      return;
+    }
+    console.log("\nShutting down...");
+    this.shutdownRequested = true;
+    this.running = false;
+    for (const agent of this.agents) {
+      agent.shutdown();
+    }
+    this.gatewayClient.close();
+    console.log("Shutdown complete");
+  }
+};
+
+// src/checkpoint-client.ts
+var CheckpointClient = class {
+  baseUrl;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  /**
+   * Store a checkpoint.
+   */
+  async put(config, checkpoint, metadata, newVersions = {}) {
+    const url = `${this.baseUrl}/checkpoints/`;
+    const payload = {
+      config,
+      checkpoint,
+      metadata,
+      new_versions: newVersions
+    };
+    try {
+      const response = await fetch(url, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new APIException(`Failed to store checkpoint: ${response.status} - ${errorText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to store checkpoint: ${error}`);
+    }
+  }
+  /**
+   * Get a checkpoint tuple.
+   */
+  async getTuple(threadId, checkpointNs = "", checkpointId) {
+    const url = new URL(`${this.baseUrl}/checkpoints/${threadId}`);
+    url.searchParams.set("checkpoint_ns", checkpointNs);
+    if (checkpointId) {
+      url.searchParams.set("checkpoint_id", checkpointId);
+    }
+    try {
+      const response = await fetch(url.toString());
+      if (response.status === 404) {
+        return null;
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new APIException(`Failed to get checkpoint: ${response.status} - ${errorText}`, response.status);
+      }
+      const result = await response.json();
+      return result || null;
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to get checkpoint: ${error}`);
+    }
+  }
+  /**
+   * List checkpoints.
+   */
+  async list(options = {}) {
+    const url = new URL(`${this.baseUrl}/checkpoints/`);
+    if (options.threadId) url.searchParams.set("thread_id", options.threadId);
+    if (options.checkpointNs !== void 0) url.searchParams.set("checkpoint_ns", options.checkpointNs);
+    if (options.before) url.searchParams.set("before", options.before);
+    if (options.limit) url.searchParams.set("limit", String(options.limit));
+    try {
+      const response = await fetch(url.toString());
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new APIException(`Failed to list checkpoints: ${response.status} - ${errorText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to list checkpoints: ${error}`);
+    }
+  }
+  /**
+   * Delete all checkpoints for a thread.
+   */
+  async deleteThread(threadId) {
+    const url = `${this.baseUrl}/checkpoints/${threadId}`;
+    try {
+      const response = await fetch(url, { method: "DELETE" });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new APIException(`Failed to delete checkpoints: ${response.status} - ${errorText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to delete checkpoints: ${error}`);
+    }
+  }
+};
+
+// src/agent-state-client.ts
+var AgentStateClient = class {
+  baseUrl;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  /**
+   * Store or update agent state.
+   */
+  async put(conversationId, namespace, state) {
+    const url = `${this.baseUrl}/agent-state/${conversationId}`;
+    const payload = {
+      namespace,
+      state
+    };
+    try {
+      const response = await fetch(url, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new APIException(`Failed to store agent state: ${response.status} - ${errorText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to store agent state: ${error}`);
+    }
+  }
+  /**
+   * Get agent state.
+   */
+  async get(conversationId, namespace) {
+    const url = new URL(`${this.baseUrl}/agent-state/${conversationId}`);
+    url.searchParams.set("namespace", namespace);
+    try {
+      const response = await fetch(url.toString());
+      if (response.status === 404) {
+        return null;
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new APIException(`Failed to get agent state: ${response.status} - ${errorText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to get agent state: ${error}`);
+    }
+  }
+  /**
+   * Delete agent state.
+   */
+  async delete(conversationId, namespace) {
+    const url = new URL(`${this.baseUrl}/agent-state/${conversationId}`);
+    if (namespace) {
+      url.searchParams.set("namespace", namespace);
+    }
+    try {
+      const response = await fetch(url.toString(), { method: "DELETE" });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new APIException(`Failed to delete agent state: ${response.status} - ${errorText}`, response.status);
+      }
+      return await response.json();
+    } catch (error) {
+      if (error instanceof APIException) throw error;
+      throw new APIException(`Failed to delete agent state: ${error}`);
+    }
+  }
+};
+
+// src/index.ts
+var VERSION = "0.3.0";
+
+export { AI_INVENTORY_PATHS, APIException, Agent, AgentStateClient, AttachmentClient, CONVERSATION_STORE_PATHS, CheckpointClient, ConfigurationError, Conversation, ConversationClient, ConversationMessage, GatewayClient, GatewayError, HeartbeatError, HeartbeatManager, KafkaError, MEMORY_PATHS, MarchAgentApp, MarchAgentError, Memory, MemoryClient, Message, RegistrationError, SERVICES, SenderFilter, Streamer, VERSION, createAttachmentInfo, toArtifact };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map