alibabacloud-agentcore-sdk 0.1.0

package/dist/server/index.js

@@ -0,0 +1,604 @@
+import {
+  RequestContext,
+  useContext
+} from "../chunk-ZWQBAJ5O.js";
+import {
+  parseCollaborationContext,
+  useCollaborationContext
+} from "../chunk-RYXL25AI.js";
+import {
+  nullLogger
+} from "../chunk-NZL3VPJ2.js";
+import {
+  AgentEvent,
+  EventType
+} from "../chunk-PTJPB27L.js";
+import {
+  AgentCoreError,
+  ConfigError,
+  ContextError
+} from "../chunk-MZ5UWGXS.js";
+
+// src/server/app.ts
+import { Hono as Hono3 } from "hono";
+import { serve } from "@hono/node-server";
+
+// src/server/invoker.ts
+var AgentInvoker = class {
+  constructor(handler, logger = nullLogger) {
+    this.handler = handler;
+    this.logger = logger;
+  }
+  handler;
+  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 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 = parseCollaborationContext(context.headers);
+      const run = (callback) => useContext(context, () => useCollaborationContext(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(() => iterator.return?.(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 AgentEvent(EventType.TEXT, { delta: value });
+  if (!(value instanceof AgentEvent)) throw new TypeError("handler must return text, AgentEvent, or an event iterable");
+  if (value.event !== EventType.TOOL_CALL) return value;
+  const args = value.data.args ?? "";
+  return new AgentEvent(EventType.TOOL_CALL_CHUNK, {
+    id: value.data.id ?? "",
+    name: value.data.name ?? "",
+    args_delta: typeof args === "string" ? args : JSON.stringify(args)
+  });
+}
+function errorCode(error) {
+  return error instanceof 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
+import { randomUUID } from "crypto";
+import { Hono } from "hono";
+
+// src/server/sse.ts
+import { streamSSE } from "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 iterator.return?.();
+  }
+}
+function eventStream(c, producer) {
+  c.header("X-Accel-Buffering", "no");
+  return streamSSE(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 {
+  constructor(prefix = "/openai/v1", modelName = "agentcore") {
+    this.prefix = prefix;
+    this.modelName = modelName;
+  }
+  prefix;
+  modelName;
+  name = "openai_chat_completions";
+  routes(invoker) {
+    const app = new 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 {
+        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 === 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 ConfigError || error instanceof ContextError;
+        return c.json(
+          { error: {
+            message: error instanceof AgentCoreError ? error.message : "handler failed",
+            type: invalid ? "invalid_request_error" : "server_error",
+            code: errorCode(error)
+          } },
+          invalid ? 400 : error instanceof AgentCoreError ? 502 : 500
+        );
+      }
+    });
+    return app;
+  }
+};
+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 ((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: fn.description ?? "", parameters: object(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-${randomUUID()}`, created: Math.floor(Date.now() / 1e3), model };
+}
+var CompletionState = class {
+  content = [];
+  reasoning = [];
+  calls = /* @__PURE__ */ new Map();
+  get finishReason() {
+    return this.calls.size ? "tool_calls" : "stop";
+  }
+  consume(event) {
+    const data = event.data;
+    if (event.event === EventType.TEXT || event.event === EventType.REASONING) {
+      if (typeof data.delta !== "string" || !data.delta) return [];
+      (event.event === EventType.TEXT ? this.content : this.reasoning).push(data.delta);
+      return [{ [event.event === EventType.TEXT ? "content" : "reasoning_content"]: data.delta }];
+    }
+    if (event.event !== 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;
+  }
+};
+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 === 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: 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
+import { randomUUID as randomUUID2 } from "crypto";
+import { Hono as Hono2 } from "hono";
+import { RunAgentInputSchema } from "@ag-ui/core";
+var AGUIProtocolHandler = class {
+  constructor(prefix = "/ag-ui/agent") {
+    this.prefix = prefix;
+  }
+  prefix;
+  name = "ag-ui";
+  routes(invoker) {
+    const app = new Hono2();
+    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 = 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 {
+        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;
+  }
+};
+var StreamState = class {
+  textId;
+  reasoningId;
+  tools = /* @__PURE__ */ new Set();
+  toolIds = /* @__PURE__ */ new Set();
+  textIds = /* @__PURE__ */ new Set();
+  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 === EventType.TEXT_END) return [...identity === void 0 ? this.finishText() : [], ...this.finishIdentified(false, identity)];
+    if (event.event === EventType.REASONING_END) return [...identity === void 0 ? this.finishReasoning() : [], ...this.finishIdentified(true, identity)];
+    if (event.event === EventType.TEXT || event.event === EventType.REASONING) {
+      const reasoning = event.event === 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 = identity ?? (reasoning ? this.reasoningId : this.textId);
+      if (identity ? !active.has(identity) : !messageId) {
+        messageId ??= randomUUID2();
+        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 === EventType.TOOL_CALL_CHUNK || event.event === 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: data.name ?? "" });
+      }
+      if (event.event === 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(data.result ?? "")
+        });
+      }
+      return events;
+    }
+    return [event.toJSON()];
+  }
+};
+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 === 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: 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 = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.logger = options.logger ?? 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 options.protocols ?? [new OpenAIProtocolHandler(), new AGUIProtocolHandler()]) {
+      this.app.route("/", protocol.routes(this.invoker));
+    }
+  }
+  options;
+  app = new Hono3();
+  invoker;
+  logger;
+  server;
+  starting;
+  stopping;
+  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 this.options.startup?.();
+      initialized = true;
+      const address = await new Promise((resolve, reject) => {
+        const server = serve({ fetch: this.app.fetch, port: options.port ?? 9e3, hostname: 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 this.options.shutdown?.();
+        } 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 this.starting?.catch(() => void 0);
+    if (!this.server?.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 this.options.shutdown?.();
+    } catch (error) {
+      this.logger.error("agentcore.server.lifecycle.shutdown.failed", failureFields(error));
+      throw error;
+    }
+    this.logger.info("agentcore.server.lifecycle.shutdown.succeeded");
+  }
+};
+export {
+  AGUIProtocolHandler,
+  AgentCoreServer,
+  AgentEvent,
+  AgentInvoker,
+  EventType,
+  OpenAIProtocolHandler
+};
+//# sourceMappingURL=index.js.map