@agentrun/sdk 0.0.3 → 0.0.4

package/dist/server/protocol/index.js

@@ -0,0 +1,1053 @@
+import { v4 } from 'uuid';
+
+// src/utils/log.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var COLORS = {
+  reset: "\x1B[0m",
+  bright: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  blue: "\x1B[34m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m"
+};
+var Logger = class {
+  level = "info";
+  // match Python logger name
+  prefix = "agentrun-logger";
+  setLevel(level) {
+    this.level = level;
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+  }
+  getColor(level) {
+    switch (level) {
+      case "debug":
+        return COLORS.cyan;
+      case "info":
+        return COLORS.blue;
+      case "warn":
+        return COLORS.yellow;
+      case "error":
+        return COLORS.red;
+      default:
+        return COLORS.reset;
+    }
+  }
+  // format timestamp like Python: YYYY-MM-DD HH:mm:ss,SSS
+  formatTimestamp(d = /* @__PURE__ */ new Date()) {
+    const pad = (n, sz = 2) => n.toString().padStart(sz, "0");
+    const year = d.getFullYear();
+    const month = pad(d.getMonth() + 1);
+    const day = pad(d.getDate());
+    const hour = pad(d.getHours());
+    const minute = pad(d.getMinutes());
+    const second = pad(d.getSeconds());
+    const ms = pad(d.getMilliseconds(), 3);
+    return `${year}-${month}-${day} ${hour}:${minute}:${second},${ms}`;
+  }
+  // attempt to infer caller file and line by parsing Error.stack
+  // helper: parse a single stack frame into {filepath, line, functionName}
+  parseFrame(frame) {
+    const m = frame.match(/^(?:at\s+)?(?:(.+?)\s+\()?(.*?):(\d+):(\d+)\)?$/);
+    if (!m) return null;
+    return {
+      functionName: m[1] ? m[1].trim() : void 0,
+      filepath: m[2],
+      line: parseInt(m[3], 10)
+    };
+  }
+  // get caller by fixed stack offset (used in public log methods)
+  getCallerByOffset() {
+    const err = new Error();
+    const stack = err.stack;
+    if (!stack) return {};
+    const lines = stack.split("\n").map((l) => l.trim());
+    for (let i = 3; i < lines.length; i++) {
+      let parsed = this.parseFrame(lines[i]);
+      if (!parsed) {
+        const m = lines[i].match(/(\/[^:\s]+:\d+:\d+)/);
+        if (m) {
+          const parts = m[1].split(":");
+          parts.pop();
+          const ln = Number(parts.pop());
+          const fp2 = parts.join(":");
+          parsed = { filepath: fp2, line: ln, functionName: void 0 };
+        }
+      }
+      if (!parsed) continue;
+      const fp = parsed.filepath;
+      if (fp.includes("node_modules") || fp.includes("internal") || fp.includes("<anonymous>") || fp.includes("native"))
+        continue;
+      return { filepath: parsed.filepath, line: parsed.line };
+    }
+    const cwd = process.cwd();
+    for (let i = 0; i < lines.length; i++) {
+      let parsed = this.parseFrame(lines[i]);
+      if (!parsed) {
+        const m = lines[i].match(/(\/[^:\s]+:\d+:\d+)/);
+        if (m) {
+          const parts = m[1].split(":");
+          parts.pop();
+          const ln = Number(parts.pop());
+          const fp2 = parts.join(":");
+          parsed = { filepath: fp2, line: ln, functionName: void 0 };
+        }
+      }
+      if (!parsed) continue;
+      const fp = parsed.filepath;
+      if (fp.includes("node_modules") || fp.includes("internal") || fp.includes("<anonymous>") || fp.includes("native"))
+        continue;
+      if (fp.includes("/src/utils/log.ts")) continue;
+      if (fp.startsWith(cwd)) return { filepath: parsed.filepath, line: parsed.line };
+    }
+    for (let i = 0; i < lines.length; i++) {
+      let parsed = this.parseFrame(lines[i]);
+      if (!parsed) {
+        const m = lines[i].match(/(\/[^:\s]+:\d+:\d+)/);
+        if (m) {
+          const parts = m[1].split(":");
+          parts.pop();
+          const ln = Number(parts.pop());
+          const fp2 = parts.join(":");
+          parsed = { filepath: fp2, line: ln, functionName: void 0 };
+        }
+      }
+      if (!parsed) continue;
+      const fp = parsed.filepath;
+      if (fp.includes("node_modules") || fp.includes("internal") || fp.includes("<anonymous>") || fp.includes("native"))
+        continue;
+      if (fp.includes("/src/utils/log.ts")) continue;
+      return { filepath: parsed.filepath, line: parsed.line };
+    }
+    return {};
+  }
+  formatMessage(level, message, filepath, line) {
+    const timestamp = this.formatTimestamp();
+    const color = this.getColor(level);
+    const reset = COLORS.reset;
+    const levelName = level === "warn" ? "WARNING" : level.toUpperCase();
+    const levelStr = `${COLORS.bright}${color}${levelName}${reset}`;
+    const nameStr = `${color}[${this.prefix}]${reset}`;
+    const tsStr = `${color} ${timestamp}${reset}`;
+    const pathInfo = filepath && line !== void 0 ? ` ${COLORS.dim}${COLORS.italic}${filepath}:${line}${reset}` : "";
+    const msg = level === "debug" ? `${COLORS.dim}${message}${reset}` : message;
+    return `
+${levelStr} ${nameStr}${tsStr}${pathInfo}
+${msg}
+`;
+  }
+  debug(message, ...args) {
+    if (this.shouldLog("debug")) {
+      const caller = this.getCallerByOffset();
+      console.debug(this.formatMessage("debug", message, caller.filepath, caller.line), ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.shouldLog("info")) {
+      const caller = this.getCallerByOffset();
+      console.info(this.formatMessage("info", message, caller.filepath, caller.line), ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.shouldLog("warn")) {
+      const caller = this.getCallerByOffset();
+      console.warn(this.formatMessage("warn", message, caller.filepath, caller.line), ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.shouldLog("error")) {
+      const caller = this.getCallerByOffset();
+      console.error(this.formatMessage("error", message, caller.filepath, caller.line), ...args);
+    }
+  }
+};
+var logger = new Logger();
+if (![void 0, null, "", "False", "FALSE", "false", "0"].includes(process.env["AGENTRUN_SDK_DEBUG"])) {
+  logger.setLevel("debug");
+  if (!globalThis._AGENTRUN_DEBUG_LOGGED) {
+    logger.warn("\u542F\u7528 AgentRun SDK \u8C03\u8BD5\u65E5\u5FD7\uFF0C \u79FB\u9664 AGENTRUN_SDK_DEBUG \u73AF\u5883\u53D8\u91CF\u4EE5\u5173\u95ED");
+    globalThis._AGENTRUN_DEBUG_LOGGED = true;
+  }
+} else {
+  logger.setLevel("info");
+}
+
+// src/utils/version-check.ts
+var VERSION = "0.0.4" ;
+if (!process.env.DISABLE_BREAKING_CHANGES_WARNING && !globalThis._AGENTRUN_VERSION_WARNING_SHOWN) {
+  globalThis._AGENTRUN_VERSION_WARNING_SHOWN = true;
+  logger.warn(
+    `\u5F53\u524D\u60A8\u6B63\u5728\u4F7F\u7528 AgentRun Python SDK \u7248\u672C ${VERSION}\u3002\u65E9\u671F\u7248\u672C\u901A\u5E38\u5305\u542B\u8BB8\u591A\u65B0\u529F\u80FD\uFF0C\u8FD9\u4E9B\u529F\u80FD\x1B[1;33m \u53EF\u80FD\u5F15\u5165\u4E0D\u517C\u5BB9\u7684\u53D8\u66F4 \x1B[0m\u3002\u4E3A\u907F\u514D\u6F5C\u5728\u95EE\u9898\uFF0C\u6211\u4EEC\u5F3A\u70C8\u5EFA\u8BAE\x1B[1;32m \u5C06\u4F9D\u8D56\u9501\u5B9A\u4E3A\u6B64\u7248\u672C \x1B[0m\u3002
+You are currently using AgentRun Python SDK version ${VERSION}. Early versions often include many new features, which\x1B[1;33m may introduce breaking changes\x1B[0m. To avoid potential issues, we strongly recommend \x1B[1;32mpinning the dependency to this version\x1B[0m.
+\x1B[2;3m  pip install 'agentrun-sdk==${VERSION}' \x1B[0m
+
+\u589E\u52A0\x1B[2;3m DISABLE_BREAKING_CHANGES_WARNING=1 \x1B[0m\u5230\u60A8\u7684\u73AF\u5883\u53D8\u91CF\u4EE5\u5173\u95ED\u6B64\u8B66\u544A\u3002
+Add\x1B[2;3m DISABLE_BREAKING_CHANGES_WARNING=1 \x1B[0mto your environment variables to disable this warning.
+     
+Releases:\x1B[2;3m https://github.com/Serverless-Devs/agentrun-sdk-python/releases\x1B[0m`
+  );
+}
+
+// src/server/core/model.ts
+var MessageRole = /* @__PURE__ */ ((MessageRole3) => {
+  MessageRole3["SYSTEM"] = "system";
+  MessageRole3["USER"] = "user";
+  MessageRole3["ASSISTANT"] = "assistant";
+  MessageRole3["TOOL"] = "tool";
+  return MessageRole3;
+})(MessageRole || {});
+
+// src/server/protocol/base.ts
+var ProtocolHandler = class {
+  /**
+   * Check if a request matches this protocol
+   */
+  matches(req) {
+    const prefix = this.getPrefix();
+    return this.getRoutes().some(
+      (route) => route.method === req.method && this.matchPath(prefix + route.path, req.url)
+    );
+  }
+  /**
+   * Handle a request
+   */
+  async handle(req, invoker) {
+    const prefix = this.getPrefix();
+    const route = this.getRoutes().find(
+      (r) => r.method === req.method && this.matchPath(prefix + r.path, req.url)
+    );
+    if (!route) {
+      return {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "Not Found" })
+      };
+    }
+    try {
+      return await route.handler(req, invoker);
+    } catch (error) {
+      return this.createErrorResponse(error, 500);
+    }
+  }
+  /**
+   * Create error response
+   */
+  createErrorResponse(error, status = 500) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      status,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        error: {
+          message,
+          type: "server_error"
+        }
+      })
+    };
+  }
+  /**
+   * Match path with simple pattern matching
+   * Supports exact match and prefix match with trailing slash
+   */
+  matchPath(pattern, path) {
+    const normalizedPattern = pattern.replace(/\/+$/, "");
+    const normalizedPath = path.replace(/\/+$/, "").split("?")[0];
+    return normalizedPattern === normalizedPath;
+  }
+};
+
+// src/server/protocol/openai.ts
+var OpenAIProtocolHandler = class extends ProtocolHandler {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  name = "openai";
+  getPrefix() {
+    return this.config?.prefix ?? "/openai/v1";
+  }
+  getRoutes() {
+    return [
+      {
+        method: "POST",
+        path: "/chat/completions",
+        handler: this.handleChatCompletions.bind(this)
+      },
+      {
+        method: "GET",
+        path: "/models",
+        handler: this.handleListModels.bind(this)
+      }
+    ];
+  }
+  /**
+   * Handle POST /chat/completions
+   */
+  async handleChatCompletions(req, invoker) {
+    try {
+      const { agentRequest, context } = this.parseRequest(req.body);
+      if (agentRequest.stream) {
+        return {
+          status: 200,
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          },
+          body: this.formatStream(invoker.invoke(agentRequest), context)
+        };
+      }
+      const events = [];
+      for await (const event of invoker.invoke(agentRequest)) {
+        events.push(event);
+      }
+      return {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(this.formatNonStream(events, context))
+      };
+    } catch (error) {
+      return this.createErrorResponse(error, 400);
+    }
+  }
+  /**
+   * Handle GET /models
+   */
+  async handleListModels() {
+    const modelName = this.config?.modelName ?? "agentrun";
+    return {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        object: "list",
+        data: [
+          {
+            id: modelName,
+            object: "model",
+            created: Math.floor(Date.now() / 1e3),
+            owned_by: "agentrun"
+          }
+        ]
+      })
+    };
+  }
+  /**
+   * Parse OpenAI format request to AgentRequest
+   */
+  parseRequest(body) {
+    if (!body.messages || !Array.isArray(body.messages)) {
+      throw new Error("Missing required field: messages");
+    }
+    const context = {
+      id: `chatcmpl-${this.generateId()}`,
+      model: body.model || this.config?.modelName || "agentrun",
+      created: Math.floor(Date.now() / 1e3)
+    };
+    const messages = this.parseMessages(body.messages);
+    const tools = this.parseTools(body.tools);
+    const agentRequest = {
+      protocol: "openai",
+      messages,
+      stream: body.stream ?? false,
+      model: context.model,
+      tools: tools || void 0,
+      metadata: body.metadata
+    };
+    return { agentRequest, context };
+  }
+  /**
+   * Parse OpenAI messages to internal Message format
+   */
+  parseMessages(messages) {
+    return messages.map((m) => {
+      const msg = m;
+      return {
+        id: msg.id,
+        role: msg.role,
+        content: msg.content,
+        name: msg.name,
+        toolCallId: msg.tool_call_id,
+        toolCalls: msg.tool_calls ? msg.tool_calls.map((tc) => {
+          const call = tc;
+          return {
+            id: call.id,
+            type: call.type,
+            function: call.function
+          };
+        }) : void 0
+      };
+    });
+  }
+  /**
+   * Parse OpenAI tools format
+   */
+  parseTools(tools) {
+    if (!tools || !Array.isArray(tools)) {
+      return null;
+    }
+    return tools.map((t) => {
+      const tool = t;
+      return {
+        type: tool.type || "function",
+        function: tool.function
+      };
+    });
+  }
+  /**
+   * Format streaming response (SSE)
+   */
+  async *formatStream(events, context) {
+    let sentRole = false;
+    let hasText = false;
+    let toolCallIndex = -1;
+    const toolCallStates = /* @__PURE__ */ new Map();
+    let hasToolCalls = false;
+    for await (const event of events) {
+      if (event.event === "RAW" /* RAW */) {
+        const raw = event.data?.raw;
+        if (raw) {
+          yield raw.endsWith("\n\n") ? raw : raw.replace(/\n+$/, "") + "\n\n";
+        }
+        continue;
+      }
+      if (event.event === "TEXT" /* TEXT */) {
+        const delta = {};
+        if (!sentRole) {
+          delta.role = "assistant";
+          sentRole = true;
+        }
+        const content = event.data?.delta;
+        if (content) {
+          delta.content = content;
+          hasText = true;
+        }
+        yield this.buildChunk(context, { delta });
+        continue;
+      }
+      if (event.event === "TOOL_CALL_CHUNK" /* TOOL_CALL_CHUNK */) {
+        const toolId = event.data?.id;
+        const toolName = event.data?.name;
+        const argsDelta = event.data?.args_delta || event.data?.argsDelta;
+        if (toolId && !toolCallStates.has(toolId)) {
+          toolCallIndex++;
+          toolCallStates.set(toolId, { index: toolCallIndex, started: true });
+          hasToolCalls = true;
+          yield this.buildChunk(context, {
+            delta: {
+              tool_calls: [
+                {
+                  index: toolCallIndex,
+                  id: toolId,
+                  type: "function",
+                  function: { name: toolName || "", arguments: "" }
+                }
+              ]
+            }
+          });
+        }
+        if (argsDelta) {
+          const state = toolCallStates.get(toolId);
+          const currentIndex = state?.index ?? toolCallIndex;
+          yield this.buildChunk(context, {
+            delta: {
+              tool_calls: [
+                {
+                  index: currentIndex,
+                  function: { arguments: argsDelta }
+                }
+              ]
+            }
+          });
+        }
+        continue;
+      }
+      if (event.event === "ERROR" /* ERROR */) {
+        yield this.buildChunk(context, {
+          delta: {},
+          finish_reason: "error"
+        });
+        continue;
+      }
+    }
+    const finishReason = hasToolCalls ? "tool_calls" : hasText ? "stop" : "stop";
+    yield this.buildChunk(context, { delta: {}, finish_reason: finishReason });
+    yield "data: [DONE]\n\n";
+  }
+  /**
+   * Build SSE chunk
+   */
+  buildChunk(context, choice) {
+    const chunk = {
+      id: context.id,
+      object: "chat.completion.chunk",
+      created: context.created,
+      model: context.model,
+      choices: [
+        {
+          index: 0,
+          delta: choice.delta || {},
+          finish_reason: choice.finish_reason ?? null
+        }
+      ]
+    };
+    return `data: ${JSON.stringify(chunk)}
+
+`;
+  }
+  /**
+   * Format non-streaming response
+   */
+  formatNonStream(events, context) {
+    let content = "";
+    const toolCalls = [];
+    for (const event of events) {
+      if (event.event === "TEXT" /* TEXT */) {
+        content += event.data?.delta || "";
+      } else if (event.event === "TOOL_CALL_CHUNK" /* TOOL_CALL_CHUNK */) {
+        const toolId = event.data?.id;
+        const toolName = event.data?.name;
+        const argsDelta = event.data?.args_delta || event.data?.argsDelta;
+        let toolCall = toolCalls.find((tc) => tc.id === toolId);
+        if (!toolCall && toolId) {
+          toolCall = {
+            id: toolId,
+            type: "function",
+            function: { name: toolName || "", arguments: "" }
+          };
+          toolCalls.push(toolCall);
+        }
+        if (toolCall && argsDelta) {
+          toolCall.function.arguments += argsDelta;
+        }
+      }
+    }
+    const message = {
+      role: "assistant",
+      content: content || null
+    };
+    if (toolCalls.length > 0) {
+      message.tool_calls = toolCalls.map((tc, idx) => ({
+        index: idx,
+        id: tc.id,
+        type: tc.type,
+        function: tc.function
+      }));
+    }
+    return {
+      id: context.id,
+      object: "chat.completion",
+      created: context.created,
+      model: context.model,
+      choices: [
+        {
+          index: 0,
+          message,
+          finish_reason: toolCalls.length > 0 ? "tool_calls" : "stop"
+        }
+      ],
+      usage: {
+        prompt_tokens: 0,
+        completion_tokens: 0,
+        total_tokens: 0
+      }
+    };
+  }
+  /**
+   * Generate unique ID
+   */
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  }
+};
+var AGUI_EVENT_TYPES = {
+  RUN_STARTED: "RUN_STARTED",
+  RUN_FINISHED: "RUN_FINISHED",
+  RUN_ERROR: "RUN_ERROR",
+  TEXT_MESSAGE_START: "TEXT_MESSAGE_START",
+  TEXT_MESSAGE_CONTENT: "TEXT_MESSAGE_CONTENT",
+  TEXT_MESSAGE_END: "TEXT_MESSAGE_END",
+  TOOL_CALL_START: "TOOL_CALL_START",
+  TOOL_CALL_ARGS: "TOOL_CALL_ARGS",
+  TOOL_CALL_END: "TOOL_CALL_END",
+  TOOL_CALL_RESULT: "TOOL_CALL_RESULT",
+  STATE_SNAPSHOT: "STATE_SNAPSHOT",
+  STATE_DELTA: "STATE_DELTA",
+  MESSAGES_SNAPSHOT: "MESSAGES_SNAPSHOT",
+  STEP_STARTED: "STEP_STARTED",
+  STEP_FINISHED: "STEP_FINISHED",
+  CUSTOM: "CUSTOM",
+  RAW: "RAW"
+};
+var StreamState = class {
+  text = {
+    started: false,
+    ended: false,
+    messageId: v4()
+  };
+  toolCalls = /* @__PURE__ */ new Map();
+  toolResultChunks = /* @__PURE__ */ new Map();
+  hasError = false;
+  /**
+   * End all open tool calls
+   */
+  *endAllToolCalls(exclude) {
+    for (const [toolId, state] of this.toolCalls) {
+      if (exclude && toolId === exclude) continue;
+      if (state.started && !state.ended) {
+        yield { type: AGUI_EVENT_TYPES.TOOL_CALL_END, toolCallId: toolId };
+        state.ended = true;
+      }
+    }
+  }
+  /**
+   * Ensure text message has started
+   */
+  *ensureTextStarted() {
+    if (!this.text.started || this.text.ended) {
+      if (this.text.ended) {
+        this.text = { started: false, ended: false, messageId: v4() };
+      }
+      yield {
+        type: AGUI_EVENT_TYPES.TEXT_MESSAGE_START,
+        messageId: this.text.messageId,
+        role: "assistant"
+      };
+      this.text.started = true;
+      this.text.ended = false;
+    }
+  }
+  /**
+   * End text message if open
+   */
+  *endTextIfOpen() {
+    if (this.text.started && !this.text.ended) {
+      yield {
+        type: AGUI_EVENT_TYPES.TEXT_MESSAGE_END,
+        messageId: this.text.messageId
+      };
+      this.text.ended = true;
+    }
+  }
+  /**
+   * Cache tool result chunk
+   */
+  cacheToolResultChunk(toolId, delta) {
+    if (!toolId || delta === null || delta === void 0) return;
+    if (delta) {
+      const chunks = this.toolResultChunks.get(toolId) || [];
+      chunks.push(delta);
+      this.toolResultChunks.set(toolId, chunks);
+    }
+  }
+  /**
+   * Pop and concatenate cached tool result chunks
+   */
+  popToolResultChunks(toolId) {
+    const chunks = this.toolResultChunks.get(toolId) || [];
+    this.toolResultChunks.delete(toolId);
+    return chunks.join("");
+  }
+};
+var DEFAULT_PREFIX = "/ag-ui";
+var AGUIProtocolHandler = class extends ProtocolHandler {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  name = "agui";
+  getPrefix() {
+    return this.config?.prefix ?? DEFAULT_PREFIX;
+  }
+  getRoutes() {
+    return [
+      {
+        method: "POST",
+        path: "/agent",
+        handler: this.handleAgent.bind(this)
+      }
+    ];
+  }
+  /**
+   * Handle POST /agent
+   */
+  async handleAgent(req, invoker) {
+    try {
+      const { agentRequest, context } = this.parseRequest(req.body);
+      return {
+        status: 200,
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        },
+        body: this.formatStream(invoker.invoke(agentRequest), context)
+      };
+    } catch (error) {
+      return {
+        status: 200,
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        },
+        body: this.errorStream(error instanceof Error ? error.message : String(error))
+      };
+    }
+  }
+  /**
+   * Parse AG-UI request
+   */
+  parseRequest(body) {
+    const context = {
+      threadId: body.threadId || v4(),
+      runId: body.runId || v4()
+    };
+    const messages = this.parseMessages(body.messages || []);
+    const tools = this.parseTools(body.tools);
+    const agentRequest = {
+      protocol: "agui",
+      messages,
+      stream: true,
+      // AG-UI always streams
+      tools: tools || void 0,
+      model: body.model,
+      metadata: body.metadata
+    };
+    return { agentRequest, context };
+  }
+  /**
+   * Parse messages list
+   */
+  parseMessages(rawMessages) {
+    const messages = [];
+    for (const msg of rawMessages) {
+      if (typeof msg !== "object" || msg === null) continue;
+      const roleStr = msg.role || "user";
+      let role;
+      if (Object.values(MessageRole).includes(roleStr)) {
+        role = roleStr;
+      } else {
+        role = "user" /* USER */;
+      }
+      let toolCalls;
+      const rawToolCalls = msg.toolCalls;
+      if (rawToolCalls && Array.isArray(rawToolCalls)) {
+        toolCalls = rawToolCalls.map((tc) => ({
+          id: tc.id || "",
+          type: tc.type || "function",
+          function: tc.function || {
+            name: "",
+            arguments: ""
+          }
+        }));
+      }
+      messages.push({
+        id: msg.id,
+        role,
+        content: msg.content,
+        name: msg.name,
+        toolCalls,
+        toolCallId: msg.toolCallId
+      });
+    }
+    return messages;
+  }
+  /**
+   * Parse tools list
+   */
+  parseTools(rawTools) {
+    if (!rawTools || !Array.isArray(rawTools)) return null;
+    const tools = [];
+    for (const tool of rawTools) {
+      if (typeof tool !== "object" || tool === null) continue;
+      tools.push({
+        type: tool.type || "function",
+        function: tool.function || { name: "" }
+      });
+    }
+    return tools.length > 0 ? tools : null;
+  }
+  /**
+   * Format event stream as AG-UI SSE format
+   */
+  async *formatStream(events, context) {
+    const state = new StreamState();
+    yield this.encode({ type: AGUI_EVENT_TYPES.RUN_STARTED, ...context });
+    for await (const event of events) {
+      if (state.hasError) continue;
+      if (event.event === "ERROR" /* ERROR */) {
+        state.hasError = true;
+      }
+      for (const aguiEvent of this.processEvent(event, context, state)) {
+        yield this.encode(aguiEvent);
+      }
+    }
+    if (state.hasError) return;
+    for (const event of state.endAllToolCalls()) {
+      yield this.encode(event);
+    }
+    for (const event of state.endTextIfOpen()) {
+      yield this.encode(event);
+    }
+    yield this.encode({ type: AGUI_EVENT_TYPES.RUN_FINISHED, ...context });
+  }
+  /**
+   * Process single event and yield AG-UI events
+   */
+  *processEvent(event, context, state) {
+    if (event.event === "RAW" /* RAW */) {
+      const raw = event.data?.raw;
+      if (raw) {
+        yield { __raw: raw };
+      }
+      return;
+    }
+    if (event.event === "TEXT" /* TEXT */) {
+      yield* state.endAllToolCalls();
+      yield* state.ensureTextStarted();
+      const aguiEvent = {
+        type: AGUI_EVENT_TYPES.TEXT_MESSAGE_CONTENT,
+        messageId: state.text.messageId,
+        delta: event.data?.delta || ""
+      };
+      if (event.addition) {
+        yield this.applyAddition(aguiEvent, event.addition, event.additionMergeOptions);
+      } else {
+        yield aguiEvent;
+      }
+      return;
+    }
+    if (event.event === "TOOL_CALL_CHUNK" /* TOOL_CALL_CHUNK */) {
+      const toolId = event.data?.id || "";
+      const toolName = event.data?.name || "";
+      yield* state.endTextIfOpen();
+      const currentState = state.toolCalls.get(toolId);
+      if (toolId && (!currentState || currentState.ended)) {
+        yield {
+          type: AGUI_EVENT_TYPES.TOOL_CALL_START,
+          toolCallId: toolId,
+          toolCallName: toolName
+        };
+        state.toolCalls.set(toolId, {
+          name: toolName,
+          started: true,
+          ended: false,
+          hasResult: false,
+          isHitl: false
+        });
+      }
+      yield {
+        type: AGUI_EVENT_TYPES.TOOL_CALL_ARGS,
+        toolCallId: toolId,
+        delta: event.data?.args_delta || event.data?.argsDelta || ""
+      };
+      return;
+    }
+    if (event.event === "TOOL_CALL" /* TOOL_CALL */) {
+      const toolId = event.data?.id || "";
+      const toolName = event.data?.name || "";
+      const toolArgs = event.data?.args || "";
+      yield* state.endTextIfOpen();
+      const currentState = state.toolCalls.get(toolId);
+      if (toolId && (!currentState || currentState.ended)) {
+        yield {
+          type: AGUI_EVENT_TYPES.TOOL_CALL_START,
+          toolCallId: toolId,
+          toolCallName: toolName
+        };
+        state.toolCalls.set(toolId, {
+          name: toolName,
+          started: true,
+          ended: false,
+          hasResult: false,
+          isHitl: false
+        });
+      }
+      if (toolArgs) {
+        yield {
+          type: AGUI_EVENT_TYPES.TOOL_CALL_ARGS,
+          toolCallId: toolId,
+          delta: toolArgs
+        };
+      }
+      return;
+    }
+    if (event.event === "TOOL_RESULT_CHUNK" /* TOOL_RESULT_CHUNK */) {
+      const toolId = event.data?.id || "";
+      const delta = event.data?.delta || "";
+      state.cacheToolResultChunk(toolId, delta);
+      return;
+    }
+    if (event.event === "HITL" /* HITL */) {
+      const hitlId = event.data?.id || "";
+      const toolCallId = event.data?.tool_call_id || event.data?.toolCallId || "";
+      const hitlType = event.data?.type || "confirmation";
+      const prompt = event.data?.prompt || "";
+      yield* state.endTextIfOpen();
+      if (toolCallId && state.toolCalls.has(toolCallId)) {
+        const toolState = state.toolCalls.get(toolCallId);
+        if (toolState.started && !toolState.ended) {
+          yield { type: AGUI_EVENT_TYPES.TOOL_CALL_END, toolCallId };
+          toolState.ended = true;
+        }
+        toolState.isHitl = true;
+        toolState.hasResult = false;
+        return;
+      }
+      const argsDict = { type: hitlType, prompt };
+      if (event.data?.options) argsDict.options = event.data.options;
+      if (event.data?.default !== void 0) argsDict.default = event.data.default;
+      if (event.data?.timeout !== void 0) argsDict.timeout = event.data.timeout;
+      if (event.data?.schema) argsDict.schema = event.data.schema;
+      const actualId = toolCallId || hitlId;
+      yield {
+        type: AGUI_EVENT_TYPES.TOOL_CALL_START,
+        toolCallId: actualId,
+        toolCallName: `hitl_${hitlType}`
+      };
+      yield {
+        type: AGUI_EVENT_TYPES.TOOL_CALL_ARGS,
+        toolCallId: actualId,
+        delta: JSON.stringify(argsDict)
+      };
+      yield { type: AGUI_EVENT_TYPES.TOOL_CALL_END, toolCallId: actualId };
+      state.toolCalls.set(actualId, {
+        name: `hitl_${hitlType}`,
+        started: true,
+        ended: true,
+        hasResult: false,
+        isHitl: true
+      });
+      return;
+    }
+    if (event.event === "TOOL_RESULT" /* TOOL_RESULT */) {
+      const toolId = event.data?.id || "";
+      const toolName = event.data?.name || "";
+      yield* state.endTextIfOpen();
+      let toolState = state.toolCalls.get(toolId);
+      if (toolId && !toolState) {
+        yield {
+          type: AGUI_EVENT_TYPES.TOOL_CALL_START,
+          toolCallId: toolId,
+          toolCallName: toolName
+        };
+        toolState = {
+          name: toolName,
+          started: true,
+          ended: false,
+          hasResult: false,
+          isHitl: false
+        };
+        state.toolCalls.set(toolId, toolState);
+      }
+      if (toolState && toolState.started && !toolState.ended) {
+        yield { type: AGUI_EVENT_TYPES.TOOL_CALL_END, toolCallId: toolId };
+        toolState.ended = true;
+      }
+      let finalResult = (event.data?.content || event.data?.result) ?? "";
+      if (toolId) {
+        const cachedChunks = state.popToolResultChunks(toolId);
+        if (cachedChunks) {
+          finalResult = cachedChunks + finalResult;
+        }
+      }
+      yield {
+        type: AGUI_EVENT_TYPES.TOOL_CALL_RESULT,
+        messageId: event.data?.message_id || event.data?.messageId || `tool-result-${toolId}`,
+        toolCallId: toolId,
+        content: finalResult,
+        role: "tool"
+      };
+      return;
+    }
+    if (event.event === "ERROR" /* ERROR */) {
+      yield {
+        type: AGUI_EVENT_TYPES.RUN_ERROR,
+        message: event.data?.message || "",
+        code: event.data?.code
+      };
+      return;
+    }
+    if (event.event === "STATE" /* STATE */) {
+      if ("snapshot" in (event.data || {})) {
+        yield {
+          type: AGUI_EVENT_TYPES.STATE_SNAPSHOT,
+          snapshot: event.data?.snapshot || {}
+        };
+      } else if ("delta" in (event.data || {})) {
+        yield {
+          type: AGUI_EVENT_TYPES.STATE_DELTA,
+          delta: event.data?.delta || []
+        };
+      } else {
+        yield {
+          type: AGUI_EVENT_TYPES.STATE_SNAPSHOT,
+          snapshot: event.data || {}
+        };
+      }
+      return;
+    }
+    if (event.event === "CUSTOM" /* CUSTOM */) {
+      yield {
+        type: AGUI_EVENT_TYPES.CUSTOM,
+        name: event.data?.name || "custom",
+        value: event.data?.value
+      };
+      return;
+    }
+    yield {
+      type: AGUI_EVENT_TYPES.CUSTOM,
+      name: event.event || "unknown",
+      value: event.data
+    };
+  }
+  /**
+   * Encode event to SSE format
+   */
+  encode(event) {
+    if ("__raw" in event) {
+      const raw = event.__raw;
+      return raw.endsWith("\n\n") ? raw : raw.replace(/\n+$/, "") + "\n\n";
+    }
+    return `data: ${JSON.stringify(event)}
+
+`;
+  }
+  /**
+   * Apply addition fields
+   */
+  applyAddition(eventData, addition, mergeOptions) {
+    if (!addition) return eventData;
+    const result = { ...eventData };
+    for (const [key, value] of Object.entries(addition)) {
+      if (mergeOptions?.noNewField && !(key in eventData)) continue;
+      result[key] = value;
+    }
+    return result;
+  }
+  /**
+   * Generate error stream
+   */
+  async *errorStream(message) {
+    const threadId = v4();
+    const runId = v4();
+    yield this.encode({ type: AGUI_EVENT_TYPES.RUN_STARTED, threadId, runId });
+    yield this.encode({
+      type: AGUI_EVENT_TYPES.RUN_ERROR,
+      message,
+      code: "REQUEST_ERROR"
+    });
+  }
+};
+
+export { AGUIProtocolHandler, AGUI_EVENT_TYPES, OpenAIProtocolHandler };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map