@cuylabs/agent-foundry-agentserver-responses 4.9.0

package/dist/chunk-24VMS6GY.js

@@ -0,0 +1,513 @@
+// src/streaming/sse.ts
+function startResponsesSseResponse(res) {
+  res.status(200);
+  res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+  res.setHeader("X-Accel-Buffering", "no");
+  res.flushHeaders?.();
+}
+function createSseEncoderState() {
+  return { sequenceNumber: 0 };
+}
+function encodeSseEvent(event, state = createSseEncoderState()) {
+  if (!event.type) {
+    throw new Error("SSE event must include a non-empty type");
+  }
+  const eventType = event.type.replaceAll("\n", "").replaceAll("\r", "");
+  const sequenceNumber = typeof event.sequence_number === "number" && event.sequence_number >= 0 ? event.sequence_number : state.sequenceNumber;
+  state.sequenceNumber = Math.max(state.sequenceNumber, sequenceNumber + 1);
+  const payload = {
+    ...event,
+    type: eventType,
+    sequence_number: sequenceNumber
+  };
+  return `event: ${eventType}
+data: ${JSON.stringify(payload)}
+
+`;
+}
+function encodeKeepAliveComment(comment = "keep-alive") {
+  return `: ${comment}
+
+`;
+}
+
+// src/ids.ts
+import { randomBytes } from "crypto";
+var PARTITION_KEY_HEX_LENGTH = 16;
+var PARTITION_KEY_SUFFIX = "00";
+var PARTITION_KEY_TOTAL_LENGTH = PARTITION_KEY_HEX_LENGTH + PARTITION_KEY_SUFFIX.length;
+var ENTROPY_LENGTH = 32;
+var NEW_FORMAT_BODY_LENGTH = PARTITION_KEY_TOTAL_LENGTH + ENTROPY_LENGTH;
+var LEGACY_BODY_LENGTH = 48;
+var LEGACY_PARTITION_KEY_LENGTH = 16;
+function newId(prefix, partitionKeyHint = "") {
+  if (!prefix) {
+    throw new Error("prefix must not be empty");
+  }
+  const extracted = tryExtractPartitionKey(partitionKeyHint);
+  const partitionKey = extracted ? normalizePartitionKey(extracted) : generatePartitionKey();
+  return `${prefix}_${partitionKey}${generateEntropy()}`;
+}
+function newResponseId(partitionKeyHint = "") {
+  return newId("caresp", partitionKeyHint);
+}
+function newMessageItemId(partitionKeyHint = "") {
+  return newId("msg", partitionKeyHint);
+}
+function newOutputMessageItemId(partitionKeyHint = "") {
+  return newId("omsg", partitionKeyHint);
+}
+function extractPartitionKey(idValue) {
+  const partitionKey = tryExtractPartitionKey(idValue);
+  if (partitionKey) {
+    return partitionKey;
+  }
+  if (!idValue) {
+    throw new Error("ID must not be null or empty.");
+  }
+  if (!idValue.includes("_")) {
+    throw new Error(`ID '${idValue}' has no '_' delimiter.`);
+  }
+  throw new Error(`ID '${idValue}' has unexpected body length.`);
+}
+function isValidId(idValue, allowedPrefixes) {
+  if (!idValue) {
+    return { valid: false, error: "ID must not be null or empty." };
+  }
+  const delimiterIndex = idValue.indexOf("_");
+  if (delimiterIndex < 0) {
+    return { valid: false, error: `ID '${idValue}' has no '_' delimiter.` };
+  }
+  const prefix = idValue.slice(0, delimiterIndex);
+  if (!prefix) {
+    return { valid: false, error: "ID has an empty prefix." };
+  }
+  const body = idValue.slice(delimiterIndex + 1);
+  if (body.length !== NEW_FORMAT_BODY_LENGTH && body.length !== LEGACY_BODY_LENGTH) {
+    return {
+      valid: false,
+      error: `ID '${idValue}' has unexpected body length ${body.length} (expected ${NEW_FORMAT_BODY_LENGTH} or ${LEGACY_BODY_LENGTH}).`
+    };
+  }
+  if (allowedPrefixes && !allowedPrefixes.includes(prefix)) {
+    return {
+      valid: false,
+      error: `ID prefix '${prefix}' is not in the allowed set [${allowedPrefixes.join(", ")}].`
+    };
+  }
+  if (!/^[A-Za-z0-9]+$/.test(body)) {
+    return {
+      valid: false,
+      error: `ID '${idValue}' body must be alphanumeric.`
+    };
+  }
+  return { valid: true };
+}
+function normalizePartitionKey(partitionKey) {
+  if (partitionKey.length === LEGACY_PARTITION_KEY_LENGTH) {
+    return `${partitionKey}${PARTITION_KEY_SUFFIX}`;
+  }
+  return partitionKey;
+}
+function generatePartitionKey() {
+  return `${randomBytes(8).toString("hex")}${PARTITION_KEY_SUFFIX}`;
+}
+function generateEntropy() {
+  const chars = [];
+  while (chars.length < ENTROPY_LENGTH) {
+    const candidate = randomBytes(48).toString("base64");
+    for (const char of candidate) {
+      if (/^[A-Za-z0-9]$/.test(char)) {
+        chars.push(char);
+        if (chars.length >= ENTROPY_LENGTH) {
+          break;
+        }
+      }
+    }
+  }
+  return chars.join("");
+}
+function tryExtractPartitionKey(idValue) {
+  if (!idValue) {
+    return void 0;
+  }
+  const delimiterIndex = idValue.indexOf("_");
+  if (delimiterIndex < 0) {
+    return void 0;
+  }
+  const body = idValue.slice(delimiterIndex + 1);
+  if (body.length === NEW_FORMAT_BODY_LENGTH) {
+    return body.slice(0, PARTITION_KEY_TOTAL_LENGTH);
+  }
+  if (body.length === LEGACY_BODY_LENGTH) {
+    return body.slice(-LEGACY_PARTITION_KEY_LENGTH);
+  }
+  return void 0;
+}
+
+// src/model-helpers.ts
+import { createHash, randomBytes as randomBytes2 } from "crypto";
+var RESPONSE_ID_HEADER = "x-agent-response-id";
+var SESSION_ID_HEADER = "x-agent-session-id";
+var DEFAULT_AGENT_REFERENCE_NAME = "server-default-agent";
+var SESSION_ID_LENGTH = 63;
+function normalizeCreateResponse(value) {
+  if (value === void 0 || value === null) {
+    return {};
+  }
+  if (!isRecord(value)) {
+    throw new Error("request body must be a JSON object");
+  }
+  return { ...value };
+}
+function applyCreateResponseDefaults(request, defaults) {
+  const model = typeof request.model === "string" ? request.model.trim() : void 0;
+  if (model) {
+    return { ...request, model };
+  }
+  const defaultModel = defaults.defaultModel?.trim();
+  return defaultModel ? { ...request, model: defaultModel } : { ...request };
+}
+function resolveConversationId(request) {
+  const conversation = request.conversation;
+  if (typeof conversation === "string") {
+    return conversation || void 0;
+  }
+  if (isRecord(conversation) && typeof conversation.id === "string") {
+    return conversation.id || void 0;
+  }
+  return void 0;
+}
+function resolveResponseId(request, headers) {
+  const headerValue = headers.get(RESPONSE_ID_HEADER)?.trim();
+  const explicit = typeof request.response_id === "string" ? request.response_id.trim() : "";
+  const responseId = headerValue || explicit || newResponseId(
+    request.previous_response_id ?? resolveConversationId(request) ?? ""
+  );
+  validateResponseId(responseId);
+  return responseId;
+}
+function validateResponseId(responseId) {
+  const validation = isValidId(responseId, ["caresp"]);
+  if (!validation.valid) {
+    throw new Error(
+      "response_id must be in format caresp_<18-char partition key><32-char alphanumeric entropy>"
+    );
+  }
+}
+function resolveAgentReference(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (!isRecord(value)) {
+    throw new Error("agent_reference must be an object");
+  }
+  if (value.type !== void 0 && value.type !== "agent_reference") {
+    throw new Error("agent_reference.type must be 'agent_reference'");
+  }
+  if (typeof value.name !== "string" || !value.name.trim()) {
+    throw new Error("agent_reference.name must be a non-empty string");
+  }
+  return {
+    type: "agent_reference",
+    name: value.name.trim(),
+    ...typeof value.version === "string" ? { version: value.version } : {},
+    ...typeof value.id === "string" ? { id: value.id } : {}
+  };
+}
+function resolveSessionId(options) {
+  const requestSessionId = typeof options.request.agent_session_id === "string" ? options.request.agent_session_id.trim() : "";
+  if (requestSessionId) {
+    return requestSessionId;
+  }
+  if (options.envSessionId?.trim()) {
+    return options.envSessionId.trim();
+  }
+  return deriveSessionId({
+    conversationId: resolveConversationId(options.request),
+    previousResponseId: typeof options.request.previous_response_id === "string" ? options.request.previous_response_id : void 0,
+    agentReference: options.agentReference
+  });
+}
+function deriveSessionId(options) {
+  const partitionSource = options.conversationId ?? options.previousResponseId;
+  if (partitionSource) {
+    let partitionHint;
+    try {
+      partitionHint = extractPartitionKey(partitionSource);
+    } catch {
+      partitionHint = partitionSource;
+    }
+    const agentName = options.agentReference?.name ?? DEFAULT_AGENT_REFERENCE_NAME;
+    const agentVersion = options.agentReference?.version ?? "";
+    return computeHexHash(`${agentName}:${agentVersion}:${partitionHint}`);
+  }
+  return randomBytes2(48).toString("hex").slice(0, SESSION_ID_LENGTH);
+}
+function getInputExpanded(request, responseId) {
+  return normalizeResponseInput(request.input).map(
+    (item) => toOutputItem(item, responseId)
+  );
+}
+function normalizeResponseInput(input) {
+  if (input === void 0 || input === null) {
+    return [];
+  }
+  if (typeof input === "string") {
+    return [
+      {
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text: input }]
+      }
+    ];
+  }
+  if (Array.isArray(input)) {
+    return input;
+  }
+  return [input];
+}
+function toOutputItem(item, partitionHint) {
+  if (isItemReference(item)) {
+    return { id: item.id, type: "item_reference" };
+  }
+  if (isMessage(item)) {
+    const role = item.role;
+    const id = typeof item.id === "string" && item.id ? item.id : role === "assistant" ? newOutputMessageItemId(partitionHint) : newMessageItemId(partitionHint);
+    return {
+      id,
+      type: "message",
+      role,
+      status: "completed",
+      content: normalizeMessageContent(item.content, role)
+    };
+  }
+  if (isRecord(item)) {
+    const id = typeof item.id === "string" && item.id ? item.id : newMessageItemId(partitionHint);
+    return { id, ...item, type: String(item.type ?? "item") };
+  }
+  return { id: newMessageItemId(partitionHint), type: "item", value: item };
+}
+function extractTextFromItems(items) {
+  const texts = [];
+  for (const item of items) {
+    if (item.type !== "message") {
+      continue;
+    }
+    for (const part of item.content ?? []) {
+      if ((part.type === "input_text" || part.type === "output_text") && typeof part.text === "string") {
+        texts.push(part.text);
+      }
+    }
+  }
+  return texts.join("\n");
+}
+function createResponseObject(options) {
+  const conversationId = resolveConversationId(options.request);
+  return stripUndefined({
+    id: options.id,
+    object: "response",
+    created_at: options.createdAt ?? Math.floor(Date.now() / 1e3),
+    status: options.status,
+    model: typeof options.request.model === "string" ? options.request.model : void 0,
+    stream: options.request.stream === true ? true : void 0,
+    background: options.request.background === true ? true : void 0,
+    store: options.request.store === false ? false : void 0,
+    output: options.output ?? [],
+    error: options.error ?? null,
+    previous_response_id: typeof options.request.previous_response_id === "string" ? options.request.previous_response_id : null,
+    conversation: conversationId ? { id: conversationId } : void 0,
+    metadata: isRecord(options.request.metadata) || options.request.metadata === null ? options.request.metadata : void 0
+  });
+}
+function mergeResponseSnapshot(existing, update) {
+  return stripUndefined({
+    ...existing,
+    ...update,
+    output: update.output ?? existing.output
+  });
+}
+function normalizeMessageContent(content, role) {
+  if (typeof content === "string") {
+    return [
+      {
+        type: role === "assistant" ? "output_text" : "input_text",
+        text: content
+      }
+    ];
+  }
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content.map((part) => {
+    if (isRecord(part)) {
+      return part;
+    }
+    return { type: "input_text", text: String(part) };
+  });
+}
+function computeHexHash(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex").slice(0, 63);
+}
+function isMessage(value) {
+  return isRecord(value) && value.type === "message" && typeof value.role === "string" && (typeof value.content === "string" || Array.isArray(value.content));
+}
+function isItemReference(value) {
+  return isRecord(value) && value.type === "item_reference" && typeof value.id === "string";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stripUndefined(value) {
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry !== void 0) {
+      result[key] = entry;
+    }
+  }
+  return result;
+}
+
+// src/streaming/text-response.ts
+var TextResponse = class {
+  constructor(context, request, options) {
+    this.context = context;
+    this.request = request;
+    this.options = options;
+  }
+  [Symbol.asyncIterator]() {
+    return this.generate();
+  }
+  async *generate() {
+    let response = createResponseObject({
+      id: this.context.responseId,
+      request: this.request,
+      status: "queued",
+      createdAt: this.context.createdAt
+    });
+    this.options.configure?.(response);
+    yield { type: "response.created", response };
+    response = mergeResponseSnapshot(response, { status: "in_progress" });
+    yield { type: "response.in_progress", response };
+    const outputIndex = 0;
+    const contentIndex = 0;
+    const textPart = {
+      type: "output_text",
+      text: "",
+      annotations: []
+    };
+    const message = {
+      id: newOutputMessageItemId(this.context.responseId),
+      type: "message",
+      status: "in_progress",
+      role: "assistant",
+      content: [textPart]
+    };
+    yield {
+      type: "response.output_item.added",
+      output_index: outputIndex,
+      item: message
+    };
+    yield {
+      type: "response.content_part.added",
+      output_index: outputIndex,
+      content_index: contentIndex,
+      item_id: message.id,
+      part: textPart
+    };
+    let accumulated = "";
+    for await (const chunk of iterateTextSource(this.options.text)) {
+      if (!chunk) {
+        continue;
+      }
+      accumulated += chunk;
+      yield {
+        type: "response.output_text.delta",
+        output_index: outputIndex,
+        content_index: contentIndex,
+        item_id: message.id,
+        delta: chunk
+      };
+    }
+    textPart.text = accumulated;
+    message.status = "completed";
+    yield {
+      type: "response.output_text.done",
+      output_index: outputIndex,
+      content_index: contentIndex,
+      item_id: message.id,
+      text: accumulated
+    };
+    yield {
+      type: "response.content_part.done",
+      output_index: outputIndex,
+      content_index: contentIndex,
+      item_id: message.id,
+      part: textPart
+    };
+    yield {
+      type: "response.output_item.done",
+      output_index: outputIndex,
+      item: message
+    };
+    response = mergeResponseSnapshot(response, {
+      status: "completed",
+      output: [message],
+      error: null
+    });
+    yield { type: "response.completed", response };
+  }
+};
+async function* iterateTextSource(source) {
+  if (typeof source === "string") {
+    yield source;
+    return;
+  }
+  if (typeof source === "function") {
+    yield await source();
+    return;
+  }
+  if (isAsyncIterable(source)) {
+    for await (const chunk of source) {
+      yield chunk;
+    }
+    return;
+  }
+  for (const chunk of source) {
+    yield chunk;
+  }
+}
+function isAsyncIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+
+export {
+  newId,
+  newResponseId,
+  newMessageItemId,
+  newOutputMessageItemId,
+  extractPartitionKey,
+  isValidId,
+  RESPONSE_ID_HEADER,
+  SESSION_ID_HEADER,
+  normalizeCreateResponse,
+  applyCreateResponseDefaults,
+  resolveConversationId,
+  resolveResponseId,
+  validateResponseId,
+  resolveAgentReference,
+  resolveSessionId,
+  deriveSessionId,
+  getInputExpanded,
+  normalizeResponseInput,
+  toOutputItem,
+  extractTextFromItems,
+  createResponseObject,
+  startResponsesSseResponse,
+  createSseEncoderState,
+  encodeSseEvent,
+  encodeKeepAliveComment,
+  TextResponse
+};