alibabacloud-agentcore-sdk 0.1.0

package/dist/server/index.cjs

@@ -0,0 +1,604 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5;
+
+
+var _chunkULJTQSLEcjs = require('../chunk-ULJTQSLE.cjs');
+
+
+
+var _chunkA3PF2SPDcjs = require('../chunk-A3PF2SPD.cjs');
+
+
+var _chunkLE5P3SJWcjs = require('../chunk-LE5P3SJW.cjs');
+
+
+
+var _chunkZELRQU4Jcjs = require('../chunk-ZELRQU4J.cjs');
+
+
+
+
+var _chunkJSP7ZROScjs = require('../chunk-JSP7ZROS.cjs');
+
+// src/server/app.ts
+var _hono = require('hono');
+var _nodeserver = require('@hono/node-server');
+
+// src/server/invoker.ts
+var AgentInvoker = class {
+  constructor(handler, logger = _chunkLE5P3SJWcjs.nullLogger) {
+    this.handler = handler;
+    this.logger = logger;
+  }
+  
+  
+  get configured() {
+    return this.handler !== void 0;
+  }
+  setHandler(handler) {
+    this.handler = handler;
+  }
+  async *invokeStream(request) {
+    if (!this.handler) throw new Error("AgentCore handler is not configured");
+    const context = new (0, _chunkULJTQSLEcjs.RequestContext)(Object.fromEntries(request.rawRequest.headers));
+    const fields = {
+      protocol: request.protocol,
+      requestId: context.headers["x-request-id"],
+      sessionId: context.headers["x-agentcore-session-id"]
+    };
+    this.logger.info("agentcore.server.invoke.started", fields);
+    try {
+      request.signal.throwIfAborted();
+      const collaboration = _chunkA3PF2SPDcjs.parseCollaborationContext.call(void 0, context.headers);
+      const run = (callback) => _chunkULJTQSLEcjs.useContext.call(void 0, context, () => _chunkA3PF2SPDcjs.useCollaborationContext.call(void 0, collaboration, callback));
+      const result = await run(() => this.handler(request, context));
+      const iterator = iterate(result)[Symbol.asyncIterator]();
+      try {
+        for (; ; ) {
+          request.signal.throwIfAborted();
+          const item = await run(() => iterator.next());
+          if (item.done) break;
+          request.signal.throwIfAborted();
+          const event = normalize(item.value);
+          if (event) yield event;
+        }
+      } finally {
+        await run(() => _optionalChain([iterator, 'access', _ => _.return, 'optionalCall', _2 => _2(void 0)]));
+      }
+    } catch (error) {
+      if (request.signal.aborted) this.logger.info("agentcore.server.invoke.cancelled", fields);
+      else this.logger.error("agentcore.server.invoke.failed", { ...fields, ...failureFields(error) });
+      throw error;
+    }
+    this.logger.info("agentcore.server.invoke.succeeded", fields);
+  }
+  async invoke(request) {
+    const events = [];
+    for await (const event of this.invokeStream(request)) events.push(event);
+    return events;
+  }
+};
+async function* iterate(result) {
+  if (result != null && typeof result === "object" && Symbol.asyncIterator in result) yield* result;
+  else if (result != null && typeof result === "object" && Symbol.iterator in result) yield* result;
+  else yield result;
+}
+function normalize(value) {
+  if (value == null || value === "") return;
+  if (typeof value === "string") return new (0, _chunkZELRQU4Jcjs.AgentEvent)(_chunkZELRQU4Jcjs.EventType.TEXT, { delta: value });
+  if (!(value instanceof _chunkZELRQU4Jcjs.AgentEvent)) throw new TypeError("handler must return text, AgentEvent, or an event iterable");
+  if (value.event !== _chunkZELRQU4Jcjs.EventType.TOOL_CALL) return value;
+  const args = _nullishCoalesce(value.data.args, () => ( ""));
+  return new (0, _chunkZELRQU4Jcjs.AgentEvent)(_chunkZELRQU4Jcjs.EventType.TOOL_CALL_CHUNK, {
+    id: _nullishCoalesce(value.data.id, () => ( "")),
+    name: _nullishCoalesce(value.data.name, () => ( "")),
+    args_delta: typeof args === "string" ? args : JSON.stringify(args)
+  });
+}
+function errorCode(error) {
+  return error instanceof _chunkJSP7ZROScjs.AgentCoreError ? error.code : "INTERNAL_ERROR";
+}
+function failureFields(error) {
+  return {
+    code: errorCode(error),
+    errorType: error instanceof Error ? error.name : typeof error,
+    errorMessage: error instanceof Error ? error.message : String(error),
+    stack: error instanceof Error ? error.stack : void 0
+  };
+}
+
+// src/server/openai.ts
+var _crypto = require('crypto');
+
+
+// src/server/sse.ts
+var _streaming = require('hono/streaming');
+var HEARTBEAT_INTERVAL_MS = 15e3;
+function sse(value) {
+  return `data: ${JSON.stringify(value)}
+
+`;
+}
+async function* withHeartbeat(source) {
+  const iterator = source[Symbol.asyncIterator]();
+  let pending = iterator.next();
+  try {
+    for (; ; ) {
+      let timer;
+      const heartbeat = /* @__PURE__ */ Symbol();
+      const tick = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(heartbeat), HEARTBEAT_INTERVAL_MS);
+      });
+      let item;
+      try {
+        item = await Promise.race([pending, tick]);
+      } finally {
+        clearTimeout(timer);
+      }
+      if (item === heartbeat) {
+        yield ": ping\n\n";
+        continue;
+      }
+      if (item.done) return;
+      yield item.value;
+      pending = iterator.next();
+    }
+  } finally {
+    await _optionalChain([iterator, 'access', _3 => _3.return, 'optionalCall', _4 => _4()]);
+  }
+}
+function eventStream(c, producer) {
+  c.header("X-Accel-Buffering", "no");
+  return _streaming.streamSSE.call(void 0, c, async (stream) => {
+    const cancelled = new AbortController();
+    stream.onAbort(() => cancelled.abort());
+    const signal = AbortSignal.any([c.req.raw.signal, cancelled.signal]);
+    try {
+      for await (const frame of withHeartbeat(producer(signal))) {
+        if (signal.aborted) break;
+        await stream.write(frame);
+      }
+    } catch (error) {
+      if (!signal.aborted) throw error;
+    }
+  });
+}
+
+// src/server/openai.ts
+var OpenAIProtocolHandler = (_class = class {
+  constructor(prefix = "/openai/v1", modelName = "agentcore") {;_class.prototype.__init.call(this);
+    this.prefix = prefix;
+    this.modelName = modelName;
+  }
+  
+  
+  __init() {this.name = "openai_chat_completions"}
+  routes(invoker) {
+    const app = new (0, _hono.Hono)();
+    app.get(`${this.prefix}/models`, (c) => c.json({ object: "list", data: [{
+      id: this.modelName,
+      object: "model",
+      created: Math.floor(Date.now() / 1e3),
+      owned_by: "agentcore"
+    }] }));
+    app.post(`${this.prefix}/chat/completions`, async (c) => {
+      if (!invoker.configured) return c.json({ error: { message: "handler is not configured", type: "server_error" } }, 503);
+      let request;
+      try {
+        request = parseOpenAI(c.req.raw, await c.req.json());
+      } catch (e) {
+        return c.json({ error: { message: "invalid request", type: "invalid_request_error" } }, 400);
+      }
+      const model = text(request.rawPayload.model) || this.modelName;
+      if (request.stream) return eventStream(c, (signal) => formatStream(invoker, { ...request, signal }, model));
+      try {
+        const state = new CompletionState();
+        for (const event of await invoker.invoke(request)) {
+          if (event.event === _chunkZELRQU4Jcjs.EventType.ERROR) throw new Error("agent reported an error");
+          state.consume(event);
+        }
+        return c.json({ ...completion(model), object: "chat.completion", choices: [{
+          index: 0,
+          message: {
+            role: "assistant",
+            content: state.content.join("") || null,
+            ...state.reasoning.length ? { reasoning_content: state.reasoning.join("") } : {},
+            ...state.calls.size ? { tool_calls: [...state.calls.values()].map(({ id, name, args }) => ({
+              id,
+              type: "function",
+              function: { name, arguments: args }
+            })) } : {}
+          },
+          finish_reason: state.finishReason
+        }] });
+      } catch (error) {
+        const invalid = error instanceof _chunkJSP7ZROScjs.ConfigError || error instanceof _chunkJSP7ZROScjs.ContextError;
+        return c.json(
+          { error: {
+            message: error instanceof _chunkJSP7ZROScjs.AgentCoreError ? error.message : "handler failed",
+            type: invalid ? "invalid_request_error" : "server_error",
+            code: errorCode(error)
+          } },
+          invalid ? 400 : error instanceof _chunkJSP7ZROScjs.AgentCoreError ? 502 : 500
+        );
+      }
+    });
+    return app;
+  }
+}, _class);
+function parseOpenAI(rawRequest, value) {
+  const payload = object(value);
+  if (!Array.isArray(payload.messages)) throw new Error("messages must be an array");
+  const messages = payload.messages.map((value2) => {
+    const item = object(value2);
+    if (!["developer", "system", "user", "assistant", "tool"].includes(String(item.role))) throw new Error("invalid role");
+    let toolCalls;
+    if (item.tool_calls != null) {
+      if (!Array.isArray(item.tool_calls)) throw new Error("invalid tool_calls");
+      toolCalls = item.tool_calls.map((value3) => {
+        const call = object(value3);
+        if (!text(call.id)) throw new Error("tool id is required");
+        return { id: call.id, type: text(call.type) || "function", function: object(call.function) };
+      });
+    }
+    return {
+      role: item.role,
+      content: item.content,
+      id: text(item.id),
+      name: text(item.name),
+      toolCalls,
+      toolCallId: text(item.tool_call_id)
+    };
+  });
+  let tools;
+  if (payload.tools != null) {
+    if (!Array.isArray(payload.tools)) throw new Error("tools must be an array");
+    tools = payload.tools.map((value2) => {
+      const item = object(value2), fn = object(item.function);
+      if ((_nullishCoalesce(item.type, () => ( "function"))) !== "function" || !text(fn.name)) throw new Error("invalid function tool");
+      if (fn.description !== void 0 && typeof fn.description !== "string") throw new Error("invalid description");
+      return { name: fn.name, description: _nullishCoalesce(fn.description, () => ( "")), parameters: object(_nullishCoalesce(fn.parameters, () => ( {}))) };
+    });
+  }
+  return {
+    protocol: "openai",
+    messages,
+    tools,
+    stream: payload.stream === true,
+    rawRequest,
+    rawPayload: payload,
+    signal: rawRequest.signal
+  };
+}
+function object(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("object required");
+  return value;
+}
+function text(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function completion(model) {
+  return { id: `chatcmpl-${_crypto.randomUUID.call(void 0, )}`, created: Math.floor(Date.now() / 1e3), model };
+}
+var CompletionState = (_class2 = class {constructor() { _class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this); }
+  __init2() {this.content = []}
+  __init3() {this.reasoning = []}
+  __init4() {this.calls = /* @__PURE__ */ new Map()}
+  get finishReason() {
+    return this.calls.size ? "tool_calls" : "stop";
+  }
+  consume(event) {
+    const data = event.data;
+    if (event.event === _chunkZELRQU4Jcjs.EventType.TEXT || event.event === _chunkZELRQU4Jcjs.EventType.REASONING) {
+      if (typeof data.delta !== "string" || !data.delta) return [];
+      (event.event === _chunkZELRQU4Jcjs.EventType.TEXT ? this.content : this.reasoning).push(data.delta);
+      return [{ [event.event === _chunkZELRQU4Jcjs.EventType.TEXT ? "content" : "reasoning_content"]: data.delta }];
+    }
+    if (event.event !== _chunkZELRQU4Jcjs.EventType.TOOL_CALL_CHUNK || typeof data.id !== "string" || !data.id) return [];
+    const deltas = [];
+    let call = this.calls.get(data.id);
+    if (!call) {
+      call = { id: data.id, index: this.calls.size, name: text(data.name) || "", args: "" };
+      this.calls.set(call.id, call);
+      deltas.push({ tool_calls: [{ index: call.index, id: call.id, type: "function", function: { name: call.name, arguments: "" } }] });
+    }
+    if (text(data.name)) call.name = text(data.name);
+    if (typeof data.args_delta === "string" && data.args_delta) {
+      call.args += data.args_delta;
+      deltas.push({ tool_calls: [{ index: call.index, function: { arguments: data.args_delta } }] });
+    }
+    return deltas;
+  }
+}, _class2);
+async function* formatStream(invoker, request, model) {
+  const base = { ...completion(model), object: "chat.completion.chunk" }, state = new CompletionState();
+  const chunk = (delta, finishReason = null) => sse({
+    ...base,
+    choices: [{ index: 0, delta, finish_reason: finishReason }]
+  });
+  yield chunk({ role: "assistant" });
+  let failed = false;
+  try {
+    for await (const event of invoker.invokeStream(request)) {
+      if (event.event === _chunkZELRQU4Jcjs.EventType.ERROR) {
+        yield sse({ error: { message: "handler failed", type: "server_error" } });
+        failed = true;
+        break;
+      }
+      for (const delta of state.consume(event)) yield chunk(delta);
+    }
+  } catch (error) {
+    if (request.signal.aborted) return;
+    invoker.logger.error("agentcore.server.openai.stream.failed", { ...failureFields(error), requestId: _nullishCoalesce(request.rawRequest.headers.get("x-request-id"), () => ( void 0)) });
+    yield sse({ error: { message: "handler failed", type: "server_error", code: errorCode(error) } });
+    failed = true;
+  }
+  if (!failed) yield chunk({}, state.finishReason);
+  yield "data: [DONE]\n\n";
+}
+
+// src/server/agui.ts
+
+
+var _core = require('@ag-ui/core');
+var AGUIProtocolHandler = (_class3 = class {
+  constructor(prefix = "/ag-ui/agent") {;_class3.prototype.__init5.call(this);
+    this.prefix = prefix;
+  }
+  
+  __init5() {this.name = "ag-ui"}
+  routes(invoker) {
+    const app = new (0, _hono.Hono)();
+    app.post(this.prefix, async (c) => {
+      if (!invoker.configured) return c.json({ error: { code: "HANDLER_NOT_CONFIGURED" } }, 503);
+      let request, threadId, runId;
+      try {
+        const payload = await c.req.json();
+        const parsed = _core.RunAgentInputSchema.parse(payload);
+        threadId = parsed.threadId;
+        runId = parsed.runId;
+        const messages = parsed.messages.map((message) => ({
+          role: message.role,
+          id: message.id,
+          name: "name" in message ? message.name : void 0,
+          content: "content" in message ? message.content : void 0,
+          toolCalls: "toolCalls" in message ? message.toolCalls : void 0,
+          toolCallId: "toolCallId" in message ? message.toolCallId : void 0
+        }));
+        const tools = parsed.tools.map((tool) => {
+          if (!tool.parameters || typeof tool.parameters !== "object" || Array.isArray(tool.parameters)) throw new Error("tool parameters must be an object");
+          return { name: tool.name, description: tool.description, parameters: tool.parameters };
+        });
+        request = {
+          protocol: "agui",
+          messages,
+          tools,
+          stream: true,
+          rawRequest: c.req.raw,
+          rawPayload: payload,
+          signal: c.req.raw.signal
+        };
+      } catch (e2) {
+        return eventStream(c, async function* () {
+          yield sse({ type: "RUN_ERROR", message: "invalid request", code: "INVALID_REQUEST" });
+        });
+      }
+      return eventStream(c, (signal) => formatStream2(invoker, { ...request, signal }, threadId, runId));
+    });
+    return app;
+  }
+}, _class3);
+var StreamState = (_class4 = class {constructor() { _class4.prototype.__init6.call(this);_class4.prototype.__init7.call(this);_class4.prototype.__init8.call(this);_class4.prototype.__init9.call(this); }
+  
+  
+  __init6() {this.tools = /* @__PURE__ */ new Set()}
+  __init7() {this.toolIds = /* @__PURE__ */ new Set()}
+  __init8() {this.textIds = /* @__PURE__ */ new Set()}
+  __init9() {this.reasoningIds = /* @__PURE__ */ new Set()}
+  finishIdentified(reasoning, messageId) {
+    const active = reasoning ? this.reasoningIds : this.textIds;
+    return (messageId === void 0 ? [...active] : [messageId]).flatMap((id) => {
+      if (!active.delete(id)) return [];
+      return reasoning ? [{ type: "REASONING_MESSAGE_END", messageId: id }, { type: "REASONING_END", messageId: id }] : [{ type: "TEXT_MESSAGE_END", messageId: id }];
+    });
+  }
+  finishText() {
+    if (!this.textId) return [];
+    const messageId = this.textId;
+    this.textId = void 0;
+    return [{ type: "TEXT_MESSAGE_END", messageId }];
+  }
+  finishReasoning() {
+    if (!this.reasoningId) return [];
+    const messageId = this.reasoningId;
+    this.reasoningId = void 0;
+    return [{ type: "REASONING_MESSAGE_END", messageId }, { type: "REASONING_END", messageId }];
+  }
+  finishTool(toolCallId) {
+    return this.tools.delete(toolCallId) ? [{ type: "TOOL_CALL_END", toolCallId }] : [];
+  }
+  finishTools() {
+    return [...this.tools].flatMap((id) => this.finishTool(id));
+  }
+  consume(event) {
+    const data = event.data;
+    const identity = typeof data.message_id === "string" ? data.message_id : void 0;
+    if (event.event === _chunkZELRQU4Jcjs.EventType.TEXT_END) return [...identity === void 0 ? this.finishText() : [], ...this.finishIdentified(false, identity)];
+    if (event.event === _chunkZELRQU4Jcjs.EventType.REASONING_END) return [...identity === void 0 ? this.finishReasoning() : [], ...this.finishIdentified(true, identity)];
+    if (event.event === _chunkZELRQU4Jcjs.EventType.TEXT || event.event === _chunkZELRQU4Jcjs.EventType.REASONING) {
+      const reasoning = event.event === _chunkZELRQU4Jcjs.EventType.REASONING;
+      const events = [...reasoning ? this.finishText() : this.finishReasoning(), ...this.finishTools()];
+      if (identity) events.push(...reasoning ? this.finishReasoning() : this.finishText());
+      const active = reasoning ? this.reasoningIds : this.textIds;
+      let messageId = _nullishCoalesce(identity, () => ( (reasoning ? this.reasoningId : this.textId)));
+      if (identity ? !active.has(identity) : !messageId) {
+        messageId ??= _crypto.randomUUID.call(void 0, );
+        if (identity) active.add(identity);
+        else if (reasoning) this.reasoningId = messageId;
+        else this.textId = messageId;
+        if (reasoning) {
+          events.push({ type: "REASONING_START", messageId });
+        }
+        events.push({
+          type: reasoning ? "REASONING_MESSAGE_START" : "TEXT_MESSAGE_START",
+          messageId,
+          role: reasoning ? "reasoning" : "assistant"
+        });
+      }
+      if (typeof data.delta === "string" && data.delta) events.push({
+        type: reasoning ? "REASONING_MESSAGE_CONTENT" : "TEXT_MESSAGE_CONTENT",
+        messageId,
+        delta: data.delta
+      });
+      return events;
+    }
+    if (event.event === _chunkZELRQU4Jcjs.EventType.TOOL_CALL_CHUNK || event.event === _chunkZELRQU4Jcjs.EventType.TOOL_RESULT) {
+      if (typeof data.id !== "string" || !data.id) return [];
+      const toolCallId = data.id, events = [...this.finishText(), ...this.finishReasoning()];
+      if (!this.toolIds.has(toolCallId)) {
+        this.tools.add(toolCallId);
+        this.toolIds.add(toolCallId);
+        events.push({ type: "TOOL_CALL_START", toolCallId, toolCallName: _nullishCoalesce(data.name, () => ( "")) });
+      }
+      if (event.event === _chunkZELRQU4Jcjs.EventType.TOOL_CALL_CHUNK) {
+        if (typeof data.args_delta === "string" && data.args_delta) events.push({ type: "TOOL_CALL_ARGS", toolCallId, delta: data.args_delta });
+      } else {
+        events.push(...this.finishTool(toolCallId));
+        events.push({
+          type: "TOOL_CALL_RESULT",
+          toolCallId,
+          messageId: `tool-result-${toolCallId}`,
+          role: "tool",
+          content: typeof data.result === "string" ? data.result : JSON.stringify(_nullishCoalesce(data.result, () => ( "")))
+        });
+      }
+      return events;
+    }
+    return [event.toJSON()];
+  }
+}, _class4);
+async function* formatStream2(invoker, request, threadId, runId) {
+  const state = new StreamState();
+  yield sse({ type: "RUN_STARTED", threadId, runId });
+  try {
+    for await (const event of invoker.invokeStream(request)) {
+      if (event.event === _chunkZELRQU4Jcjs.EventType.ERROR) {
+        yield sse({ type: "RUN_ERROR", message: event.data.message || "agent failed", code: event.data.code });
+        return;
+      }
+      for (const encoded of state.consume(event)) yield sse(encoded);
+    }
+  } catch (error) {
+    if (request.signal.aborted) return;
+    invoker.logger.error("agentcore.server.agui.stream.failed", {
+      ...failureFields(error),
+      threadId,
+      runId,
+      requestId: _nullishCoalesce(request.rawRequest.headers.get("x-request-id"), () => ( void 0))
+    });
+    yield sse({ type: "RUN_ERROR", message: "handler failed", code: errorCode(error) });
+    return;
+  }
+  for (const encoded of [
+    ...state.finishReasoning(),
+    ...state.finishTools(),
+    ...state.finishText(),
+    ...state.finishIdentified(false),
+    ...state.finishIdentified(true)
+  ]) yield sse(encoded);
+  yield sse({ type: "RUN_FINISHED", threadId, runId });
+}
+
+// src/server/app.ts
+var AgentCoreServer = (_class5 = class {
+  constructor(options = {}) {;_class5.prototype.__init10.call(this);
+    this.options = options;
+    this.logger = _nullishCoalesce(options.logger, () => ( _chunkLE5P3SJWcjs.nullLogger));
+    this.invoker = new AgentInvoker(options.invoke, this.logger);
+    this.app.get("/healthz", (c) => c.json({ status: "ok" }));
+    this.app.get("/readyz", async (c) => {
+      let ready = false;
+      try {
+        ready = options.readiness ? await options.readiness() : this.invoker.configured;
+      } catch (error) {
+        this.logger.warn("agentcore.server.readiness.failed", failureFields(error));
+      }
+      return c.json({ ready }, ready ? 200 : 503);
+    });
+    for (const protocol of _nullishCoalesce(options.protocols, () => ( [new OpenAIProtocolHandler(), new AGUIProtocolHandler()]))) {
+      this.app.route("/", protocol.routes(this.invoker));
+    }
+  }
+  
+  __init10() {this.app = new (0, _hono.Hono)()}
+  
+  
+  
+  
+  
+  invoke(handler) {
+    this.invoker.setHandler(handler);
+  }
+  start(options = {}) {
+    if (this.stopping) return Promise.reject(new Error("AgentCore server is closed"));
+    if (this.starting) return this.starting;
+    this.starting = this.listen(options).catch((error) => {
+      this.starting = void 0;
+      throw error;
+    });
+    return this.starting;
+  }
+  async listen(options) {
+    this.logger.info("agentcore.server.lifecycle.startup.started");
+    let initialized = false;
+    try {
+      await _optionalChain([this, 'access', _5 => _5.options, 'access', _6 => _6.startup, 'optionalCall', _7 => _7()]);
+      initialized = true;
+      const address = await new Promise((resolve, reject) => {
+        const server = _nodeserver.serve.call(void 0, { fetch: this.app.fetch, port: _nullishCoalesce(options.port, () => ( 9e3)), hostname: _nullishCoalesce(options.hostname, () => ( "0.0.0.0")) }, resolve);
+        this.server = server;
+        server.once("error", reject);
+      });
+      this.logger.info("agentcore.server.lifecycle.startup.succeeded", { port: address.port });
+      return `http://${address.family === "IPv6" ? `[${address.address}]` : address.address}:${address.port}`;
+    } catch (error) {
+      this.logger.error("agentcore.server.lifecycle.startup.failed", failureFields(error));
+      this.server = void 0;
+      if (initialized) {
+        try {
+          await _optionalChain([this, 'access', _8 => _8.options, 'access', _9 => _9.shutdown, 'optionalCall', _10 => _10()]);
+        } catch (cleanupError) {
+          this.logger.error("agentcore.server.lifecycle.shutdown.failed", failureFields(cleanupError));
+        }
+      }
+      throw error;
+    }
+  }
+  /** Stop accepting traffic, drain requests, then release application resources. */
+  close() {
+    if (this.stopping) return this.stopping;
+    this.stopping = this.stop();
+    return this.stopping;
+  }
+  async stop() {
+    await _optionalChain([this, 'access', _11 => _11.starting, 'optionalAccess', _12 => _12.catch, 'call', _13 => _13(() => void 0)]);
+    if (!_optionalChain([this, 'access', _14 => _14.server, 'optionalAccess', _15 => _15.listening])) return;
+    this.logger.info("agentcore.server.lifecycle.shutdown.started");
+    await new Promise((resolve, reject) => this.server.close((error) => error ? reject(error) : resolve()));
+    try {
+      await _optionalChain([this, 'access', _16 => _16.options, 'access', _17 => _17.shutdown, 'optionalCall', _18 => _18()]);
+    } catch (error) {
+      this.logger.error("agentcore.server.lifecycle.shutdown.failed", failureFields(error));
+      throw error;
+    }
+    this.logger.info("agentcore.server.lifecycle.shutdown.succeeded");
+  }
+}, _class5);
+
+
+
+
+
+
+
+exports.AGUIProtocolHandler = AGUIProtocolHandler; exports.AgentCoreServer = AgentCoreServer; exports.AgentEvent = _chunkZELRQU4Jcjs.AgentEvent; exports.AgentInvoker = AgentInvoker; exports.EventType = _chunkZELRQU4Jcjs.EventType; exports.OpenAIProtocolHandler = OpenAIProtocolHandler;
+//# sourceMappingURL=index.cjs.map