@rcrsr/rill-agent-foundry 0.18.4 → 0.18.6

package/dist/index.js

@@ -1,22 +1,969 @@
-// ============================================================
-// TYPES
-// ============================================================
-// ============================================================
-// ERRORS
-// ============================================================
-export { CapacityError, CredentialError, InputError } from './errors.js';
-export { createIdGenerator, generateId } from './id.js';
-export { extractInput } from './extract.js';
-export { createSessionManager } from './session.js';
-// ============================================================
-// RESPONSE BUILDERS
-// ============================================================
-export { buildErrorResponse, buildSyncResponse, generateToolDefinitions, } from './response.js';
-// ============================================================
-// SSE STREAM EMITTER
-// ============================================================
-export { streamFoundryResponse } from './stream.js';
-export { createConversationsClient, PersistenceError, } from './conversations.js';
-export { initTelemetry, getTracer, shutdownTelemetry } from './telemetry.js';
-export { createFoundryHarness } from './harness.js';
-//# sourceMappingURL=index.js.map
+// src/errors.ts
+var InputError = class extends Error {
+  /** HTTP status code for this error. */
+  statusCode;
+  constructor(message) {
+    super(message);
+    this.name = "InputError";
+    this.statusCode = 400;
+  }
+};
+var CredentialError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CredentialError";
+  }
+};
+var CapacityError = class extends Error {
+  /** HTTP status code for this error. */
+  statusCode;
+  constructor(max) {
+    super(`Maximum concurrent sessions (${max}) reached`);
+    this.name = "CapacityError";
+    this.statusCode = 429;
+  }
+};
+
+// src/id.ts
+import { randomBytes } from "crypto";
+var PARTITION_KEY_LENGTH = 18;
+var ENTROPY_LENGTH = 32;
+function generateEntropy(length) {
+  let result = "";
+  while (result.length < length) {
+    const bytes = randomBytes(Math.ceil(length * 1.5));
+    result += bytes.toString("base64").replace(/[^A-Za-z0-9]/g, "");
+  }
+  return result.slice(0, length);
+}
+function extractPartitionKey(id) {
+  const underscoreIdx = id.indexOf("_");
+  if (underscoreIdx === -1) return null;
+  const segment = id.slice(underscoreIdx + 1);
+  if (segment.length < PARTITION_KEY_LENGTH) return null;
+  return segment.slice(0, PARTITION_KEY_LENGTH);
+}
+function buildId(prefix, partitionKey) {
+  const entropy = generateEntropy(ENTROPY_LENGTH);
+  return `${prefix}_${partitionKey}${entropy}`;
+}
+function createIdGenerator(responseId, conversationId) {
+  const partitionKey = (conversationId !== void 0 ? extractPartitionKey(conversationId) : null) ?? (responseId !== void 0 ? extractPartitionKey(responseId) : null) ?? generateEntropy(PARTITION_KEY_LENGTH);
+  const resolvedResponseId = responseId ?? buildId("resp", partitionKey);
+  return {
+    responseId: resolvedResponseId,
+    generateMessageId: () => buildId("msg", partitionKey),
+    generateFunctionCallId: () => buildId("func", partitionKey),
+    generateFunctionOutputId: () => buildId("funcout", partitionKey)
+  };
+}
+function generateId(prefix) {
+  return prefix + generateEntropy(ENTROPY_LENGTH);
+}
+
+// src/extract.ts
+function concatenateTextParts(parts) {
+  return parts.filter((p) => p.type === "input_text").map((p) => p.text).join("");
+}
+function extractUserText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return concatenateTextParts(content);
+}
+function findLastUserText(items) {
+  let text;
+  for (const item of items) {
+    if (item.type === "message" && item.role === "user") {
+      text = extractUserText(item.content);
+    }
+  }
+  return text;
+}
+function extractFunctionCallOutputs(items) {
+  const callMap = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.type === "function_call") {
+      callMap.set(item.call_id, item.name);
+    }
+  }
+  const outputs = items.filter(
+    (item) => item.type === "function_call_output"
+  );
+  let targetAgent;
+  const toolResults = [];
+  for (const output of outputs) {
+    const handlerName = callMap.get(output.call_id);
+    if (handlerName === void 0) {
+      throw new InputError("function_call_output missing paired function_call");
+    }
+    if (targetAgent === void 0) {
+      targetAgent = handlerName;
+    }
+    toolResults.push({ call_id: output.call_id, output: output.output });
+  }
+  return {
+    params: { tool_results: toolResults },
+    targetAgent
+  };
+}
+function extractInput(input) {
+  if (input === void 0 || input === null || input === "") {
+    throw new InputError("Missing required field: input");
+  }
+  if (typeof input === "string") {
+    if (input.trim() === "") {
+      throw new InputError("Missing required field: input");
+    }
+    return { params: { input } };
+  }
+  if (!Array.isArray(input) || input.length === 0) {
+    throw new InputError("Missing required field: input");
+  }
+  const items = input;
+  const hasFunctionCallOutput = items.some(
+    (item) => item.type === "function_call_output"
+  );
+  if (hasFunctionCallOutput) {
+    return extractFunctionCallOutputs(items);
+  }
+  const userText = findLastUserText(items);
+  if (userText !== void 0) {
+    return { params: { input: userText } };
+  }
+  throw new InputError("No actionable input items found");
+}
+
+// src/session.ts
+var DEFAULT_MAX_SESSIONS = 10;
+function createSessionManager() {
+  const raw = process.env["MAX_CONCURRENT_SESSIONS"];
+  const parsed = raw !== void 0 ? parseInt(raw, 10) : NaN;
+  const max = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_SESSIONS;
+  const active = /* @__PURE__ */ new Set();
+  return {
+    acquire(conversationId) {
+      if (active.size >= max) {
+        throw new CapacityError(max);
+      }
+      const sessionId = conversationId ?? generateId("sess_");
+      active.add(sessionId);
+      return sessionId;
+    },
+    release(sessionId) {
+      active.delete(sessionId);
+    },
+    activeCount() {
+      return active.size;
+    }
+  };
+}
+
+// src/response.ts
+function coerceResult(result) {
+  if (result === null || result === void 0) {
+    return "";
+  }
+  if (typeof result === "string") {
+    return result;
+  }
+  if (typeof result === "number" || typeof result === "boolean") {
+    return String(result);
+  }
+  return JSON.stringify(result);
+}
+function buildSyncResponse(result, responseId) {
+  const status = result.state === "completed" ? "completed" : "failed";
+  const text = coerceResult(result.result);
+  const msgId = generateId("msg_");
+  return {
+    id: responseId,
+    object: "response",
+    created_at: Math.floor(Date.now() / 1e3),
+    status,
+    output: [
+      {
+        id: msgId,
+        type: "message",
+        role: "assistant",
+        status: "completed",
+        content: [
+          {
+            type: "text",
+            text,
+            annotations: []
+          }
+        ]
+      }
+    ],
+    error: status === "failed" ? { code: "SERVER_ERROR", message: text } : null,
+    metadata: {},
+    temperature: 0,
+    top_p: 0,
+    user: ""
+  };
+}
+var GENERIC_MESSAGES = {
+  INVALID_REQUEST: "Invalid request",
+  NOT_FOUND: "Not found",
+  RATE_LIMITED: "Rate limited",
+  SERVER_ERROR: "Internal server error"
+};
+var FALLBACK_MESSAGE = "An error occurred";
+function buildErrorResponse(code, message, debug) {
+  const safeMessage = debug ? message : GENERIC_MESSAGES[code] ?? FALLBACK_MESSAGE;
+  return {
+    error: { code, message: safeMessage }
+  };
+}
+function mapParamType(rillType) {
+  switch (rillType) {
+    case "number":
+    case "integer":
+      return rillType;
+    case "boolean":
+      return "boolean";
+    default:
+      return "string";
+  }
+}
+function generateToolDefinitions(router) {
+  const defaultAgent = router.defaultAgent();
+  const description = router.describe(defaultAgent);
+  if (description === null) {
+    return [];
+  }
+  const properties = {};
+  const required = [];
+  for (const param of description.params) {
+    const property = {
+      type: mapParamType(param.type),
+      ...param.description !== void 0 ? { description: param.description } : {},
+      ...param.defaultValue !== void 0 ? { default: param.defaultValue } : {}
+    };
+    properties[param.name] = property;
+    if (param.required) {
+      required.push(param.name);
+    }
+  }
+  const parameters = {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+  return [
+    {
+      type: "function",
+      name: description.name,
+      description: description.description ?? "",
+      parameters,
+      strict: true
+    }
+  ];
+}
+
+// src/stream.ts
+var REDACTED_ERROR_MESSAGE = "Internal server error";
+var encoder = new TextEncoder();
+function sseChunk(event, data) {
+  return `event: ${event}
+data: ${data}
+
+`;
+}
+function sseHeaders(options) {
+  const headers = {
+    "content-type": "text/event-stream; charset=utf-8",
+    "cache-control": "no-store",
+    "x-accel-buffering": "no",
+    "x-aml-foundry-agents-metadata": options?.metadataHeader ?? JSON.stringify({
+      package: { name: "azure-ai-agentserver-core", version: "1.0.0b17" },
+      runtime: {
+        python_version: "3.11.0",
+        platform: "Linux",
+        host_name: "",
+        replica_name: ""
+      }
+    })
+  };
+  if (options?.sessionId !== void 0) {
+    headers["x-agent-session-id"] = options.sessionId;
+  }
+  if (options?.invocationId !== void 0) {
+    headers["x-agent-invocation-id"] = options.invocationId;
+  }
+  return headers;
+}
+function createFoundryStreamResponse(responseId, options) {
+  let seq = 0;
+  let closed = false;
+  let keepAliveTimer;
+  const clearKeepAlive = () => {
+    if (keepAliveTimer !== void 0) {
+      clearInterval(keepAliveTimer);
+      keepAliveTimer = void 0;
+    }
+  };
+  function ev(event, payload) {
+    payload["sequence_number"] = seq++;
+    return encoder.encode(sseChunk(event, JSON.stringify(payload)));
+  }
+  function emitDeltas(controller, fullText) {
+    const tokens = fullText.split(" ");
+    for (let i = 0; i < tokens.length; i++) {
+      const piece = i === tokens.length - 1 ? tokens[i] : tokens[i] + " ";
+      controller.enqueue(
+        ev("response.output_text.delta", {
+          type: "response.output_text.delta",
+          delta: piece
+        })
+      );
+    }
+  }
+  function emitCompletion(controller, fullText) {
+    controller.enqueue(
+      ev("response.output_text.done", {
+        type: "response.output_text.done",
+        text: fullText
+      })
+    );
+    controller.enqueue(
+      ev("response.completed", {
+        type: "response.completed",
+        response: {
+          object: "response",
+          id: responseId,
+          status: "completed",
+          created_at: Math.floor(Date.now() / 1e3),
+          output: []
+        }
+      })
+    );
+    closed = true;
+    controller.close();
+  }
+  function emitError(controller, err) {
+    clearKeepAlive();
+    options.onError?.(err);
+    const rawMessage = err instanceof Error ? err.message : String(err);
+    const message = options.debugErrors === true ? rawMessage : REDACTED_ERROR_MESSAGE;
+    controller.enqueue(
+      encoder.encode(
+        sseChunk(
+          "error",
+          JSON.stringify({
+            type: "error",
+            sequence_number: seq++,
+            code: "SERVER_ERROR",
+            message,
+            param: ""
+          })
+        )
+      )
+    );
+    closed = true;
+    controller.close();
+  }
+  const body = new ReadableStream({
+    start(controller) {
+      keepAliveTimer = setInterval(() => {
+        if (!closed) {
+          controller.enqueue(encoder.encode(": keep-alive\n\n"));
+        }
+      }, 15e3);
+      if (options.chunks !== void 0) {
+        (async () => {
+          let fullText = "";
+          for await (const chunk of options.chunks) {
+            if (closed) break;
+            fullText += chunk;
+            controller.enqueue(
+              ev("response.output_text.delta", {
+                type: "response.output_text.delta",
+                delta: chunk
+              })
+            );
+          }
+          if (closed) return;
+          clearKeepAlive();
+          emitCompletion(controller, fullText);
+        })().catch((err) => emitError(controller, err));
+      } else if (options.resultPromise !== void 0) {
+        options.resultPromise.then((resultText) => {
+          if (closed) return;
+          clearKeepAlive();
+          emitDeltas(controller, resultText);
+          emitCompletion(controller, resultText);
+        }).catch((err) => emitError(controller, err));
+      } else {
+        clearKeepAlive();
+        emitCompletion(controller, "");
+      }
+    },
+    cancel() {
+      closed = true;
+      clearKeepAlive();
+    }
+  });
+  return new Response(body, {
+    status: 200,
+    headers: sseHeaders(options)
+  });
+}
+function streamFoundryResponse(_c, responseId, resultStream, options) {
+  const resultPromise = options.resultPromise ?? (async () => {
+    let text = "";
+    for await (const chunk of resultStream) {
+      if (chunk.value !== null && chunk.value !== void 0) {
+        text += typeof chunk.value === "string" ? chunk.value : JSON.stringify(chunk.value);
+      }
+    }
+    return text;
+  })();
+  return createFoundryStreamResponse(responseId, {
+    ...options,
+    resultPromise
+  });
+}
+
+// src/conversations.ts
+var PersistenceError = class extends Error {
+  statusCode;
+  constructor(message) {
+    super(message);
+    this.name = "PersistenceError";
+    this.statusCode = 502;
+  }
+};
+var API_VERSION = "2025-11-15-preview";
+var TOKEN_SCOPE = "https://ai.azure.com/.default";
+var REQUEST_TIMEOUT_MS = 3e4;
+function createConversationsClient(projectEndpoint, credential) {
+  return {
+    async saveItems(conversationId, items) {
+      let token;
+      try {
+        const accessToken = await credential.getToken(TOKEN_SCOPE);
+        if (accessToken === null) {
+          throw new Error(`Failed to acquire token for scope ${TOKEN_SCOPE}`);
+        }
+        token = accessToken.token;
+      } catch (err) {
+        if (err instanceof CredentialError) {
+          throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        throw new CredentialError(message);
+      }
+      const encodedConversationId = encodeURIComponent(conversationId);
+      const url = new URL(
+        `${projectEndpoint}/openai/conversations/${encodedConversationId}/items`
+      );
+      url.searchParams.set("api-version", API_VERSION);
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+      try {
+        let response;
+        try {
+          response = await fetch(url.toString(), {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${token}`
+            },
+            body: JSON.stringify({ items }),
+            signal: controller.signal
+          });
+        } catch (err) {
+          const isTimeout = err instanceof Error && err.name === "AbortError";
+          throw new PersistenceError(
+            isTimeout ? "Conversations API timeout" : `Conversations API error: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+        if (!response.ok) {
+          throw new PersistenceError(
+            `Conversations API error: ${response.status}`
+          );
+        }
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+
+// src/telemetry.ts
+import { trace } from "@opentelemetry/api";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { Resource } from "@opentelemetry/resources";
+var sdk;
+function initTelemetry(options) {
+  if (!process.env["OTEL_EXPORTER_OTLP_ENDPOINT"]) return;
+  if (sdk !== void 0) return;
+  const resource = new Resource({
+    "service.name": options?.agentName ?? "rill-foundry-harness",
+    "service.version": options?.agentVersion ?? "0.0.0"
+  });
+  const traceExporter = new OTLPTraceExporter();
+  sdk = new NodeSDK({ resource, traceExporter });
+  sdk.start();
+}
+function getTracer() {
+  return trace.getTracer("rill-foundry-harness");
+}
+async function shutdownTelemetry() {
+  if (sdk === void 0) return;
+  const instance = sdk;
+  sdk = void 0;
+  await instance.shutdown();
+}
+
+// src/harness.ts
+import "hono";
+import { SpanStatusCode } from "@opentelemetry/api";
+import { DefaultAzureCredential } from "@azure/identity";
+import { validateParams, routerErrorToStatus } from "@rcrsr/rill-agent";
+
+// ../../shared/hono-kit/src/index.ts
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+function assertJsonObject(parsed) {
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Request body must be a JSON object");
+  }
+  return parsed;
+}
+function createHarnessLifecycle(options) {
+  const app = new Hono();
+  let server;
+  async function listen(port) {
+    if (server !== void 0) {
+      throw new Error("Server is already listening");
+    }
+    return new Promise((resolve) => {
+      server = serve({ fetch: app.fetch, port }, () => {
+        options?.serverTweaks?.(server);
+        resolve();
+      });
+    });
+  }
+  async function close() {
+    if (server !== void 0) {
+      server.close();
+      server = void 0;
+    }
+  }
+  return { app, listen, close };
+}
+
+// src/harness.ts
+var DEFAULT_PORT = 8088;
+function resolvePort(options) {
+  if (options?.port !== void 0) {
+    if (!Number.isFinite(options.port)) {
+      throw new Error(`Invalid port: "${options.port}"`);
+    }
+    return options.port;
+  }
+  const envVal = process.env["DEFAULT_AD_PORT"];
+  if (envVal === void 0) {
+    return DEFAULT_PORT;
+  }
+  const parsed = Number(envVal);
+  if (!Number.isFinite(parsed) || envVal.trim() === "") {
+    throw new Error(`Invalid port: "${envVal}"`);
+  }
+  return parsed;
+}
+function resolveConversationId(conversation) {
+  if (conversation === void 0) {
+    return void 0;
+  }
+  if (typeof conversation === "string") {
+    return conversation;
+  }
+  return conversation.id;
+}
+function createFoundryHarness(router, options) {
+  const port = resolvePort(options);
+  const debugErrors = options?.debugErrors ?? process.env["FOUNDRY_AGENT_DEBUG_ERRORS"] === "true";
+  const forceSync = options?.forceSync ?? process.env["FOUNDRY_AGENT_FORCE_SYNC"] === "true";
+  const agentName = options?.agentName ?? process.env["FOUNDRY_AGENT_NAME"];
+  const agentVersion = options?.agentVersion ?? process.env["FOUNDRY_AGENT_VERSION"];
+  initTelemetry({
+    agentName: agentName ?? router.defaultAgent(),
+    agentVersion
+  });
+  const sessions = createSessionManager();
+  const projectEndpoint = process.env["FOUNDRY_PROJECT_ENDPOINT"];
+  const azureCredential = projectEndpoint !== void 0 ? new DefaultAzureCredential() : void 0;
+  const conversationsClient = projectEndpoint !== void 0 && azureCredential !== void 0 ? createConversationsClient(projectEndpoint, azureCredential) : void 0;
+  let totalRequests = 0;
+  let errorCount = 0;
+  let ready = false;
+  function serverTweaks(srv) {
+    const s = srv;
+    s["requestTimeout"] = 0;
+    s["headersTimeout"] = 0;
+    s["keepAliveTimeout"] = 0;
+    s["timeout"] = 0;
+  }
+  const lifecycle = createHarnessLifecycle({ serverTweaks });
+  const app = lifecycle.app;
+  const metadataHeader = JSON.stringify({
+    package: {
+      name: "azure-ai-agentserver-core",
+      version: "1.0.0b17"
+    },
+    runtime: {
+      python_version: "3.11.0",
+      platform: "Linux",
+      host_name: "",
+      replica_name: ""
+    }
+  });
+  app.use("*", async (c, next) => {
+    await next();
+    c.res.headers.set("x-aml-foundry-agents-metadata", metadataHeader);
+  });
+  app.get("/liveness", (c) => {
+    totalRequests++;
+    return c.json({ status: "ok" }, 200);
+  });
+  app.get("/readiness", (c) => {
+    totalRequests++;
+    if (!ready) {
+      errorCount++;
+      return c.json({ status: "initializing" }, 503);
+    }
+    return c.json({ status: "ready" }, 200);
+  });
+  app.get("/metrics", (c) => {
+    totalRequests++;
+    return c.json({
+      activeSessions: sessions.activeCount(),
+      totalRequests,
+      errorCount
+    });
+  });
+  async function handleResponseRequest(c) {
+    totalRequests++;
+    let body;
+    try {
+      const parsed = await c.req.json();
+      body = assertJsonObject(parsed);
+    } catch (err) {
+      errorCount++;
+      return c.json(
+        buildErrorResponse(
+          "INVALID_REQUEST",
+          err instanceof Error ? err.message : "Invalid JSON in request body",
+          debugErrors
+        ),
+        400
+      );
+    }
+    let extracted;
+    try {
+      extracted = extractInput(body.input);
+    } catch (err) {
+      errorCount++;
+      if (err instanceof InputError) {
+        return c.json(
+          buildErrorResponse("INVALID_REQUEST", err.message, debugErrors),
+          400
+        );
+      }
+      return c.json(
+        buildErrorResponse(
+          "SERVER_ERROR",
+          err instanceof Error ? err.message : String(err),
+          debugErrors
+        ),
+        500
+      );
+    }
+    const conversationId = resolveConversationId(body.conversation);
+    const agentName_ = extracted.targetAgent ?? router.defaultAgent();
+    const validationError = validateParams(
+      extracted.params,
+      agentName_,
+      router
+    );
+    if (validationError !== null) {
+      errorCount++;
+      return c.json(
+        buildErrorResponse("INVALID_REQUEST", validationError, debugErrors),
+        400
+      );
+    }
+    let sessionId;
+    try {
+      sessionId = sessions.acquire(conversationId);
+    } catch (err) {
+      errorCount++;
+      if (err instanceof CapacityError) {
+        return c.json(
+          buildErrorResponse("RATE_LIMITED", err.message, debugErrors),
+          429
+        );
+      }
+      return c.json(
+        buildErrorResponse(
+          "SERVER_ERROR",
+          err instanceof Error ? err.message : String(err),
+          debugErrors
+        ),
+        500
+      );
+    }
+    const idGen = createIdGenerator(
+      body.metadata?.["response_id"],
+      conversationId
+    );
+    const responseId = idGen.responseId;
+    const invocationId = c.req.header("x-agent-invocation-id") ?? generateId("inv_");
+    const agentSessionId = c.req.query("session") ?? c.req.header("x-agent-session-id") ?? sessionId;
+    const sessionVars = {};
+    const oid = c.req.header("x-aml-oid");
+    if (oid !== void 0) sessionVars["AZURE_OID"] = oid;
+    const tid = c.req.header("x-aml-tid");
+    if (tid !== void 0) sessionVars["AZURE_TID"] = tid;
+    if (typeof body.user === "string") sessionVars["FOUNDRY_USER"] = body.user;
+    if (typeof body.model === "string")
+      sessionVars["FOUNDRY_MODEL"] = body.model;
+    if (typeof body.temperature === "number")
+      sessionVars["FOUNDRY_TEMPERATURE"] = String(body.temperature);
+    const runContext = {
+      sessionVars
+    };
+    const runRequest = {
+      params: extracted.params
+    };
+    if (body.stream === true && !forceSync) {
+      const tracer = getTracer();
+      const span = tracer.startSpan("foundry.agent.run", {
+        attributes: {
+          "foundry.agent.name": agentName_,
+          "foundry.response_id": responseId,
+          "foundry.stream": true
+        }
+      });
+      let pushChunk;
+      let endChunks;
+      let failChunks;
+      const chunkBuffer = [];
+      let done = false;
+      let waiting;
+      pushChunk = (chunk) => {
+        if (waiting !== void 0) {
+          const resolve = waiting;
+          waiting = void 0;
+          resolve({ value: chunk, done: false });
+        } else {
+          chunkBuffer.push(chunk);
+        }
+      };
+      endChunks = () => {
+        done = true;
+        if (waiting !== void 0) {
+          const resolve = waiting;
+          waiting = void 0;
+          resolve({ value: void 0, done: true });
+        }
+      };
+      let pendingError;
+      let rejectWaiting;
+      failChunks = (err) => {
+        pendingError = err;
+        done = true;
+        if (rejectWaiting !== void 0) {
+          const reject = rejectWaiting;
+          rejectWaiting = void 0;
+          waiting = void 0;
+          reject(err);
+        }
+      };
+      const chunks = {
+        [Symbol.asyncIterator]() {
+          return {
+            next() {
+              if (chunkBuffer.length > 0) {
+                return Promise.resolve({
+                  value: chunkBuffer.shift(),
+                  done: false
+                });
+              }
+              if (done) {
+                if (pendingError !== void 0) {
+                  return Promise.reject(pendingError);
+                }
+                return Promise.resolve({
+                  value: void 0,
+                  done: true
+                });
+              }
+              return new Promise((resolve, reject) => {
+                waiting = resolve;
+                rejectWaiting = reject;
+              });
+            }
+          };
+        }
+      };
+      const onChunk = async (chunk) => {
+        const text = typeof chunk === "string" ? chunk : JSON.stringify(chunk);
+        pushChunk(text);
+      };
+      const streamContext = { ...runContext, onChunk };
+      router.run(agentName_, runRequest, streamContext).then((result) => {
+        span.setAttribute("foundry.agent.state", result.state);
+        span.end();
+        sessions.release(sessionId);
+        if (!result.streamed) {
+          if (result.result !== null && result.result !== void 0) {
+            const text = typeof result.result === "string" ? result.result : JSON.stringify(result.result);
+            if (text !== "") pushChunk(text);
+          }
+        }
+        endChunks();
+      }).catch((err) => {
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: err instanceof Error ? err.message : String(err)
+        });
+        span.end();
+        sessions.release(sessionId);
+        failChunks(err);
+      });
+      return createFoundryStreamResponse(responseId, {
+        chunks,
+        idGenerator: idGen,
+        onError: (_err) => {
+          errorCount++;
+        },
+        sessionId: agentSessionId,
+        invocationId,
+        metadataHeader,
+        debugErrors
+      });
+    }
+    try {
+      let result;
+      const tracer = getTracer();
+      const span = tracer.startSpan("foundry.agent.run", {
+        attributes: {
+          "foundry.agent.name": agentName_,
+          "foundry.response_id": responseId,
+          "foundry.stream": false
+        }
+      });
+      try {
+        result = await router.run(agentName_, runRequest, runContext);
+        span.setAttribute("foundry.agent.state", result.state);
+      } catch (err) {
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: err instanceof Error ? err.message : String(err)
+        });
+        span.end();
+        errorCount++;
+        const msg = err instanceof Error ? err.message : String(err);
+        const status = routerErrorToStatus(err);
+        if (status === 404) {
+          return c.json(buildErrorResponse("NOT_FOUND", msg, debugErrors), 404);
+        }
+        return c.json(
+          buildErrorResponse("SERVER_ERROR", msg, debugErrors),
+          500
+        );
+      }
+      span.end();
+      const response = buildSyncResponse(result, responseId);
+      const shouldStore = body.store === true;
+      if (shouldStore && conversationId !== void 0 && conversationsClient !== void 0) {
+        try {
+          await conversationsClient.saveItems(conversationId, response.output);
+        } catch (err) {
+          errorCount++;
+          if (err instanceof PersistenceError) {
+            return c.json(
+              buildErrorResponse("SERVER_ERROR", err.message, debugErrors),
+              502
+            );
+          }
+          return c.json(
+            buildErrorResponse(
+              "SERVER_ERROR",
+              err instanceof Error ? err.message : String(err),
+              debugErrors
+            ),
+            502
+          );
+        }
+      }
+      if (result.state === "error") {
+        errorCount++;
+      }
+      return c.json(response, 200);
+    } finally {
+      sessions.release(sessionId);
+    }
+  }
+  app.post("/responses", (c) => handleResponseRequest(c));
+  app.post("/runs", (c) => handleResponseRequest(c));
+  ready = true;
+  async function listen() {
+    if (azureCredential !== void 0) {
+      try {
+        const token = await azureCredential.getToken(
+          "https://ai.azure.com/.default"
+        );
+        if (token === null) {
+          throw new CredentialError(
+            "Failed to acquire token for scope https://ai.azure.com/.default"
+          );
+        }
+      } catch (err) {
+        if (!(err instanceof CredentialError)) {
+          const message = err instanceof Error ? err.message : String(err);
+          throw new CredentialError(message);
+        }
+        process.exit(1);
+      }
+    }
+    await lifecycle.listen(port);
+  }
+  async function close() {
+    await lifecycle.close();
+    await shutdownTelemetry();
+  }
+  function metrics() {
+    return {
+      activeSessions: sessions.activeCount(),
+      totalRequests,
+      errorCount
+    };
+  }
+  return { listen, close, app, metrics };
+}
+export {
+  CapacityError,
+  CredentialError,
+  InputError,
+  PersistenceError,
+  buildErrorResponse,
+  buildSyncResponse,
+  createConversationsClient,
+  createFoundryHarness,
+  createIdGenerator,
+  createSessionManager,
+  extractInput,
+  generateId,
+  generateToolDefinitions,
+  getTracer,
+  initTelemetry,
+  shutdownTelemetry,
+  streamFoundryResponse
+};