@rcrsr/rill-agent-foundry 0.20.0 → 0.21.0

package/dist/index.d.ts

@@ -250,12 +250,23 @@ export interface SessionManager {
 	 */
 	activeCount(): number;
 }
+/**
+ * Options accepted by createSessionManager.
+ */
+export interface SessionManagerOptions {
+	/**
+	 * Maximum number of concurrently open sessions. Overrides the
+	 * MAX_CONCURRENT_SESSIONS env var when provided.
+	 */
+	readonly maxConcurrentSessions?: number | undefined;
+}
 /**
  * Create a bounded pool manager for concurrent rill sessions.
  *
- * Max capacity reads from MAX_CONCURRENT_SESSIONS env var, default 10.
+ * Max capacity resolution order: options.maxConcurrentSessions, then the
+ * MAX_CONCURRENT_SESSIONS env var, then DEFAULT_MAX_SESSIONS.
  */
-export declare function createSessionManager(): SessionManager;
+export declare function createSessionManager(options?: SessionManagerOptions): SessionManager;
 export interface HandlerDescription {
 	readonly name: string;
 	readonly description?: string | undefined;
@@ -316,8 +327,15 @@ export interface AgentRouter {
  *
  * State mapping: 'completed' → 'completed', 'error' → 'failed'.
  * Result is coerced to string; errors are encoded in the response body.
+ *
+ * When `debugErrors` is false (default), a failed-state error message is
+ * redacted with the same generic message `buildErrorResponse` uses for
+ * SERVER_ERROR, so internal detail does not leak through the sync response
+ * path when it is suppressed everywhere else. The same redaction is applied
+ * to the output message `text`, since it otherwise carries the same raw
+ * failure detail. When true, the raw message is passed through verbatim.
  */
-export declare function buildSyncResponse(result: RunResponse, responseId: string): FoundryResponse;
+export declare function buildSyncResponse(result: RunResponse, responseId: string, debugErrors?: boolean): FoundryResponse;
 /**
  * Build a non-streaming JSON error response body.
  *
@@ -333,33 +351,6 @@ export declare function buildErrorResponse(code: string, message: string, debug?
  * Returns an empty array when describe() returns null.
  */
 export declare function generateToolDefinitions(router: AgentRouter): FoundryToolDefinition[];
-export interface StreamOptions {
-	readonly onError?: ((err: unknown) => void) | undefined;
-	/** IdGenerator scoped to the request for correlated message IDs. */
-	readonly idGenerator?: IdGenerator | undefined;
-	/** Session ID echoed back in x-agent-session-id response header. */
-	readonly sessionId?: string | undefined;
-	/** Invocation ID echoed back in x-agent-invocation-id response header. */
-	readonly invocationId?: string | undefined;
-	/** Pre-built x-aml-foundry-agents-metadata JSON string. */
-	readonly metadataHeader?: string | undefined;
-	/**
-	 * When true, raw error messages are forwarded to clients. When false
-	 * (default), error events emit a generic message to avoid leaking
-	 * internal details. Mirrors the harness `debugErrors` option used by
-	 * `buildErrorResponse`.
-	 */
-	readonly debugErrors?: boolean | undefined;
-}
-/**
- * Stream a Foundry Responses lifecycle via SSE.
- * Delegates to createFoundryStreamResponse for all paths.
- */
-export declare function streamFoundryResponse(_c: unknown, responseId: string, resultStream: AsyncIterable<{
-	value?: unknown;
-}>, options: StreamOptions & {
-	resultPromise?: Promise<string>;
-}): Response;
 export interface ConversationsClient {
 	saveItems(conversationId: string, items: ReadonlyArray<unknown>): Promise<void>;
 }

package/dist/index.js

@@ -80,6 +80,38 @@ function findLastUserText(items) {
   }
   return text;
 }
+function isContentPart(value) {
+  return typeof value === "object" && value !== null && value.type === "input_text" && typeof value.text === "string";
+}
+function isValidContent(content) {
+  if (typeof content === "string") {
+    return true;
+  }
+  return Array.isArray(content) && content.every(isContentPart);
+}
+function isInputItem(item) {
+  if (typeof item !== "object" || item === null) {
+    return false;
+  }
+  const type = item.type;
+  if (type === "message") {
+    const role = item.role;
+    const content = item.content;
+    return typeof role === "string" && isValidContent(content);
+  }
+  if (type === "function_call_output") {
+    const callId = item.call_id;
+    const output = item.output;
+    return typeof callId === "string" && typeof output === "string";
+  }
+  if (type === "function_call") {
+    const callId = item.call_id;
+    const name = item.name;
+    const args = item.arguments;
+    return typeof callId === "string" && typeof name === "string" && typeof args === "string";
+  }
+  return false;
+}
 function extractFunctionCallOutputs(items) {
   const callMap = /* @__PURE__ */ new Map();
   for (const item of items) {
@@ -120,6 +152,11 @@ function extractInput(input) {
   if (!Array.isArray(input) || input.length === 0) {
     throw new InputError("Missing required field: input");
   }
+  for (const item of input) {
+    if (!isInputItem(item)) {
+      throw new InputError("Invalid input item shape");
+    }
+  }
   const items = input;
   const hasFunctionCallOutput = items.some(
     (item) => item.type === "function_call_output"
@@ -136,25 +173,47 @@ function extractInput(input) {
 
 // src/session.ts
 var DEFAULT_MAX_SESSIONS = 10;
-function createSessionManager() {
+function createSessionManager(options) {
   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();
+  const parsedEnv = raw !== void 0 ? parseInt(raw, 10) : NaN;
+  const envMax = Number.isFinite(parsedEnv) && parsedEnv > 0 ? parsedEnv : DEFAULT_MAX_SESSIONS;
+  const max = options?.maxConcurrentSessions ?? envMax;
+  const activeTokens = /* @__PURE__ */ new Map();
+  const tokensBySession = /* @__PURE__ */ new Map();
   return {
     acquire(conversationId) {
-      if (active.size >= max) {
+      if (activeTokens.size >= max) {
         throw new CapacityError(max);
       }
       const sessionId = conversationId ?? generateId("sess_");
-      active.add(sessionId);
+      const token = generateId("tok_");
+      activeTokens.set(token, sessionId);
+      const tokens = tokensBySession.get(sessionId);
+      if (tokens === void 0) {
+        tokensBySession.set(sessionId, /* @__PURE__ */ new Set([token]));
+      } else {
+        tokens.add(token);
+      }
       return sessionId;
     },
     release(sessionId) {
-      active.delete(sessionId);
+      const tokens = tokensBySession.get(sessionId);
+      if (tokens === void 0) {
+        return;
+      }
+      const iterResult = tokens.values().next();
+      if (iterResult.done) {
+        return;
+      }
+      const token = iterResult.value;
+      tokens.delete(token);
+      if (tokens.size === 0) {
+        tokensBySession.delete(sessionId);
+      }
+      activeTokens.delete(token);
     },
     activeCount() {
-      return active.size;
+      return activeTokens.size;
     }
   };
 }
@@ -172,10 +231,12 @@ function coerceResult(result) {
   }
   return JSON.stringify(result);
 }
-function buildSyncResponse(result, responseId) {
+function buildSyncResponse(result, responseId, debugErrors = false) {
   const status = result.state === "completed" ? "completed" : "failed";
-  const text = coerceResult(result.result);
+  const rawText = coerceResult(result.result);
   const msgId = generateId("msg_");
+  const errorMessage = debugErrors ? rawText : GENERIC_MESSAGES["SERVER_ERROR"] ?? FALLBACK_MESSAGE;
+  const text = status === "failed" && !debugErrors ? errorMessage : rawText;
   return {
     id: responseId,
     object: "response",
@@ -196,7 +257,7 @@ function buildSyncResponse(result, responseId) {
         ]
       }
     ],
-    error: status === "failed" ? { code: "SERVER_ERROR", message: text } : null,
+    error: status === "failed" ? { code: "SERVER_ERROR", message: errorMessage } : null,
     metadata: {},
     temperature: 0,
     top_p: 0,
@@ -262,170 +323,6 @@ function generateToolDefinitions(router) {
   ];
 }
 
-// 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;
@@ -523,7 +420,7 @@ async function shutdownTelemetry() {
 import "hono";
 import { SpanStatusCode } from "@opentelemetry/api";
 import { DefaultAzureCredential } from "@azure/identity";
-import { validateParams, routerErrorToStatus } from "@rcrsr/rill-agent";
+import { validateParams, routerErrorToStatus as routerErrorToStatus2 } from "@rcrsr/rill-agent";
 
 // ../../shared/hono-kit/src/index.ts
 import { existsSync } from "fs";
@@ -543,18 +440,33 @@ function createHarnessLifecycle(options) {
     if (server !== void 0) {
       throw new Error("Server is already listening");
     }
-    return new Promise((resolve) => {
-      server = serve({ fetch: app.fetch, port }, () => {
-        options?.serverTweaks?.(server);
+    return new Promise((resolve, reject) => {
+      const started = serve({ fetch: app.fetch, port }, () => {
+        started.off("error", onError);
+        options?.serverTweaks?.(started);
         resolve();
       });
+      function onError(err) {
+        server = void 0;
+        reject(err);
+      }
+      started.once("error", onError);
+      server = started;
     });
   }
   async function close() {
-    if (server !== void 0) {
-      server.close();
-      server = void 0;
+    if (server === void 0) return;
+    const current = server;
+    server = void 0;
+    if ("closeAllConnections" in current) {
+      current.closeAllConnections();
     }
+    await new Promise((resolve, reject) => {
+      current.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
   }
   return { app, listen, close };
 }
@@ -587,6 +499,159 @@ async function runRillServe(ctx, start) {
   });
 }
 
+// src/stream.ts
+import { routerErrorToStatus } from "@rcrsr/rill-agent";
+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) {
+    if (closed) return;
+    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);
+    if (closed) return;
+    const rawMessage = err instanceof Error ? err.message : String(err);
+    const message = options.debugErrors === true ? rawMessage : REDACTED_ERROR_MESSAGE;
+    const code = routerErrorToStatus(err) === 404 ? "NOT_FOUND" : "SERVER_ERROR";
+    controller.enqueue(
+      encoder.encode(
+        sseChunk(
+          "error",
+          JSON.stringify({
+            type: "error",
+            sequence_number: seq++,
+            code,
+            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)
+  });
+}
+
 // src/harness.ts
 var DEFAULT_PORT = 8088;
 function resolvePort(options) {
@@ -613,7 +678,26 @@ function resolveConversationId(conversation) {
   if (typeof conversation === "string") {
     return conversation;
   }
-  return conversation.id;
+  if (typeof conversation === "object" && conversation !== null && typeof conversation.id === "string") {
+    return conversation.id;
+  }
+  throw new InputError("conversation.id must be a string");
+}
+function resolveMetadataResponseId(metadata) {
+  if (metadata === void 0 || metadata === null) {
+    return void 0;
+  }
+  if (typeof metadata !== "object") {
+    throw new InputError("metadata must be an object");
+  }
+  const responseId = metadata["response_id"];
+  if (responseId === void 0) {
+    return void 0;
+  }
+  if (typeof responseId !== "string") {
+    throw new InputError("metadata.response_id must be a string");
+  }
+  return responseId;
 }
 function createFoundryHarness(router, options) {
   const port = resolvePort(options);
@@ -625,7 +709,9 @@ function createFoundryHarness(router, options) {
     agentName: agentName ?? router.defaultAgent(),
     agentVersion
   });
-  const sessions = createSessionManager();
+  const sessions = createSessionManager({
+    maxConcurrentSessions: options?.maxConcurrentSessions
+  });
   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;
@@ -714,7 +800,19 @@ function createFoundryHarness(router, options) {
         500
       );
     }
-    const conversationId = resolveConversationId(body.conversation);
+    let conversationId;
+    let metadataResponseId;
+    try {
+      conversationId = resolveConversationId(body.conversation);
+      metadataResponseId = resolveMetadataResponseId(body.metadata);
+    } catch (err) {
+      errorCount++;
+      const msg = err instanceof InputError ? err.message : String(err);
+      return c.json(
+        buildErrorResponse("INVALID_REQUEST", msg, debugErrors),
+        400
+      );
+    }
     const agentName_ = extracted.targetAgent ?? router.defaultAgent();
     const validationError = validateParams(
       extracted.params,
@@ -748,10 +846,7 @@ function createFoundryHarness(router, options) {
         500
       );
     }
-    const idGen = createIdGenerator(
-      body.metadata?.["response_id"],
-      conversationId
-    );
+    const idGen = createIdGenerator(metadataResponseId, 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;
@@ -843,8 +938,7 @@ function createFoundryHarness(router, options) {
         }
       };
       const onChunk = async (chunk) => {
-        const text = typeof chunk === "string" ? chunk : JSON.stringify(chunk);
-        pushChunk(text);
+        pushChunk(coerceResult(chunk));
       };
       const streamContext = { ...runContext, onChunk };
       router.run(agentName_, runRequest, streamContext).then((result) => {
@@ -852,10 +946,8 @@ function createFoundryHarness(router, options) {
         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);
-          }
+          const text = coerceResult(result.result);
+          if (text !== "") pushChunk(text);
         }
         endChunks();
       }).catch((err) => {
@@ -869,7 +961,6 @@ function createFoundryHarness(router, options) {
       });
       return createFoundryStreamResponse(responseId, {
         chunks,
-        idGenerator: idGen,
         onError: (_err) => {
           errorCount++;
         },
@@ -900,7 +991,7 @@ function createFoundryHarness(router, options) {
         span.end();
         errorCount++;
         const msg = err instanceof Error ? err.message : String(err);
-        const status = routerErrorToStatus(err);
+        const status = routerErrorToStatus2(err);
         if (status === 404) {
           return c.json(buildErrorResponse("NOT_FOUND", msg, debugErrors), 404);
         }
@@ -910,7 +1001,7 @@ function createFoundryHarness(router, options) {
         );
       }
       span.end();
-      const response = buildSyncResponse(result, responseId);
+      const response = buildSyncResponse(result, responseId, debugErrors);
       const shouldStore = body.store === true;
       if (shouldStore && conversationId !== void 0 && conversationsClient !== void 0) {
         try {
@@ -956,11 +1047,11 @@ function createFoundryHarness(router, options) {
           );
         }
       } catch (err) {
-        if (!(err instanceof CredentialError)) {
-          const message = err instanceof Error ? err.message : String(err);
-          throw new CredentialError(message);
+        if (err instanceof CredentialError) {
+          throw err;
         }
-        process.exit(1);
+        const message = err instanceof Error ? err.message : String(err);
+        throw new CredentialError(message);
       }
     }
     await lifecycle.listen(port);
@@ -1014,6 +1105,5 @@ export {
   generateToolDefinitions,
   getTracer,
   initTelemetry,
-  shutdownTelemetry,
-  streamFoundryResponse
+  shutdownTelemetry
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rcrsr/rill-agent-foundry",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "rill agent foundry — Azure-hosted harness factory",
   "license": "MIT",
   "author": "Andre Bremer",
@@ -22,19 +22,19 @@
     "@opentelemetry/api": "^1.9.0"
   },
   "dependencies": {
-    "@azure/identity": "^4.10.0",
-    "@hono/node-server": "^2.0.1",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.216.0",
-    "@opentelemetry/resources": "^2.7.1",
-    "@opentelemetry/sdk-node": "^0.216.0",
-    "hono": "^4.12.16",
-    "@rcrsr/rill-agent": "~0.20.0"
+    "@azure/identity": "^4.13.2",
+    "@hono/node-server": "^2.1.1",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.222.0",
+    "@opentelemetry/resources": "^2.11.0",
+    "@opentelemetry/sdk-node": "^0.222.0",
+    "@rcrsr/rill-agent": "~0.21.0",
+    "hono": "^4.13.7"
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.0",
+    "@rcrsr/rill-agent-hono-kit": "^0.21.0",
     "dts-bundle-generator": "^9.5.1",
-    "tsup": "^8.5.0",
-    "@rcrsr/rill-agent-hono-kit": "^0.20.0"
+    "tsup": "^8.5.1"
   },
   "files": [
     "dist"