@rcrsr/rill-agent-foundry 0.19.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;
@@ -266,6 +277,17 @@ export interface HandlerDescription {
 		readonly description?: string | undefined;
 		readonly defaultValue?: unknown;
 	}>;
+	/**
+	 * Handler return type annotation, formatted with the same grammar as
+	 * parameter type strings (e.g. `stream(dict(content: string)):string`).
+	 * Undefined when the handler closure has no `:T` annotation, or when the
+	 * rill-build emitting the handler is too old to expose the field.
+	 */
+	readonly returnType?: string | undefined;
+}
+export interface InitContext {
+	readonly globalVars?: Record<string, string> | undefined;
+	readonly ahiResolver?: ((agentName: string, request: RunRequest) => Promise<RunResponse>) | undefined;
 }
 export interface RunRequest {
 	readonly params?: Record<string, unknown> | undefined;
@@ -275,13 +297,25 @@ export interface RunContext {
 	readonly sessionVars?: Record<string, string> | undefined;
 	readonly onLog?: ((message: string) => void) | undefined;
 	readonly onChunk?: ((chunk: unknown) => Promise<void>) | undefined;
+	readonly signal?: AbortSignal | undefined;
 }
 export interface RunResponse {
 	readonly state: "completed" | "error";
 	readonly result: unknown;
 	readonly streamed?: boolean | undefined;
 }
+export interface AgentHandler {
+	describe(): HandlerDescription | null;
+	init(context?: InitContext): Promise<void>;
+	execute(request?: RunRequest, context?: RunContext): Promise<RunResponse>;
+	dispose(): Promise<void>;
+}
+export interface AgentManifest {
+	readonly defaultAgent: string;
+	readonly agents: ReadonlyMap<string, AgentHandler>;
+}
 export interface AgentRouter {
+	readonly manifest: AgentManifest;
 	run(agentName: string, request: RunRequest, context?: RunContext): Promise<RunResponse>;
 	describe(agentName: string): HandlerDescription | null;
 	agents(): string[];
@@ -293,50 +327,30 @@ 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.
  *
  * When debug is true, the original message is passed through verbatim.
  * When debug is false or absent, a generic message is returned based on
- * the error code per IR-10 (FOUNDRY_AGENT_DEBUG_ERRORS=false behavior).
+ * the error code (FOUNDRY_AGENT_DEBUG_ERRORS=false behavior).
  */
 export declare function buildErrorResponse(code: string, message: string, debug?: boolean): ErrorResponse;
 /**
  * Generate Foundry tool definitions from the default agent's handler descriptions.
  *
- * Only the default agent's handlers are exposed (AC-21).
+ * Only the default agent's handlers are exposed.
  * 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>;
 }
@@ -394,5 +408,46 @@ export interface FoundryHarness {
  *   GET  /metrics    — FoundryMetrics JSON
  */
 export declare function createFoundryHarness(router: AgentRouter, options?: FoundryHarnessOptions): FoundryHarness;
+export interface RillHarnessLogger {
+	info(...args: unknown[]): void;
+	warn(...args: unknown[]): void;
+	error(...args: unknown[]): void;
+}
+export interface RillCompiledPackage {
+	readonly mount: string;
+	readonly buildOutput: {
+		readonly outputPath: string;
+	};
+}
+export interface RillServeContext {
+	readonly config: Record<string, unknown>;
+	readonly logger: RillHarnessLogger;
+	readonly packages: readonly RillCompiledPackage[];
+	readonly requestedMount: string | undefined;
+	readonly args: readonly string[];
+	readonly onShutdown: (handler: () => void | Promise<void>) => void;
+	readonly onSourceChange: (handler: () => void | Promise<void>) => void;
+}
+export interface RillPostBuildContext {
+	readonly outputDir: string;
+	readonly packages: readonly RillCompiledPackage[];
+	readonly logger: RillHarnessLogger;
+}
+export interface RillHarness {
+	readonly name: string;
+	readonly postBuild?: (ctx: RillPostBuildContext) => Promise<void>;
+	readonly serve?: (ctx: RillServeContext) => Promise<number>;
+}
+/**
+ * Default export consumed by the rill CLI (`rill install --replace`,
+ * `rill run`) when this package is declared as a bundle harness. `serve`
+ * assembles a router from the bundle's compiled packages and hosts it over the
+ * Foundry Responses harness on `config.port` (default 3000).
+ */
+declare const harness: RillHarness;
+
+export {
+	harness as default,
+};
 
 export {};

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,7 +323,184 @@ function generateToolDefinitions(router) {
   ];
 }
 
+// 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 { resourceFromAttributes } from "@opentelemetry/resources";
+var sdk;
+function initTelemetry(options) {
+  if (!process.env["OTEL_EXPORTER_OTLP_ENDPOINT"]) return;
+  if (sdk !== void 0) return;
+  const resource = resourceFromAttributes({
+    "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 as routerErrorToStatus2 } from "@rcrsr/rill-agent";
+
+// ../../shared/hono-kit/src/index.ts
+import { existsSync } from "fs";
+import path from "path";
+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, 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) 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 };
+}
+function compiledPackageEntries(ctx) {
+  return ctx.packages.map((p) => ({
+    name: p.mount,
+    dir: p.buildOutput.outputPath
+  }));
+}
+function readHarnessPort(config, fallback) {
+  const p = config["port"];
+  if (typeof p === "number" && Number.isInteger(p)) return p;
+  if (typeof p === "string" && /^\d+$/.test(p)) return Number(p);
+  return fallback;
+}
+function assertCompiledHandlers(ctx) {
+  for (const pkg of ctx.packages) {
+    const handlerPath = path.join(pkg.buildOutput.outputPath, "handler.js");
+    if (!existsSync(handlerPath)) {
+      throw new Error(`missing handler file: ${handlerPath}`);
+    }
+  }
+}
+async function runRillServe(ctx, start) {
+  const handle = await start(compiledPackageEntries(ctx));
+  ctx.onShutdown(async () => {
+    await handle.close();
+  });
+  return new Promise(() => {
+  });
+}
+
 // src/stream.ts
+import { routerErrorToStatus } from "@rcrsr/rill-agent";
 var REDACTED_ERROR_MESSAGE = "Internal server error";
 var encoder = new TextEncoder();
 function sseChunk(event, data) {
@@ -321,6 +559,7 @@ function createFoundryStreamResponse(responseId, options) {
     }
   }
   function emitCompletion(controller, fullText) {
+    if (closed) return;
     controller.enqueue(
       ev("response.output_text.done", {
         type: "response.output_text.done",
@@ -345,8 +584,10 @@ function createFoundryStreamResponse(responseId, options) {
   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(
@@ -354,7 +595,7 @@ function createFoundryStreamResponse(responseId, options) {
           JSON.stringify({
             type: "error",
             sequence_number: seq++,
-            code: "SERVER_ERROR",
+            code,
             message,
             param: ""
           })
@@ -410,152 +651,6 @@ function createFoundryStreamResponse(responseId, options) {
     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 { resourceFromAttributes } from "@opentelemetry/resources";
-var sdk;
-function initTelemetry(options) {
-  if (!process.env["OTEL_EXPORTER_OTLP_ENDPOINT"]) return;
-  if (sdk !== void 0) return;
-  const resource = resourceFromAttributes({
-    "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;
@@ -583,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);
@@ -595,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;
@@ -684,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,
@@ -718,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;
@@ -813,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) => {
@@ -822,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) => {
@@ -839,7 +961,6 @@ function createFoundryHarness(router, options) {
       });
       return createFoundryStreamResponse(responseId, {
         chunks,
-        idGenerator: idGen,
         onError: (_err) => {
           errorCount++;
         },
@@ -870,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);
         }
@@ -880,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 {
@@ -926,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);
@@ -948,6 +1069,25 @@ function createFoundryHarness(router, options) {
   }
   return { listen, close, app, metrics };
 }
+
+// src/index.ts
+import { createRouter, assembleManifest } from "@rcrsr/rill-agent";
+var HARNESS_NAME = "@rcrsr/rill-agent-foundry";
+var harness = {
+  name: HARNESS_NAME,
+  postBuild: async (ctx) => {
+    assertCompiledHandlers(ctx);
+  },
+  serve: (ctx) => runRillServe(ctx, async (entries) => {
+    const router = await createRouter(await assembleManifest(entries));
+    const port = readHarnessPort(ctx.config, 3e3);
+    const server = createFoundryHarness(router, { port });
+    await server.listen();
+    ctx.logger.info(`[${HARNESS_NAME}] listening on :${port}`);
+    return server;
+  })
+};
+var index_default = harness;
 export {
   CapacityError,
   CredentialError,
@@ -959,11 +1099,11 @@ export {
   createFoundryHarness,
   createIdGenerator,
   createSessionManager,
+  index_default as default,
   extractInput,
   generateId,
   generateToolDefinitions,
   getTracer,
   initTelemetry,
-  shutdownTelemetry,
-  streamFoundryResponse
+  shutdownTelemetry
 };

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@rcrsr/rill-agent-foundry",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "rill agent foundry — Azure-hosted harness factory",
   "license": "MIT",
   "author": "Andre Bremer",
   "type": "module",
+  "rill": {
+    "role": "harness"
+  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "keywords": [
@@ -19,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.19.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.19.0"
+    "tsup": "^8.5.1"
   },
   "files": [
     "dist"
@@ -52,7 +55,7 @@
     "build": "tsup && dts-bundle-generator --config dts-bundle-generator.config.cjs && node -e \"const fs=require('fs');const walk=(d)=>fs.readdirSync(d,{withFileTypes:true}).flatMap(e=>e.isDirectory()?walk(d+'/'+e.name):[d+'/'+e.name]);const hits=walk('dist').filter(f=>fs.readFileSync(f,'utf8').includes('@rcrsr/rill-agent-hono-kit'));if(hits.length){console.error('hono-kit leak in dist:',hits);process.exit(1);}\"",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
-    "lint": "eslint --config ../../../eslint.config.js src/",
+    "lint": "oxlint --config ../../../.oxlintrc.json src/ tests/",
     "check": "pnpm run build && pnpm run test && pnpm run lint"
   }
 }