@cuylabs/agent-foundry-agentserver-responses 4.9.0

package/dist/index.js

@@ -0,0 +1,1163 @@
+import {
+  AGENTSERVER_RESPONSES_PACKAGE_VERSION,
+  FoundryStorageError,
+  FoundryStorageNotFoundError,
+  FoundryStorageProvider,
+  FoundryStorageSettings,
+  InMemoryResponseProvider
+} from "./chunk-DGMWFFNQ.js";
+import {
+  RESPONSE_ID_HEADER,
+  SESSION_ID_HEADER,
+  TextResponse,
+  applyCreateResponseDefaults,
+  createResponseObject,
+  createSseEncoderState,
+  deriveSessionId,
+  encodeKeepAliveComment,
+  encodeSseEvent,
+  extractPartitionKey,
+  extractTextFromItems,
+  getInputExpanded,
+  isValidId,
+  newId,
+  newMessageItemId,
+  newOutputMessageItemId,
+  newResponseId,
+  normalizeCreateResponse,
+  normalizeResponseInput,
+  resolveAgentReference,
+  resolveConversationId,
+  resolveResponseId,
+  resolveSessionId,
+  startResponsesSseResponse,
+  toOutputItem,
+  validateResponseId
+} from "./chunk-24VMS6GY.js";
+
+// src/host.ts
+import express from "express";
+import {
+  AGENTSERVER_CORE_PACKAGE_VERSION,
+  agentServerLoggingMiddleware,
+  agentServerRequestHeadersMiddleware,
+  buildPlatformServerHeader,
+  closeServerWithTimeout,
+  configureAgentServerObservability,
+  configureExpressAgentServerApp,
+  defaultAgentServerLogger,
+  errorMiddleware,
+  formatError as formatError2,
+  logAgentServerStartupConfiguration,
+  notFoundMiddleware,
+  resolveAgentServerConfig
+} from "@cuylabs/agent-foundry-agentserver-core";
+
+// src/hosting/handler-provider.ts
+function makeHandlerProvider(input) {
+  if (typeof input === "function") {
+    if (input.length === 0) {
+      return () => {
+        const handler = input();
+        return handler;
+      };
+    }
+    return () => ({ handle: input });
+  }
+  return () => input;
+}
+
+// src/hosting/http-utils.ts
+import {
+  createErrorBody
+} from "@cuylabs/agent-foundry-agentserver-core";
+function supportsStreamProvider(provider) {
+  return typeof provider.appendStreamEvent === "function" && typeof provider.getStreamEvents === "function" && typeof provider.deleteStreamEvents === "function";
+}
+function queryParameters(req) {
+  const params = {};
+  for (const [key, value] of Object.entries(req.query)) {
+    if (typeof value === "string") {
+      params[key] = value;
+    }
+  }
+  return params;
+}
+function parseLimit(value) {
+  const raw = typeof value === "string" ? Number.parseInt(value, 10) : 20;
+  if (!Number.isInteger(raw) || raw < 1) {
+    return 20;
+  }
+  return Math.min(raw, 100);
+}
+function queryString(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function modeFlagsFromResponse(response) {
+  return {
+    stream: response.stream === true,
+    background: response.background === true,
+    store: response.store !== false
+  };
+}
+function scopedActiveKey(responseId, isolation) {
+  return `${isolation.chatKey ?? ""}|${isolation.userKey ?? ""}|${responseId}`;
+}
+function errorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function jsonParseErrorMiddleware(error, req, res, next) {
+  if (error instanceof SyntaxError) {
+    res.status(400).json(
+      createErrorBody("invalid_request", "request body must be valid JSON", {
+        type: "invalid_request_error",
+        requestId: req.agentServerRequestId
+      })
+    );
+    return;
+  }
+  next(error);
+}
+
+// src/hosting/routes.ts
+import {
+  healthzHandler,
+  methodNotAllowed,
+  readinessHandler
+} from "@cuylabs/agent-foundry-agentserver-core";
+
+// src/openapi.ts
+function buildResponsesOpenApiSpec(options = {}) {
+  const title = options.appName ?? "Foundry Responses Host";
+  return {
+    openapi: "3.0.3",
+    info: {
+      title,
+      version: "1.0.0"
+    },
+    paths: {
+      "/responses": {
+        post: {
+          summary: "Create a response",
+          responses: {
+            "200": { description: "Response created" }
+          }
+        }
+      },
+      "/responses/{response_id}": {
+        get: {
+          summary: "Get a response",
+          responses: {
+            "200": { description: "Response snapshot or SSE replay" },
+            "404": { description: "Response not found" }
+          }
+        },
+        delete: {
+          summary: "Delete a response",
+          responses: {
+            "200": { description: "Response deleted" },
+            "404": { description: "Response not found" }
+          }
+        }
+      },
+      "/responses/{response_id}/cancel": {
+        post: {
+          summary: "Cancel a background response",
+          responses: {
+            "200": { description: "Response cancelled" },
+            "404": { description: "Response not found" }
+          }
+        }
+      },
+      "/responses/{response_id}/input_items": {
+        get: {
+          summary: "List response input items",
+          responses: {
+            "200": { description: "Input items" },
+            "404": { description: "Response not found" }
+          }
+        }
+      },
+      "/readiness": {
+        get: {
+          summary: "Readiness probe",
+          responses: { "200": { description: "Healthy" } }
+        }
+      },
+      "/healthz": {
+        get: {
+          summary: "Liveness probe",
+          responses: { "200": { description: "Healthy" } }
+        }
+      }
+    }
+  };
+}
+
+// src/hosting/routes/cancel-response.ts
+import {
+  createErrorBody as createErrorBody3,
+  resolveAgentIsolation
+} from "@cuylabs/agent-foundry-agentserver-core";
+
+// src/hosting/routes/route-utils.ts
+import { createErrorBody as createErrorBody2 } from "@cuylabs/agent-foundry-agentserver-core";
+function routeResponseId(req) {
+  const responseId = req.params.responseId;
+  return Array.isArray(responseId) ? responseId[0] ?? "" : responseId ?? "";
+}
+function validateRouteResponseId(responseId, res) {
+  const validation = isValidId(responseId, ["caresp"]);
+  if (validation.valid) {
+    return true;
+  }
+  res.status(400).json(
+    createErrorBody2(
+      "invalid_parameters",
+      validation.error ?? "invalid response_id"
+    )
+  );
+  return false;
+}
+
+// src/hosting/routes/cancel-response.ts
+function cancelResponseHandler(options) {
+  return async (req, res) => {
+    const responseId = routeResponseId(req);
+    if (!validateRouteResponseId(responseId, res)) {
+      return;
+    }
+    const isolation = resolveAgentIsolation((name) => req.header(name));
+    const activeExecution = options.active.get(
+      scopedActiveKey(responseId, isolation)
+    );
+    if (!activeExecution) {
+      res.status(404).json(createErrorBody3("not_found", "Response not found"));
+      return;
+    }
+    if (!activeExecution.modeFlags.background) {
+      res.status(400).json(
+        createErrorBody3(
+          "invalid_request",
+          "Cannot cancel a synchronous response."
+        )
+      );
+      return;
+    }
+    activeExecution.controller.abort();
+    const response = await activeExecution.done.catch(
+      () => activeExecution.response
+    );
+    res.status(200).json(response);
+  };
+}
+
+// src/hosting/routes/create-response.ts
+import {
+  addProtectedHeaders,
+  collectClientHeaders,
+  createErrorBody as createErrorBody4,
+  formatError,
+  resolveAgentIsolation as resolveAgentIsolation2
+} from "@cuylabs/agent-foundry-agentserver-core";
+
+// src/context.ts
+var ResponseContext = class {
+  responseId;
+  request;
+  createdAt;
+  modeFlags;
+  sessionId;
+  previousResponseId;
+  conversationId;
+  clientHeaders;
+  queryParameters;
+  isolation;
+  isShutdownRequested = false;
+  provider;
+  historyLimit;
+  inputItems;
+  resolvedInputCache;
+  historyCache;
+  constructor(options) {
+    this.responseId = options.responseId;
+    this.request = options.request;
+    this.createdAt = options.createdAt ?? Math.floor(Date.now() / 1e3);
+    this.modeFlags = options.modeFlags;
+    this.sessionId = options.sessionId ?? options.responseId;
+    this.provider = options.provider;
+    this.inputItems = options.inputItems ?? getInputExpanded(options.request, options.responseId);
+    if (options.previousResponseId !== void 0) {
+      this.previousResponseId = options.previousResponseId;
+    }
+    if (options.conversationId !== void 0) {
+      this.conversationId = options.conversationId;
+    }
+    this.historyLimit = options.historyLimit ?? 100;
+    this.clientHeaders = options.clientHeaders ?? {};
+    this.queryParameters = options.queryParameters ?? {};
+    this.isolation = options.isolation ?? {};
+  }
+  async getInputItems(options = {}) {
+    const resolveReferences = options.resolveReferences !== false;
+    if (!resolveReferences) {
+      return this.inputItems;
+    }
+    if (this.resolvedInputCache) {
+      return this.resolvedInputCache;
+    }
+    const resolved = [];
+    const references = [];
+    for (const item of this.inputItems) {
+      if (item.type === "item_reference" && typeof item.id === "string") {
+        references.push({ index: resolved.length, id: item.id });
+        resolved.push(item);
+      } else {
+        resolved.push(item);
+      }
+    }
+    if (references.length > 0 && this.provider) {
+      const items = await this.provider.getItems(
+        references.map((reference) => reference.id),
+        { isolation: this.isolation }
+      );
+      for (let i = 0; i < references.length; i += 1) {
+        const reference = references[i];
+        const item = items[i];
+        if (reference && item) {
+          resolved[reference.index] = item;
+        }
+      }
+    }
+    this.resolvedInputCache = resolved.filter(
+      (item) => item.type !== "item_reference"
+    );
+    return this.resolvedInputCache;
+  }
+  async getInputText(options = {}) {
+    const items = await this.getInputItems(options);
+    return extractTextFromItems(items);
+  }
+  async getHistory() {
+    if (this.historyCache) {
+      return this.historyCache;
+    }
+    if (!this.provider) {
+      this.historyCache = [];
+      return this.historyCache;
+    }
+    if (this.provider.getHistoryItems) {
+      this.historyCache = await this.provider.getHistoryItems(
+        this.previousResponseId,
+        this.conversationId,
+        this.historyLimit,
+        { isolation: this.isolation }
+      );
+      return this.historyCache;
+    }
+    const historyItemIds = await this.provider.getHistoryItemIds(
+      this.previousResponseId,
+      this.conversationId,
+      this.historyLimit,
+      { isolation: this.isolation }
+    );
+    const items = await this.provider.getItems(historyItemIds, {
+      isolation: this.isolation
+    });
+    this.historyCache = items.filter(
+      (item) => item !== void 0
+    );
+    return this.historyCache;
+  }
+  async getInputItemsForPersistence() {
+    const items = await this.getInputItems({ resolveReferences: true });
+    return items.map((item) => toOutputItem(item, this.responseId));
+  }
+};
+
+// src/hosting/execution.ts
+import {
+  ATTR_RESPONSES_ERROR_CODE,
+  ATTR_RESPONSES_ERROR_MESSAGE
+} from "@cuylabs/agent-foundry-agentserver-core";
+function createExecution(options) {
+  const controller = new AbortController();
+  const response = createResponseObject({
+    id: options.responseId,
+    request: options.request,
+    status: options.modeFlags.background ? "queued" : "in_progress",
+    output: [],
+    createdAt: options.context.createdAt
+  });
+  const execution = {
+    responseId: options.responseId,
+    request: options.request,
+    response,
+    inputItems: options.inputItems,
+    modeFlags: options.modeFlags,
+    isolation: options.isolation,
+    controller,
+    done: Promise.resolve(response)
+  };
+  options.active.set(
+    scopedActiveKey(options.responseId, options.isolation),
+    execution
+  );
+  execution.done = options.requestSpan.run(async () => {
+    let sequenceNumber = 0;
+    if (options.modeFlags.store) {
+      await options.provider.createResponse(response, options.inputItems, {
+        historyItemIds: options.historyItemIds,
+        isolation: options.isolation
+      });
+    }
+    try {
+      const result = await options.handler.handle(
+        options.request,
+        options.context,
+        controller.signal
+      );
+      for await (const event of normalizeHandlerResult(result)) {
+        const normalized = withSequenceNumber(
+          normalizeEvent(event),
+          sequenceNumber
+        );
+        sequenceNumber = normalized.sequence_number + 1;
+        applyEventToExecution(execution, normalized);
+        if (options.modeFlags.store) {
+          await options.streamProvider.appendStreamEvent(
+            options.responseId,
+            normalized,
+            { isolation: options.isolation }
+          );
+        }
+        await options.onEvent?.(normalized);
+      }
+      await completeExecutionIfNeeded(execution, options, sequenceNumber);
+      if (options.modeFlags.store) {
+        await options.provider.updateResponse(execution.response, {
+          isolation: options.isolation
+        });
+      }
+      return execution.response;
+    } catch (error) {
+      await failExecution(execution, options, error, sequenceNumber);
+      return execution.response;
+    } finally {
+      options.active.delete(
+        scopedActiveKey(options.responseId, options.isolation)
+      );
+    }
+  });
+  return execution;
+}
+async function completeExecutionIfNeeded(execution, options, sequenceNumber) {
+  if (isTerminalStatus(execution.response.status)) {
+    return;
+  }
+  execution.response = {
+    ...execution.response,
+    status: execution.controller.signal.aborted ? "cancelled" : "completed"
+  };
+  const terminalEvent = {
+    type: execution.controller.signal.aborted ? "response.cancelled" : "response.completed",
+    sequence_number: sequenceNumber,
+    response: execution.response
+  };
+  if (options.modeFlags.store) {
+    await options.streamProvider.appendStreamEvent(
+      options.responseId,
+      terminalEvent,
+      { isolation: options.isolation }
+    );
+  }
+  await options.onEvent?.(terminalEvent);
+}
+async function failExecution(execution, options, error, sequenceNumber) {
+  const aborted = execution.controller.signal.aborted;
+  execution.response = {
+    ...execution.response,
+    status: aborted ? "cancelled" : "failed",
+    error: aborted ? null : {
+      code: "server_error",
+      message: "internal server error",
+      type: "server_error"
+    }
+  };
+  options.requestSpan.recordError(
+    error,
+    aborted ? "cancelled" : "server_error"
+  );
+  options.requestSpan.span.setAttribute(
+    ATTR_RESPONSES_ERROR_CODE,
+    aborted ? "cancelled" : "server_error"
+  );
+  options.requestSpan.span.setAttribute(
+    ATTR_RESPONSES_ERROR_MESSAGE,
+    errorMessage(error)
+  );
+  const terminalEvent = {
+    type: aborted ? "response.cancelled" : "response.failed",
+    sequence_number: sequenceNumber,
+    response: execution.response
+  };
+  if (options.modeFlags.store) {
+    await options.streamProvider.appendStreamEvent(
+      options.responseId,
+      terminalEvent,
+      { isolation: options.isolation }
+    );
+  }
+  await options.onEvent?.(terminalEvent);
+  if (options.modeFlags.store) {
+    await options.provider.updateResponse(execution.response, {
+      isolation: options.isolation
+    });
+  }
+}
+function applyEventToExecution(execution, event) {
+  if (event.response) {
+    execution.response = event.response;
+    return;
+  }
+  if ((event.type === "response.output_item.done" || event.type === "response.output_item.added") && event.item) {
+    const outputIndex = typeof event.output_index === "number" ? event.output_index : execution.response.output.length;
+    const output = [...execution.response.output];
+    output[outputIndex] = event.item;
+    execution.response = { ...execution.response, output };
+  }
+}
+async function* normalizeHandlerResult(result) {
+  if (isAsyncIterable(result)) {
+    for await (const event of result) {
+      yield normalizeEvent(event);
+    }
+    return;
+  }
+  if (isIterable(result)) {
+    for (const event of result) {
+      yield normalizeEvent(event);
+    }
+    return;
+  }
+  throw new Error("response handler must return an iterable of events");
+}
+function normalizeEvent(event) {
+  if (typeof event.type !== "string" || !event.type) {
+    throw new Error("response stream event must include a string type");
+  }
+  return event;
+}
+function withSequenceNumber(event, fallback) {
+  const sequenceNumber = typeof event.sequence_number === "number" && event.sequence_number >= 0 ? event.sequence_number : fallback;
+  return { ...event, sequence_number: sequenceNumber };
+}
+function isTerminalStatus(status) {
+  return ["completed", "failed", "cancelled", "incomplete"].includes(status);
+}
+function isAsyncIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+function isIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.iterator in value;
+}
+
+// src/hosting/tracing.ts
+import {
+  startAgentServerRequestSpan
+} from "@cuylabs/agent-foundry-agentserver-core";
+function startResponseRequestSpan(options) {
+  const span = startAgentServerRequestSpan({
+    config: options.config,
+    headers: (name) => options.req.header(name),
+    requestId: options.responseId,
+    operation: "invoke_agent",
+    operationName: "invoke_agent",
+    instrumentationScope: "Azure.AI.AgentServer.Responses",
+    responseId: options.responseId,
+    sessionId: options.sessionId,
+    conversationId: options.conversationId,
+    streaming: options.streaming,
+    correlationRequestId: options.req.agentServerRequestId
+  });
+  let finished = false;
+  options.res.once("finish", () => {
+    finished = true;
+    span.end();
+  });
+  options.res.once("close", () => {
+    if (finished) {
+      span.end();
+      return;
+    }
+    span.end(new Error("HTTP response closed before finish"));
+  });
+  return span;
+}
+
+// src/hosting/validation.ts
+var ResponseValidationError = class extends Error {
+  constructor(message, code, param) {
+    super(message);
+    this.code = code;
+    this.param = param;
+    this.name = "ResponseValidationError";
+  }
+};
+function validateCreateResponseSemantics(request) {
+  const storeEnabled = request.store !== false;
+  if (request.background === true && !storeEnabled) {
+    throw new ResponseValidationError(
+      "background=true requires store=true",
+      "unsupported_parameter",
+      "background"
+    );
+  }
+  if (request.stream_options !== void 0 && request.stream !== true) {
+    throw new ResponseValidationError(
+      "stream_options requires stream=true",
+      "invalid_mode",
+      "stream"
+    );
+  }
+  const metadata = request.metadata;
+  if (isRecord(metadata)) {
+    if (Object.keys(metadata).length > 16) {
+      throw new ResponseValidationError(
+        "metadata must have at most 16 key-value pairs",
+        "invalid_request",
+        "metadata"
+      );
+    }
+    for (const [key, value] of Object.entries(metadata)) {
+      if (key.length > 64) {
+        throw new ResponseValidationError(
+          "metadata keys must be at most 64 characters",
+          "invalid_request",
+          "metadata"
+        );
+      }
+      if (typeof value === "string" && value.length > 512) {
+        throw new ResponseValidationError(
+          "metadata values must be at most 512 characters",
+          "invalid_request",
+          "metadata"
+        );
+      }
+    }
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/hosting/routes/create-response.ts
+function createResponseHandler(options) {
+  return async (req, res) => {
+    let request;
+    let responseId = "resp_validation";
+    try {
+      request = applyCreateResponseDefaults(normalizeCreateResponse(req.body), {
+        defaultModel: options.defaultModel
+      });
+      validateCreateResponseSemantics(request);
+      const agentReference = resolveAgentReference(request.agent_reference);
+      responseId = resolveResponseId(request, {
+        get: (name) => req.header(name)
+      });
+      const conversationId = resolveConversationId(request);
+      const previousResponseId = typeof request.previous_response_id === "string" ? request.previous_response_id : void 0;
+      if (previousResponseId) {
+        validateResponseId(previousResponseId);
+      }
+      const sessionId = resolveSessionId({
+        request,
+        envSessionId: options.config.sessionId,
+        ...agentReference ? { agentReference } : {}
+      });
+      addProtectedHeaders(res, { [SESSION_ID_HEADER]: sessionId });
+      const isolation = resolveAgentIsolation2((name) => req.header(name));
+      const modeFlags = {
+        stream: request.stream === true,
+        background: request.background === true,
+        store: request.store !== false
+      };
+      const inputItems = getInputExpanded(request, responseId);
+      const historyItemIds = modeFlags.store ? await options.provider.getHistoryItemIds(
+        previousResponseId,
+        conversationId,
+        options.defaultHistoryLimit,
+        { isolation }
+      ) : [];
+      const context = new ResponseContext({
+        responseId,
+        request,
+        modeFlags,
+        sessionId,
+        provider: options.provider,
+        inputItems,
+        ...previousResponseId ? { previousResponseId } : {},
+        ...conversationId ? { conversationId } : {},
+        historyLimit: options.defaultHistoryLimit,
+        clientHeaders: collectClientHeaders(req.headers),
+        queryParameters: queryParameters(req),
+        isolation
+      });
+      const requestSpan = startResponseRequestSpan({
+        req,
+        res,
+        config: options.config,
+        responseId,
+        sessionId,
+        conversationId,
+        streaming: modeFlags.stream
+      });
+      const handler = options.handlerProvider();
+      const sseState = createSseEncoderState();
+      if (modeFlags.stream) {
+        startResponsesSseResponse(res);
+      }
+      const execution = createExecution({
+        request,
+        responseId,
+        inputItems,
+        historyItemIds,
+        modeFlags,
+        context,
+        handler,
+        provider: options.provider,
+        streamProvider: options.streamProvider,
+        active: options.active,
+        isolation,
+        requestSpan,
+        onEvent: modeFlags.stream ? (event) => {
+          res.write(encodeSseEvent(event, sseState));
+        } : void 0
+      });
+      if (modeFlags.background && !modeFlags.stream) {
+        void execution.done.catch((error) => {
+          options.logger.error("Background response execution failed", {
+            responseId,
+            error: formatError(error)
+          });
+        });
+        res.status(200).json(execution.response);
+        return;
+      }
+      if (modeFlags.stream) {
+        try {
+          await execution.done;
+        } finally {
+          res.end();
+        }
+        return;
+      }
+      const response = await execution.done;
+      res.status(200).json(response);
+    } catch (error) {
+      options.logger.error("Failed to create response", {
+        responseId,
+        error: formatError(error)
+      });
+      const validationError = error instanceof ResponseValidationError ? error : void 0;
+      res.status(400).json(
+        createErrorBody4(
+          validationError?.code ?? "invalid_request",
+          errorMessage(error),
+          {
+            type: "invalid_request_error",
+            requestId: req.agentServerRequestId,
+            additionalInfo: validationError?.param ? { param: validationError.param } : void 0
+          }
+        )
+      );
+    }
+  };
+}
+
+// src/hosting/routes/delete-response.ts
+import {
+  createErrorBody as createErrorBody5,
+  resolveAgentIsolation as resolveAgentIsolation3
+} from "@cuylabs/agent-foundry-agentserver-core";
+function deleteResponseHandler(options) {
+  return async (req, res) => {
+    const responseId = routeResponseId(req);
+    if (!validateRouteResponseId(responseId, res)) {
+      return;
+    }
+    const isolation = resolveAgentIsolation3((name) => req.header(name));
+    const activeExecution = options.active.get(
+      scopedActiveKey(responseId, isolation)
+    );
+    if (activeExecution?.modeFlags.store === false) {
+      res.status(404).json(createErrorBody5("not_found", "Response not found"));
+      return;
+    }
+    if (activeExecution?.modeFlags.background && ["queued", "in_progress"].includes(activeExecution.response.status)) {
+      res.status(400).json(
+        createErrorBody5(
+          "invalid_request",
+          "Cannot delete an in-flight response."
+        )
+      );
+      return;
+    }
+    activeExecution?.controller.abort();
+    const deleted = await options.provider.deleteResponse(responseId, {
+      isolation
+    });
+    await options.streamProvider.deleteStreamEvents(responseId, { isolation });
+    if (!deleted && !activeExecution) {
+      res.status(404).json(createErrorBody5("not_found", "Response not found"));
+      return;
+    }
+    options.active.delete(scopedActiveKey(responseId, isolation));
+    res.status(200).json({ id: responseId, object: "response", deleted: true });
+  };
+}
+
+// src/hosting/routes/get-response.ts
+import {
+  createErrorBody as createErrorBody6,
+  resolveAgentIsolation as resolveAgentIsolation4
+} from "@cuylabs/agent-foundry-agentserver-core";
+function getResponseHandler(options) {
+  return async (req, res) => {
+    const responseId = routeResponseId(req);
+    if (!validateRouteResponseId(responseId, res)) {
+      return;
+    }
+    const isolation = resolveAgentIsolation4((name) => req.header(name));
+    const activeExecution = options.active.get(
+      scopedActiveKey(responseId, isolation)
+    );
+    const streamReplay = String(req.query.stream ?? "false").toLowerCase() === "true";
+    if (streamReplay) {
+      const startingAfter = parseStartingAfter(req, res);
+      if (startingAfter === false) {
+        return;
+      }
+      await handleStreamReplay({
+        activeExecution,
+        isolation,
+        routeOptions: options,
+        responseId,
+        res,
+        startingAfter
+      });
+      return;
+    }
+    const response = activeExecution?.response ?? await options.provider.getResponse(responseId, { isolation });
+    if (!response || activeExecution?.modeFlags.store === false) {
+      res.status(404).json(createErrorBody6("not_found", "Response not found"));
+      return;
+    }
+    res.status(200).json(response);
+  };
+}
+async function handleStreamReplay(options) {
+  const response = options.activeExecution?.response ?? await options.routeOptions.provider.getResponse(options.responseId, {
+    isolation: options.isolation
+  });
+  if (!response) {
+    options.res.status(404).json(createErrorBody6("not_found", "Response not found"));
+    return;
+  }
+  const flags = options.activeExecution?.modeFlags ?? modeFlagsFromResponse(response);
+  if (!flags.store) {
+    options.res.status(404).json(createErrorBody6("not_found", "Response not found"));
+    return;
+  }
+  if (!flags.background) {
+    options.res.status(400).json(
+      createErrorBody6(
+        "invalid_mode",
+        "This response cannot be streamed because it was not created with background=true."
+      )
+    );
+    return;
+  }
+  if (!flags.stream) {
+    options.res.status(400).json(
+      createErrorBody6(
+        "invalid_mode",
+        "This response cannot be streamed because it was not created with stream=true."
+      )
+    );
+    return;
+  }
+  const storedEvents = await options.routeOptions.streamProvider.getStreamEvents(
+    options.responseId,
+    { isolation: options.isolation }
+  ) ?? [];
+  const events = storedEvents.map((event, index) => ({
+    ...event,
+    sequence_number: typeof event.sequence_number === "number" ? event.sequence_number : index
+  })).filter(
+    (event) => options.startingAfter === void 0 || event.sequence_number > options.startingAfter
+  );
+  startResponsesSseResponse(options.res);
+  const sseState = createSseEncoderState();
+  for (const event of events) {
+    options.res.write(encodeSseEvent(event, sseState));
+  }
+  options.res.end();
+}
+function parseStartingAfter(req, res) {
+  const value = req.query.starting_after;
+  if (value === void 0) {
+    return void 0;
+  }
+  if (Array.isArray(value) || typeof value !== "string" || !value.trim()) {
+    res.status(400).json(
+      createErrorBody6("invalid_request", "starting_after must be an integer", {
+        type: "invalid_request_error",
+        additionalInfo: { param: "starting_after" }
+      })
+    );
+    return false;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || String(parsed) !== value.trim()) {
+    res.status(400).json(
+      createErrorBody6("invalid_request", "starting_after must be an integer", {
+        type: "invalid_request_error",
+        additionalInfo: { param: "starting_after" }
+      })
+    );
+    return false;
+  }
+  return parsed;
+}
+
+// src/hosting/routes/list-input-items.ts
+import {
+  createErrorBody as createErrorBody7,
+  resolveAgentIsolation as resolveAgentIsolation5
+} from "@cuylabs/agent-foundry-agentserver-core";
+function listInputItemsHandler(options) {
+  return async (req, res) => {
+    const responseId = routeResponseId(req);
+    if (!validateRouteResponseId(responseId, res)) {
+      return;
+    }
+    const isolation = resolveAgentIsolation5((name) => req.header(name));
+    const limit = parseLimit(req.query.limit);
+    const items = await options.provider.getInputItems(responseId, {
+      after: queryString(req.query.after),
+      ascending: String(req.query.order ?? "desc").toLowerCase() === "asc",
+      before: queryString(req.query.before),
+      isolation,
+      limit: Math.min(limit + 1, 100)
+    });
+    if (!items) {
+      res.status(404).json(createErrorBody7("not_found", "Response not found"));
+      return;
+    }
+    const page = items.slice(0, limit);
+    res.status(200).json({
+      object: "list",
+      data: page,
+      first_id: page[0]?.id ?? null,
+      last_id: page[page.length - 1]?.id ?? null,
+      has_more: items.length > limit
+    });
+  };
+}
+
+// src/hosting/routes.ts
+function registerResponsesRoutes(app, options) {
+  app.get("/", (_req, res) => {
+    res.json({
+      app: options.appName,
+      host: "foundry-responses",
+      protocol: "responses",
+      protocolVersion: "1.0.0",
+      endpoint: "/responses",
+      readiness: "/readiness",
+      liveness: "/healthz",
+      openapi: "/responses/docs/openapi.json"
+    });
+  });
+  app.get("/healthz", healthzHandler);
+  app.get("/readiness", readinessHandler);
+  app.get("/readyz", readinessHandler);
+  app.get("/responses/docs/openapi.json", (_req, res) => {
+    const handler = options.handlerProvider();
+    res.json(
+      handler.getOpenApi?.() ?? buildResponsesOpenApiSpec({ appName: options.appName })
+    );
+  });
+  app.post("/responses", createResponseHandler(options));
+  app.get("/responses/:responseId", getResponseHandler(options));
+  app.delete("/responses/:responseId", deleteResponseHandler(options));
+  app.post("/responses/:responseId/cancel", cancelResponseHandler(options));
+  app.get("/responses/:responseId/input_items", listInputItemsHandler(options));
+  app.all("/responses", methodNotAllowed(["POST"]));
+  app.all("/responses/docs/openapi.json", methodNotAllowed(["GET"]));
+  app.all("/responses/:responseId/cancel", methodNotAllowed(["POST"]));
+  app.all("/responses/:responseId/input_items", methodNotAllowed(["GET"]));
+  app.all("/responses/:responseId", methodNotAllowed(["GET", "DELETE"]));
+  app.all("/readiness", methodNotAllowed(["GET"]));
+  app.all("/readyz", methodNotAllowed(["GET"]));
+  app.all("/healthz", methodNotAllowed(["GET"]));
+}
+
+// src/host.ts
+var DEFAULT_HOST = "0.0.0.0";
+var DEFAULT_BODY_LIMIT = "1mb";
+var DEFAULT_HISTORY_LIMIT = 100;
+function createResponsesApp(options) {
+  const logger = options.logger ?? defaultAgentServerLogger("responses");
+  const config = resolveAgentServerConfig({
+    port: options.port,
+    gracefulShutdownTimeoutSeconds: options.gracefulShutdownTimeoutSeconds
+  });
+  const appName = options.appName ?? "foundry-responses-host";
+  const trustProxy = options.trustProxy ?? 1;
+  const bodyLimit = options.bodyLimit ?? DEFAULT_BODY_LIMIT;
+  const defaultHistoryLimit = resolveDefaultHistoryLimit(
+    options.defaultFetchHistoryCount
+  );
+  const requestLogging = options.requestLogging !== false;
+  const provider = options.store ?? new InMemoryResponseProvider();
+  const streamProvider = supportsStreamProvider(provider) ? provider : new InMemoryResponseProvider();
+  const active = /* @__PURE__ */ new Map();
+  const platformServer = responsesPlatformServerHeader();
+  const observabilityReady = options.configureObservability === false ? Promise.resolve(void 0) : configureAgentServerObservability({ config, logger });
+  const app = express();
+  configureExpressAgentServerApp(app, { trustProxy });
+  app.use(agentServerRequestHeadersMiddleware({ platformServer }));
+  app.use(express.json({ type: "*/*", limit: bodyLimit }));
+  app.use(jsonParseErrorMiddleware);
+  app.use(async (_req, _res, next) => {
+    try {
+      await observabilityReady;
+      next();
+    } catch (error) {
+      logger.warn("Foundry Agent Server observability initialization failed", {
+        error: formatError2(error)
+      });
+      next();
+    }
+  });
+  if (requestLogging) {
+    app.use(agentServerLoggingMiddleware(logger));
+  }
+  registerResponsesRoutes(app, {
+    active,
+    appName,
+    config,
+    defaultHistoryLimit,
+    defaultModel: options.defaultModel,
+    handlerProvider: makeHandlerProvider(options.handler),
+    logger,
+    provider,
+    streamProvider
+  });
+  app.use(notFoundMiddleware());
+  app.use(errorMiddleware(logger));
+  return app;
+}
+async function runResponsesServer(options) {
+  const app = createResponsesApp(options);
+  const config = resolveAgentServerConfig({
+    port: options.port,
+    gracefulShutdownTimeoutSeconds: options.gracefulShutdownTimeoutSeconds
+  });
+  const port = config.port;
+  const host = options.host ?? DEFAULT_HOST;
+  const logger = options.logger ?? defaultAgentServerLogger("responses");
+  const appName = options.appName ?? "foundry-responses-host";
+  const platformServer = responsesPlatformServerHeader();
+  const server = await new Promise((resolve, reject) => {
+    const httpServer = app.listen(port, host, () => {
+      logAgentServerStartupConfiguration(logger, config, platformServer);
+      logger.info(`${appName} listening on http://${host}:${port}/responses`);
+      resolve(httpServer);
+    }).on("error", reject);
+  });
+  return {
+    app,
+    server,
+    port,
+    host,
+    async close() {
+      await closeServerWithTimeout(
+        server,
+        config.gracefulShutdownTimeoutSeconds
+      );
+      const handler = options.handler;
+      if (typeof handler === "object" && "close" in handler) {
+        await handler.close?.();
+      }
+    }
+  };
+}
+function resolveDefaultHistoryLimit(value) {
+  if (value === void 0) {
+    return DEFAULT_HISTORY_LIMIT;
+  }
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error("defaultFetchHistoryCount must be a positive integer");
+  }
+  return value;
+}
+function responsesPlatformServerHeader() {
+  return buildPlatformServerHeader([
+    {
+      name: "azure-ai-agentserver-core",
+      version: AGENTSERVER_CORE_PACKAGE_VERSION
+    },
+    {
+      name: "azure-ai-agentserver-responses",
+      version: AGENTSERVER_RESPONSES_PACKAGE_VERSION
+    }
+  ]);
+}
+
+// src/types.ts
+var ResponsesHandler = class {
+};
+export {
+  AGENTSERVER_RESPONSES_PACKAGE_VERSION,
+  FoundryStorageError,
+  FoundryStorageNotFoundError,
+  FoundryStorageProvider,
+  FoundryStorageSettings,
+  InMemoryResponseProvider,
+  RESPONSE_ID_HEADER,
+  ResponseContext,
+  ResponsesHandler,
+  SESSION_ID_HEADER,
+  TextResponse,
+  buildResponsesOpenApiSpec,
+  createResponseObject,
+  createResponsesApp,
+  createSseEncoderState,
+  deriveSessionId,
+  encodeKeepAliveComment,
+  encodeSseEvent,
+  extractPartitionKey,
+  extractTextFromItems,
+  getInputExpanded,
+  isValidId,
+  newId,
+  newMessageItemId,
+  newOutputMessageItemId,
+  newResponseId,
+  normalizeCreateResponse,
+  normalizeResponseInput,
+  resolveAgentReference,
+  resolveConversationId,
+  resolveResponseId,
+  resolveSessionId,
+  runResponsesServer,
+  startResponsesSseResponse,
+  toOutputItem,
+  validateResponseId
+};