@cuylabs/agent-foundry-agentserver-responses 4.9.0

package/dist/chunk-DGMWFFNQ.js

@@ -0,0 +1,473 @@
+// src/store/foundry-errors.ts
+var FoundryStorageError = class extends Error {
+  constructor(message, status, code = "foundry_storage_error", responseBody) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.responseBody = responseBody;
+    this.name = "FoundryStorageError";
+  }
+};
+var FoundryStorageNotFoundError = class extends FoundryStorageError {
+  constructor(message, responseBody) {
+    super(message, 404, "not_found", responseBody);
+    this.name = "FoundryStorageNotFoundError";
+  }
+};
+async function throwIfStorageError(response) {
+  if (response.ok) {
+    return;
+  }
+  const body = await parseErrorBody(response);
+  const message = messageFromBody(body) ?? `Foundry storage request failed with HTTP ${response.status}`;
+  if (response.status === 404) {
+    throw new FoundryStorageNotFoundError(message, body);
+  }
+  throw new FoundryStorageError(
+    message,
+    response.status,
+    codeFromBody(body) ?? "foundry_storage_error",
+    body
+  );
+}
+async function parseErrorBody(response) {
+  const text = await response.text().catch(() => "");
+  if (!text) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function messageFromBody(body) {
+  if (isRecord(body)) {
+    const error = body.error;
+    if (isRecord(error) && typeof error.message === "string") {
+      return error.message;
+    }
+    if (typeof body.message === "string") {
+      return body.message;
+    }
+  }
+  return typeof body === "string" ? body : void 0;
+}
+function codeFromBody(body) {
+  if (isRecord(body)) {
+    const error = body.error;
+    if (isRecord(error) && typeof error.code === "string") {
+      return error.code;
+    }
+    if (typeof body.code === "string") {
+      return body.code;
+    }
+  }
+  return void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/store/foundry-provider.ts
+import {
+  CHAT_ISOLATION_HEADER,
+  USER_ISOLATION_HEADER
+} from "@cuylabs/agent-foundry-agentserver-core";
+
+// src/package-version.ts
+var AGENTSERVER_RESPONSES_PACKAGE_VERSION = "4.8.1";
+
+// src/store/foundry-settings.ts
+var STORAGE_API_VERSION = "v1";
+var FoundryStorageSettings = class _FoundryStorageSettings {
+  storageBaseUrl;
+  constructor(options) {
+    this.storageBaseUrl = normalizeBaseUrl(options.storageBaseUrl);
+  }
+  static fromEnv(env = process.env) {
+    const endpoint = env.FOUNDRY_PROJECT_ENDPOINT?.trim();
+    if (!endpoint) {
+      throw new Error(
+        "FOUNDRY_PROJECT_ENDPOINT is required for Foundry response storage."
+      );
+    }
+    return _FoundryStorageSettings.fromEndpoint(endpoint);
+  }
+  static fromEndpoint(endpoint) {
+    const normalized = endpoint.trim();
+    if (!normalized) {
+      throw new Error("endpoint must be a non-empty string");
+    }
+    const parsed = new URL(normalized);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new Error("endpoint must be an absolute http or https URL");
+    }
+    return new _FoundryStorageSettings({
+      storageBaseUrl: `${parsed.origin}${parsed.pathname.replace(/\/?$/, "/")}storage/`
+    });
+  }
+  static resolve(options = {}) {
+    if (options.storageBaseUrl) {
+      return new _FoundryStorageSettings({
+        storageBaseUrl: options.storageBaseUrl
+      });
+    }
+    if (options.projectEndpoint) {
+      return _FoundryStorageSettings.fromEndpoint(options.projectEndpoint);
+    }
+    return _FoundryStorageSettings.fromEnv(options.env);
+  }
+  buildUrl(path, query = {}) {
+    const normalizedPath = path.replace(/^\/+/, "");
+    const url = new URL(normalizedPath, this.storageBaseUrl);
+    url.searchParams.set("api-version", STORAGE_API_VERSION);
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) {
+        url.searchParams.set(key, value);
+      }
+    }
+    return url.toString();
+  }
+};
+function normalizeBaseUrl(value) {
+  const normalized = value.trim();
+  if (!normalized) {
+    throw new Error("storageBaseUrl must be a non-empty string");
+  }
+  const parsed = new URL(normalized);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("storageBaseUrl must be an absolute http or https URL");
+  }
+  return parsed.toString().replace(/\/?$/, "/");
+}
+
+// src/store/foundry-provider.ts
+var FOUNDRY_TOKEN_SCOPE = "https://ai.azure.com/.default";
+var JSON_CONTENT_TYPE = "application/json; charset=utf-8";
+var FoundryStorageProvider = class {
+  credential;
+  fetchImpl;
+  settings;
+  getServerVersion;
+  constructor(options) {
+    this.credential = options.credential;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    this.settings = FoundryStorageSettings.resolve(options);
+    this.getServerVersion = options.getServerVersion;
+    if (!this.fetchImpl) {
+      throw new Error("global fetch is unavailable; provide options.fetch");
+    }
+  }
+  async createResponse(response, inputItems, options = {}) {
+    await this.request("responses", {
+      body: {
+        response,
+        input_items: inputItems,
+        history_item_ids: [...options.historyItemIds ?? []]
+      },
+      isolation: options.isolation,
+      method: "POST"
+    });
+  }
+  async getResponse(responseId, options = {}) {
+    try {
+      return await this.request(
+        `responses/${encodeURIComponent(responseId)}`,
+        {
+          isolation: options.isolation,
+          method: "GET"
+        }
+      );
+    } catch (error) {
+      if (error instanceof FoundryStorageNotFoundError) {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  async updateResponse(response, options = {}) {
+    await this.request(`responses/${encodeURIComponent(response.id)}`, {
+      body: response,
+      isolation: options.isolation,
+      method: "POST"
+    });
+  }
+  async deleteResponse(responseId, options = {}) {
+    try {
+      await this.request(`responses/${encodeURIComponent(responseId)}`, {
+        isolation: options.isolation,
+        method: "DELETE"
+      });
+      return true;
+    } catch (error) {
+      if (error instanceof FoundryStorageNotFoundError) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async getInputItems(responseId, options = {}) {
+    try {
+      const result = await this.request(
+        `responses/${encodeURIComponent(responseId)}/input_items`,
+        {
+          isolation: options.isolation,
+          method: "GET",
+          query: {
+            after: options.after,
+            before: options.before,
+            limit: options.limit !== void 0 ? String(options.limit) : void 0,
+            order: options.ascending === true ? "asc" : "desc"
+          }
+        }
+      );
+      return Array.isArray(result.data) ? result.data : [];
+    } catch (error) {
+      if (error instanceof FoundryStorageNotFoundError) {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  async getItems(itemIds, options = {}) {
+    return await this.request(
+      "items/batch/retrieve",
+      {
+        body: { item_ids: [...itemIds] },
+        isolation: options.isolation,
+        method: "POST"
+      }
+    ).then((items) => items.map((item) => item ?? void 0));
+  }
+  async getHistoryItemIds(previousResponseId, conversationId, limit, options = {}) {
+    return await this.request("history/item_ids", {
+      isolation: options.isolation,
+      method: "GET",
+      query: {
+        conversation_id: conversationId,
+        limit: String(limit),
+        previous_response_id: previousResponseId
+      }
+    });
+  }
+  async request(path, options) {
+    const token = await this.credential.getToken(FOUNDRY_TOKEN_SCOPE);
+    if (!token?.token) {
+      throw new Error("credential did not return an access token");
+    }
+    const response = await this.fetchImpl(
+      this.settings.buildUrl(path, options.query),
+      {
+        body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+        headers: this.headers(token.token, options),
+        method: options.method
+      }
+    );
+    await throwIfStorageError(response);
+    if (response.status === 204) {
+      return void 0;
+    }
+    const text = await response.text();
+    return text ? JSON.parse(text) : void 0;
+  }
+  headers(token, options) {
+    const headers = {
+      authorization: `Bearer ${token}`,
+      "user-agent": this.getServerVersion?.() ?? `ai-agentserver-responses/${AGENTSERVER_RESPONSES_PACKAGE_VERSION}`
+    };
+    if (options.body !== void 0) {
+      headers["content-type"] = JSON_CONTENT_TYPE;
+    }
+    if (options.isolation?.userKey !== void 0) {
+      headers[USER_ISOLATION_HEADER] = options.isolation.userKey;
+    }
+    if (options.isolation?.chatKey !== void 0) {
+      headers[CHAT_ISOLATION_HEADER] = options.isolation.chatKey;
+    }
+    return headers;
+  }
+};
+
+// src/store/memory.ts
+var InMemoryResponseProvider = class {
+  responses = /* @__PURE__ */ new Map();
+  inputItems = /* @__PURE__ */ new Map();
+  historyItemIds = /* @__PURE__ */ new Map();
+  items = /* @__PURE__ */ new Map();
+  streamEvents = /* @__PURE__ */ new Map();
+  conversationResponses = /* @__PURE__ */ new Map();
+  deleted = /* @__PURE__ */ new Set();
+  async createResponse(response, inputItems, options = {}) {
+    const responseKey = scopedKey(response.id, options.isolation);
+    this.responses.set(responseKey, clone(response));
+    this.inputItems.set(responseKey, clone(inputItems));
+    this.historyItemIds.set(responseKey, [...options.historyItemIds ?? []]);
+    for (const item of [...inputItems, ...response.output]) {
+      this.items.set(scopedKey(item.id, options.isolation), clone(item));
+    }
+    const conversationId = response.conversation?.id;
+    if (conversationId) {
+      const conversationKey = scopedKey(conversationId, options.isolation);
+      const responseIds = this.conversationResponses.get(conversationKey) ?? [];
+      if (!responseIds.includes(response.id)) {
+        responseIds.push(response.id);
+      }
+      this.conversationResponses.set(conversationKey, responseIds);
+    }
+    this.deleted.delete(responseKey);
+  }
+  async getResponse(responseId, options = {}) {
+    return clone(this.responses.get(scopedKey(responseId, options.isolation)));
+  }
+  async updateResponse(response, options = {}) {
+    const responseKey = scopedKey(response.id, options.isolation);
+    this.responses.set(responseKey, clone(response));
+    for (const item of response.output) {
+      this.items.set(scopedKey(item.id, options.isolation), clone(item));
+    }
+    const conversationId = response.conversation?.id;
+    if (conversationId) {
+      const conversationKey = scopedKey(conversationId, options.isolation);
+      const responseIds = this.conversationResponses.get(conversationKey) ?? [];
+      if (!responseIds.includes(response.id)) {
+        responseIds.push(response.id);
+      }
+      this.conversationResponses.set(conversationKey, responseIds);
+    }
+  }
+  async deleteResponse(responseId, options = {}) {
+    const responseKey = scopedKey(responseId, options.isolation);
+    const existed = this.responses.delete(responseKey);
+    this.inputItems.delete(responseKey);
+    this.historyItemIds.delete(responseKey);
+    this.streamEvents.delete(responseKey);
+    if (existed) {
+      this.deleted.add(responseKey);
+    }
+    return existed;
+  }
+  async getItems(itemIds, options = {}) {
+    return itemIds.map(
+      (itemId) => clone(this.items.get(scopedKey(itemId, options.isolation)))
+    );
+  }
+  async getInputItems(responseId, options = {}) {
+    const responseKey = scopedKey(responseId, options.isolation);
+    if (!this.responses.has(responseKey)) {
+      return void 0;
+    }
+    const itemIds = [
+      ...this.historyItemIds.get(responseKey) ?? [],
+      ...(this.inputItems.get(responseKey) ?? []).map((item) => item.id)
+    ];
+    const orderedIds = options.ascending === true ? itemIds : [...itemIds].reverse();
+    const afterIndex = options.after !== void 0 ? orderedIds.indexOf(options.after) : -1;
+    const afterFiltered = afterIndex >= 0 ? orderedIds.slice(afterIndex + 1) : orderedIds;
+    const beforeIndex = options.before !== void 0 ? afterFiltered.indexOf(options.before) : -1;
+    const cursorFiltered = beforeIndex >= 0 ? afterFiltered.slice(0, beforeIndex) : afterFiltered;
+    const limit = clampLimit(options.limit);
+    return cursorFiltered.slice(0, limit).map((itemId) => this.items.get(scopedKey(itemId, options.isolation))).filter((item) => item !== void 0).map((item) => clone(item));
+  }
+  async getHistoryItemIds(previousResponseId, conversationId, limit, options = {}) {
+    const resolved = [];
+    if (previousResponseId) {
+      this.collectPreviousResponseHistoryItemIds(
+        previousResponseId,
+        options.isolation,
+        resolved
+      );
+    }
+    if (conversationId) {
+      const conversationKey = scopedKey(conversationId, options.isolation);
+      const responseIds = this.conversationResponses.get(conversationKey) ?? [];
+      for (const responseId of responseIds) {
+        this.collectResponseItemIds(responseId, options.isolation, resolved);
+      }
+    }
+    return resolved.slice(0, Math.max(0, limit));
+  }
+  async getHistoryItems(previousResponseId, conversationId, limit, options = {}) {
+    const itemIds = await this.getHistoryItemIds(
+      previousResponseId,
+      conversationId,
+      limit,
+      options
+    );
+    const items = await this.getItems(itemIds, options);
+    return items.filter((item) => item !== void 0);
+  }
+  async appendStreamEvent(responseId, event, options = {}) {
+    const responseKey = scopedKey(responseId, options.isolation);
+    const events = this.streamEvents.get(responseKey) ?? [];
+    events.push(clone(event));
+    this.streamEvents.set(responseKey, events);
+  }
+  async getStreamEvents(responseId, options = {}) {
+    return clone(
+      this.streamEvents.get(scopedKey(responseId, options.isolation))
+    );
+  }
+  async saveStreamEvents(responseId, events, options = {}) {
+    this.streamEvents.set(
+      scopedKey(responseId, options.isolation),
+      clone(events)
+    );
+  }
+  async deleteStreamEvents(responseId, options = {}) {
+    this.streamEvents.delete(scopedKey(responseId, options.isolation));
+  }
+  isDeleted(responseId, isolation) {
+    return this.deleted.has(scopedKey(responseId, isolation));
+  }
+  collectPreviousResponseHistoryItemIds(responseId, isolation, output) {
+    const response = this.responses.get(scopedKey(responseId, isolation));
+    if (!response) {
+      return;
+    }
+    if (response.previous_response_id) {
+      this.collectPreviousResponseHistoryItemIds(
+        response.previous_response_id,
+        isolation,
+        output
+      );
+    }
+    this.collectResponseItemIds(responseId, isolation, output);
+  }
+  collectResponseItemIds(responseId, isolation, output) {
+    const responseKey = scopedKey(responseId, isolation);
+    const response = this.responses.get(responseKey);
+    if (!response) {
+      return;
+    }
+    output.push(...this.historyItemIds.get(responseKey) ?? []);
+    output.push(
+      ...(this.inputItems.get(responseKey) ?? []).map((item) => item.id)
+    );
+    output.push(...response.output.map((item) => item.id));
+  }
+};
+function scopedKey(id, isolation) {
+  return `${isolation?.chatKey ?? ""}|${isolation?.userKey ?? ""}|${id}`;
+}
+function clone(value) {
+  if (value === void 0) {
+    return value;
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+function clampLimit(value) {
+  if (!Number.isInteger(value) || value === void 0) {
+    return 20;
+  }
+  return Math.max(1, Math.min(100, value));
+}
+
+export {
+  AGENTSERVER_RESPONSES_PACKAGE_VERSION,
+  InMemoryResponseProvider,
+  FoundryStorageError,
+  FoundryStorageNotFoundError,
+  FoundryStorageSettings,
+  FoundryStorageProvider
+};

package/dist/index.d.ts

@@ -0,0 +1,60 @@
+import { Express } from 'express';
+import { R as ResponsesServerOptions, a as ResponsesServer, C as CreateResponse, b as ResponseObject, O as OutputItem, A as AgentReference, c as ResponseInput, I as InputItem } from './types-Dvs2F85g.js';
+export { d as ConversationReference, E as ExpressResponse, F as FunctionCallOutputItem, e as ItemMessage, f as ItemReference, J as JsonValue, M as MessageContent, g as MessageContentInputText, h as MessageContentOutputText, i as MessageContentRefusal, j as ResponseContext, k as ResponseError, l as ResponseHandler, m as ResponseHandlerContext, n as ResponseHandlerResult, o as ResponseModeFlags, p as ResponseProvider, q as ResponseStatus, r as ResponseStreamEvent, s as ResponseStreamProvider, t as ResponseUsage, u as ResponsesHandler, v as ResponsesHandlerFactory, w as ResponsesHandlerInput, x as ResponsesRequest, y as ResponsesServerLogger } from './types-Dvs2F85g.js';
+export { AccessToken, FoundryStorageError, FoundryStorageNotFoundError, FoundryStorageProvider, FoundryStorageProviderOptions, FoundryStorageSettings, FoundryStorageSettingsOptions, InMemoryResponseProvider, TokenCredential } from './store/index.js';
+export { SseEncoderState, TextResponse, TextSource, createSseEncoderState, encodeKeepAliveComment, encodeSseEvent, startResponsesSseResponse } from './streaming/index.js';
+import 'node:http';
+import '@cuylabs/agent-foundry-agentserver-core';
+
+declare function createResponsesApp(options: ResponsesServerOptions): Express;
+declare function runResponsesServer(options: ResponsesServerOptions): Promise<ResponsesServer>;
+
+declare const AGENTSERVER_RESPONSES_PACKAGE_VERSION = "4.8.1";
+
+declare function newId(prefix: string, partitionKeyHint?: string): string;
+declare function newResponseId(partitionKeyHint?: string): string;
+declare function newMessageItemId(partitionKeyHint?: string): string;
+declare function newOutputMessageItemId(partitionKeyHint?: string): string;
+declare function extractPartitionKey(idValue: string): string;
+declare function isValidId(idValue: string | undefined, allowedPrefixes?: readonly string[]): {
+    valid: boolean;
+    error?: string;
+};
+
+declare const RESPONSE_ID_HEADER: "x-agent-response-id";
+declare const SESSION_ID_HEADER: "x-agent-session-id";
+declare function normalizeCreateResponse(value: unknown): CreateResponse;
+declare function resolveConversationId(request: Pick<CreateResponse, "conversation">): string | undefined;
+declare function resolveResponseId(request: CreateResponse, headers: {
+    get(name: string): string | undefined;
+}): string;
+declare function validateResponseId(responseId: string): void;
+declare function resolveAgentReference(value: unknown): AgentReference | undefined;
+declare function resolveSessionId(options: {
+    request: CreateResponse;
+    envSessionId?: string;
+    agentReference?: AgentReference;
+}): string;
+declare function deriveSessionId(options: {
+    conversationId?: string;
+    previousResponseId?: string;
+    agentReference?: AgentReference;
+}): string;
+declare function getInputExpanded(request: Pick<CreateResponse, "input">, responseId: string): OutputItem[];
+declare function normalizeResponseInput(input: ResponseInput | undefined): InputItem[];
+declare function toOutputItem(item: InputItem, partitionHint: string): OutputItem;
+declare function extractTextFromItems(items: readonly OutputItem[]): string;
+declare function createResponseObject(options: {
+    id: string;
+    request: CreateResponse;
+    status: ResponseObject["status"];
+    output?: OutputItem[];
+    error?: ResponseObject["error"];
+    createdAt?: number;
+}): ResponseObject;
+
+declare function buildResponsesOpenApiSpec(options?: {
+    appName?: string;
+}): Record<string, unknown>;
+
+export { AGENTSERVER_RESPONSES_PACKAGE_VERSION, AgentReference, CreateResponse, InputItem, OutputItem, RESPONSE_ID_HEADER, ResponseInput, ResponseObject, ResponsesServer, ResponsesServerOptions, SESSION_ID_HEADER, buildResponsesOpenApiSpec, createResponseObject, createResponsesApp, deriveSessionId, extractPartitionKey, extractTextFromItems, getInputExpanded, isValidId, newId, newMessageItemId, newOutputMessageItemId, newResponseId, normalizeCreateResponse, normalizeResponseInput, resolveAgentReference, resolveConversationId, resolveResponseId, resolveSessionId, runResponsesServer, toOutputItem, validateResponseId };