@cuylabs/agent-foundry-hosting 4.8.0 → 4.9.0

package/README.md

@@ -8,6 +8,7 @@ lower-level Agent Server protocol packages:
 
 ```text
 @cuylabs/agent-foundry-agentserver-invocations  -> azure-ai-agentserver-invocations
+@cuylabs/agent-foundry-agentserver-responses    -> azure-ai-agentserver-responses
 @cuylabs/agent-foundry-hosting                  -> agent-framework-foundry-hosting
 ```
 
@@ -31,6 +32,23 @@ await runInvocationsServer({
 
 ## Responses
 
-Responses hosting is not part of this package yet. Add it as an explicit
-subpath once the TypeScript Responses protocol package exists, following the
-same split used here: protocol host first, framework adapter second.
+```ts
+import { runResponsesServer } from "@cuylabs/agent-foundry-agentserver-responses";
+import { createResponsesHandlerForAgent } from "@cuylabs/agent-foundry-hosting/responses";
+import {
+  createAgentServerAdapter,
+  InProcessAgentServer,
+} from "@cuylabs/agent-server";
+
+const server = new InProcessAgentServer(createAgentServerAdapter(myAgent));
+
+await runResponsesServer({
+  handler: createResponsesHandlerForAgent(server),
+  port: 8088,
+});
+```
+
+The Responses bridge starts an `agent-server` turn for each create-response
+request, maps `agent-core` text/tool/error/completion events into Responses
+stream events, and leaves HTTP, SSE framing, IDs, storage, and platform headers
+to `@cuylabs/agent-foundry-agentserver-responses`.

package/dist/chunk-BK7IBLJL.js

@@ -0,0 +1,61 @@
+// src/invocations/async-queue.ts
+var AsyncQueue = class {
+  values = [];
+  waiters = [];
+  closed = false;
+  push(value, coalesce) {
+    if (this.closed) {
+      return;
+    }
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      waiter({ value, done: false });
+      return;
+    }
+    if (coalesce && this.values.length > 0) {
+      const lastIndex = this.values.length - 1;
+      const merged = coalesce(this.values[lastIndex], value);
+      if (merged !== void 0) {
+        this.values[lastIndex] = merged;
+        return;
+      }
+    }
+    this.values.push(value);
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    for (const waiter of this.waiters.splice(0)) {
+      waiter({ value: void 0, done: true });
+    }
+  }
+  reset() {
+    this.values = [];
+    this.closed = false;
+  }
+  async *[Symbol.asyncIterator]() {
+    while (true) {
+      if (this.values.length > 0) {
+        const value = this.values.shift();
+        yield value;
+        continue;
+      }
+      if (this.closed) {
+        return;
+      }
+      const result = await new Promise((resolve) => {
+        this.waiters.push(resolve);
+      });
+      if (result.done) {
+        return;
+      }
+      yield result.value;
+    }
+  }
+};
+
+export {
+  AsyncQueue
+};

package/dist/chunk-M7O23JGF.js

@@ -0,0 +1,493 @@
+import {
+  AsyncQueue
+} from "./chunk-BK7IBLJL.js";
+
+// src/responses/index.ts
+import {
+  ResponsesHandler,
+  TextResponse
+} from "@cuylabs/agent-foundry-agentserver-responses";
+
+// src/responses/events.ts
+import {
+  createResponseObject,
+  newId,
+  newOutputMessageItemId
+} from "@cuylabs/agent-foundry-agentserver-responses";
+function createResponsesEventState(options) {
+  return {
+    responseId: options.responseId,
+    request: options.request,
+    createdAt: options.createdAt,
+    outputIndex: 0,
+    contentIndex: 0,
+    fullText: "",
+    outputItems: [],
+    terminal: false
+  };
+}
+function createResponseLifecycleEvents(state) {
+  const response = createResponseObject({
+    id: state.responseId,
+    request: state.request,
+    status: "queued",
+    createdAt: state.createdAt
+  });
+  state.response = response;
+  const inProgress = { ...response, status: "in_progress" };
+  state.response = inProgress;
+  return [
+    { type: "response.created", response },
+    { type: "response.in_progress", response: inProgress }
+  ];
+}
+function agentEventToResponseEvents(event, state) {
+  switch (event.type) {
+    case "text-start":
+      return ensureMessageStarted(state);
+    case "text-delta":
+      return emitTextDelta(event.text, state);
+    case "text-end":
+      return [];
+    case "tool-start":
+      return emitToolCallStarted(event, state);
+    case "tool-result":
+      return emitToolCallOutput(event.toolCallId, event.result, state);
+    case "tool-error":
+      return emitToolCallOutput(
+        event.toolCallId,
+        { error: event.error },
+        state
+      );
+    case "approval-request":
+      return emitAgentEventOutput("approval_required", event.request, state);
+    case "human-input-request":
+      return emitAgentEventOutput("input_required", event.request, state);
+    case "error":
+      return finalizeFailed(event.error.message, state);
+    case "complete":
+      return finalizeCompleted(event.output, event.usage, state);
+    default:
+      return [];
+  }
+}
+function finalizeCompleted(output, usage, state) {
+  if (state.terminal) {
+    return [];
+  }
+  const events = [];
+  if (output && !state.fullText) {
+    events.push(...emitTextDelta(output, state));
+  }
+  events.push(...finishMessage(state));
+  const response = {
+    ...state.response ?? createResponseObject({
+      id: state.responseId,
+      request: state.request,
+      status: "in_progress",
+      createdAt: state.createdAt
+    }),
+    status: "completed",
+    output: state.outputItems,
+    error: null,
+    usage: usage ? {
+      input_tokens: usage.inputTokens,
+      output_tokens: usage.outputTokens,
+      total_tokens: usage.totalTokens
+    } : void 0
+  };
+  state.response = response;
+  state.terminal = true;
+  events.push({ type: "response.completed", response });
+  return events;
+}
+function finalizeFailed(message, state) {
+  if (state.terminal) {
+    return [];
+  }
+  const response = {
+    ...state.response ?? createResponseObject({
+      id: state.responseId,
+      request: state.request,
+      status: "in_progress",
+      createdAt: state.createdAt
+    }),
+    status: "failed",
+    error: {
+      code: "server_error",
+      message,
+      type: "server_error"
+    }
+  };
+  state.response = response;
+  state.terminal = true;
+  return [{ type: "response.failed", response }];
+}
+function finalizeCancelled(state) {
+  if (state.terminal) {
+    return [];
+  }
+  const response = {
+    ...state.response ?? createResponseObject({
+      id: state.responseId,
+      request: state.request,
+      status: "in_progress",
+      createdAt: state.createdAt
+    }),
+    status: "cancelled",
+    error: null
+  };
+  state.response = response;
+  state.terminal = true;
+  return [{ type: "response.cancelled", response }];
+}
+function coalesceResponseAgentEvents(previous, next) {
+  if (previous.type === "text-delta" && next.type === "text-delta") {
+    return {
+      type: "text-delta",
+      text: previous.text + next.text
+    };
+  }
+  return void 0;
+}
+function emitTextDelta(text, state) {
+  if (!text) {
+    return [];
+  }
+  const events = ensureMessageStarted(state);
+  state.fullText += text;
+  events.push({
+    type: "response.output_text.delta",
+    output_index: state.messageOutputIndex ?? 0,
+    content_index: 0,
+    item_id: state.message?.id,
+    delta: text
+  });
+  return events;
+}
+function ensureMessageStarted(state) {
+  if (state.message) {
+    return [];
+  }
+  const part = {
+    type: "output_text",
+    text: "",
+    annotations: []
+  };
+  const item = {
+    id: newOutputMessageItemId(state.responseId),
+    type: "message",
+    status: "in_progress",
+    role: "assistant",
+    content: [part]
+  };
+  const outputIndex = appendOutputItem(state, item);
+  state.message = item;
+  state.messageOutputIndex = outputIndex;
+  return [
+    {
+      type: "response.output_item.added",
+      output_index: outputIndex,
+      item
+    },
+    {
+      type: "response.content_part.added",
+      output_index: outputIndex,
+      content_index: 0,
+      item_id: item.id,
+      part
+    }
+  ];
+}
+function finishMessage(state) {
+  const message = state.message;
+  if (!message) {
+    return [];
+  }
+  const outputIndex = state.messageOutputIndex ?? 0;
+  const part = message.content?.[0];
+  if (part?.type === "output_text") {
+    part.text = state.fullText;
+  }
+  message.status = "completed";
+  return [
+    {
+      type: "response.output_text.done",
+      output_index: outputIndex,
+      content_index: 0,
+      item_id: message.id,
+      text: state.fullText
+    },
+    {
+      type: "response.content_part.done",
+      output_index: outputIndex,
+      content_index: 0,
+      item_id: message.id,
+      part
+    },
+    {
+      type: "response.output_item.done",
+      output_index: outputIndex,
+      item: message
+    }
+  ];
+}
+function emitToolCallStarted(event, state) {
+  const item = {
+    id: event.toolCallId || newId("fc", state.responseId),
+    type: "function_call",
+    status: "in_progress",
+    call_id: event.toolCallId,
+    name: event.toolName,
+    arguments: jsonText(event.input)
+  };
+  const outputIndex = appendOutputItem(state, item);
+  return [
+    {
+      type: "response.output_item.added",
+      output_index: outputIndex,
+      item
+    }
+  ];
+}
+function emitToolCallOutput(callId, result, state) {
+  const item = {
+    id: newId("fcout", state.responseId),
+    type: "function_call_output",
+    status: "completed",
+    call_id: callId,
+    output: jsonText(result)
+  };
+  const outputIndex = appendOutputItem(state, item);
+  return [
+    {
+      type: "response.output_item.done",
+      output_index: outputIndex,
+      item
+    }
+  ];
+}
+function emitAgentEventOutput(type, payload, state) {
+  const item = {
+    id: newId("item", state.responseId),
+    type,
+    status: "completed",
+    payload
+  };
+  const outputIndex = appendOutputItem(state, item);
+  return [
+    {
+      type: "response.output_item.done",
+      output_index: outputIndex,
+      item
+    }
+  ];
+}
+function appendOutputItem(state, item) {
+  const outputIndex = state.outputItems.length;
+  state.outputItems.push(item);
+  state.outputIndex = outputIndex + 1;
+  return outputIndex;
+}
+function jsonText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+// src/responses/index.ts
+var DEFAULT_EMPTY_INPUT_MESSAGE = "Send a non-empty input string or message item to create a response.";
+function createResponsesHandlerForAgent(server, options = {}) {
+  return new AgentCoreResponsesHandler(server, options);
+}
+var AgentCoreResponsesHandler = class extends ResponsesHandler {
+  constructor(server, options) {
+    super();
+    this.server = server;
+    this.options = options;
+  }
+  async handle(request, context, signal) {
+    const message = (await context.getInputText()).trim();
+    if (!message) {
+      return new TextResponse(context, request, {
+        text: this.options.emptyInputMessage ?? DEFAULT_EMPTY_INPUT_MESSAGE
+      });
+    }
+    return this.streamAgentTurn(request, context, signal, message);
+  }
+  async close() {
+    await this.server.close?.();
+  }
+  async *streamAgentTurn(request, context, signal, message) {
+    const startedAt = Date.now();
+    const state = createResponsesEventState({
+      responseId: context.responseId,
+      request,
+      createdAt: context.createdAt
+    });
+    for (const event of createResponseLifecycleEvents(state)) {
+      yield event;
+    }
+    let turnId;
+    let unsubscribe;
+    let abortListener;
+    try {
+      const turn = await this.server.startTurn(context.sessionId, message, {
+        ...typeof request.instructions === "string" ? { system: request.instructions } : {}
+      });
+      turnId = turn.id;
+      const queue = new AsyncQueue();
+      const deliveredSequences = /* @__PURE__ */ new Set();
+      unsubscribe = this.server.subscribe(
+        (notification) => {
+          if (notification.type === "turn/event") {
+            deliveredSequences.add(notification.sequence);
+            queue.push(
+              {
+                kind: "event",
+                event: notification.event,
+                sequence: notification.sequence
+              },
+              coalesceQueueItems
+            );
+          } else if (notification.type === "turn/completed") {
+            queue.push({ kind: "completed", turn: notification.turn });
+            queue.close();
+          }
+        },
+        { turnId: turn.id }
+      );
+      abortListener = () => {
+        this.server.interruptTurn(turn.id);
+      };
+      signal.addEventListener("abort", abortListener, { once: true });
+      const existing = this.server.getTurn(turn.id);
+      for (const record of existing?.events ?? []) {
+        if (deliveredSequences.has(record.sequence)) {
+          continue;
+        }
+        deliveredSequences.add(record.sequence);
+        queue.push(
+          {
+            kind: "event",
+            event: record.event,
+            sequence: record.sequence
+          },
+          coalesceQueueItems
+        );
+      }
+      if (existing && existing.status !== "running") {
+        queue.push({ kind: "completed", turn: existing });
+        queue.close();
+      }
+      for await (const item of queue) {
+        if (item.kind === "event") {
+          for (const event of agentEventToResponseEvents(item.event, state)) {
+            yield event;
+          }
+          continue;
+        }
+        if (item.turn.status === "completed") {
+          for (const event of finalizeCompleted(
+            item.turn.output,
+            item.turn.usage,
+            state
+          )) {
+            yield event;
+          }
+          await this.fireOnTurnComplete({
+            responseId: context.responseId,
+            sessionId: context.sessionId,
+            turnId: item.turn.id,
+            fullText: state.fullText,
+            durationMs: Date.now() - startedAt,
+            status: "ok"
+          });
+        } else if (item.turn.status === "interrupted" || signal.aborted) {
+          for (const event of finalizeCancelled(state)) {
+            yield event;
+          }
+          await this.fireOnTurnComplete({
+            responseId: context.responseId,
+            sessionId: context.sessionId,
+            turnId: item.turn.id,
+            fullText: state.fullText,
+            durationMs: Date.now() - startedAt,
+            status: "cancelled"
+          });
+        } else {
+          const error = item.turn.error ?? "Agent turn failed";
+          for (const event of finalizeFailed(error, state)) {
+            yield event;
+          }
+          await this.fireOnTurnComplete({
+            responseId: context.responseId,
+            sessionId: context.sessionId,
+            turnId: item.turn.id,
+            fullText: state.fullText,
+            durationMs: Date.now() - startedAt,
+            status: "error",
+            error
+          });
+        }
+      }
+    } catch (error) {
+      const message2 = error instanceof Error ? error.message : String(error);
+      this.options.logger?.error("responses turn failed", {
+        responseId: context.responseId,
+        sessionId: context.sessionId,
+        ...turnId ? { turnId } : {},
+        error: message2
+      });
+      for (const event of finalizeFailed(message2, state)) {
+        yield event;
+      }
+      await this.fireOnTurnComplete({
+        responseId: context.responseId,
+        sessionId: context.sessionId,
+        ...turnId ? { turnId } : {},
+        fullText: state.fullText,
+        durationMs: Date.now() - startedAt,
+        status: "error",
+        error: message2
+      });
+    } finally {
+      if (abortListener) {
+        signal.removeEventListener("abort", abortListener);
+      }
+      unsubscribe?.();
+    }
+  }
+  async fireOnTurnComplete(summary) {
+    if (!this.options.onTurnComplete) {
+      return;
+    }
+    try {
+      await this.options.onTurnComplete(summary);
+    } catch {
+    }
+  }
+};
+function coalesceQueueItems(previous, next) {
+  if (previous.kind !== "event" || next.kind !== "event") {
+    return void 0;
+  }
+  const event = coalesceResponseAgentEvents(previous.event, next.event);
+  return event ? { kind: "event", event } : void 0;
+}
+
+export {
+  createResponsesEventState,
+  createResponseLifecycleEvents,
+  agentEventToResponseEvents,
+  finalizeCompleted,
+  finalizeFailed,
+  finalizeCancelled,
+  coalesceResponseAgentEvents,
+  createResponsesHandlerForAgent
+};

package/dist/{chunk-D5U6N54E.js → chunk-SJJFHS66.js}

@@ -1,3 +1,7 @@
+import {
+  AsyncQueue
+} from "./chunk-BK7IBLJL.js";
+
 // src/invocations/index.ts
 import {
   InvocationHandler,
@@ -7,64 +11,6 @@ import {
   writeErrorFrame
 } from "@cuylabs/agent-foundry-agentserver-invocations";
 
-// src/invocations/async-queue.ts
-var AsyncQueue = class {
-  values = [];
-  waiters = [];
-  closed = false;
-  push(value, coalesce) {
-    if (this.closed) {
-      return;
-    }
-    const waiter = this.waiters.shift();
-    if (waiter) {
-      waiter({ value, done: false });
-      return;
-    }
-    if (coalesce && this.values.length > 0) {
-      const lastIndex = this.values.length - 1;
-      const merged = coalesce(this.values[lastIndex], value);
-      if (merged !== void 0) {
-        this.values[lastIndex] = merged;
-        return;
-      }
-    }
-    this.values.push(value);
-  }
-  close() {
-    if (this.closed) {
-      return;
-    }
-    this.closed = true;
-    for (const waiter of this.waiters.splice(0)) {
-      waiter({ value: void 0, done: true });
-    }
-  }
-  reset() {
-    this.values = [];
-    this.closed = false;
-  }
-  async *[Symbol.asyncIterator]() {
-    while (true) {
-      if (this.values.length > 0) {
-        const value = this.values.shift();
-        yield value;
-        continue;
-      }
-      if (this.closed) {
-        return;
-      }
-      const result = await new Promise((resolve) => {
-        this.waiters.push(resolve);
-      });
-      if (result.done) {
-        return;
-      }
-      yield result.value;
-    }
-  }
-};
-
 // src/invocations/events.ts
 import {
   sseFrame
@@ -602,7 +548,6 @@ var AgentCoreInvocationHandler = class extends InvocationHandler {
 };
 
 export {
-  AsyncQueue,
   agentEventToSseFrame,
   coalesceAgentEvents,
   InvocationBroker,

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { CreateInvocationsHandlerOptions, TurnSummary, createInvocationsHandlerForAgent } from './invocations/index.js';
+export { CreateResponsesHandlerOptions, ResponsesTurnSummary, createResponsesHandlerForAgent } from './responses/index.js';
 import '@cuylabs/agent-server';
 import '@cuylabs/agent-foundry-agentserver-invocations';
 import '@cuylabs/agent-core';
+import '@cuylabs/agent-foundry-agentserver-responses';

package/dist/index.js

@@ -1,6 +1,11 @@
 import {
   createInvocationsHandlerForAgent
-} from "./chunk-D5U6N54E.js";
+} from "./chunk-SJJFHS66.js";
+import {
+  createResponsesHandlerForAgent
+} from "./chunk-M7O23JGF.js";
+import "./chunk-BK7IBLJL.js";
 export {
-  createInvocationsHandlerForAgent
+  createInvocationsHandlerForAgent,
+  createResponsesHandlerForAgent
 };

package/dist/invocations/index.js

@@ -1,10 +1,12 @@
 import {
-  AsyncQueue,
   InvocationBroker,
   agentEventToSseFrame,
   coalesceAgentEvents,
   createInvocationsHandlerForAgent
-} from "../chunk-D5U6N54E.js";
+} from "../chunk-SJJFHS66.js";
+import {
+  AsyncQueue
+} from "../chunk-BK7IBLJL.js";
 export {
   AsyncQueue,
   InvocationBroker,

package/dist/responses/index.d.ts

@@ -0,0 +1,59 @@
+import { InProcessAgentServer } from '@cuylabs/agent-server';
+import { CreateResponse, OutputItem, ResponseObject, ResponseStreamEvent, ResponsesHandler } from '@cuylabs/agent-foundry-agentserver-responses';
+import { AgentEvent, TokenUsage } from '@cuylabs/agent-core';
+
+interface ResponsesEventState {
+    responseId: string;
+    request: CreateResponse;
+    createdAt: number;
+    outputIndex: number;
+    contentIndex: number;
+    fullText: string;
+    message?: OutputItem;
+    messageOutputIndex?: number;
+    outputItems: OutputItem[];
+    response?: ResponseObject;
+    terminal: boolean;
+}
+declare function createResponsesEventState(options: {
+    responseId: string;
+    request: CreateResponse;
+    createdAt: number;
+}): ResponsesEventState;
+declare function createResponseLifecycleEvents(state: ResponsesEventState): ResponseStreamEvent[];
+declare function agentEventToResponseEvents(event: AgentEvent, state: ResponsesEventState): ResponseStreamEvent[];
+declare function finalizeCompleted(output: string | undefined, usage: TokenUsage | undefined, state: ResponsesEventState): ResponseStreamEvent[];
+declare function finalizeFailed(message: string, state: ResponsesEventState): ResponseStreamEvent[];
+declare function finalizeCancelled(state: ResponsesEventState): ResponseStreamEvent[];
+declare function coalesceResponseAgentEvents(previous: AgentEvent, next: AgentEvent): AgentEvent | undefined;
+
+/**
+ * @cuylabs/agent-foundry-hosting/responses
+ *
+ * Bridge from a `@cuylabs/agent-server` `InProcessAgentServer` to the
+ * Foundry Responses protocol.
+ */
+
+interface CreateResponsesHandlerOptions {
+    emptyInputMessage?: string;
+    logger?: ResponsesBridgeLogger;
+    onTurnComplete?: (summary: ResponsesTurnSummary) => void | Promise<void>;
+}
+interface ResponsesBridgeLogger {
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+    debug?(message: string, meta?: Record<string, unknown>): void;
+}
+interface ResponsesTurnSummary {
+    responseId: string;
+    sessionId: string;
+    turnId?: string;
+    fullText: string;
+    durationMs: number;
+    status: "ok" | "error" | "cancelled";
+    error?: string;
+}
+declare function createResponsesHandlerForAgent(server: InProcessAgentServer, options?: CreateResponsesHandlerOptions): ResponsesHandler;
+
+export { type CreateResponsesHandlerOptions, type ResponsesBridgeLogger, type ResponsesEventState, type ResponsesTurnSummary, agentEventToResponseEvents, coalesceResponseAgentEvents, createResponseLifecycleEvents, createResponsesEventState, createResponsesHandlerForAgent, finalizeCancelled, finalizeCompleted, finalizeFailed };

package/dist/responses/index.js

@@ -0,0 +1,21 @@
+import {
+  agentEventToResponseEvents,
+  coalesceResponseAgentEvents,
+  createResponseLifecycleEvents,
+  createResponsesEventState,
+  createResponsesHandlerForAgent,
+  finalizeCancelled,
+  finalizeCompleted,
+  finalizeFailed
+} from "../chunk-M7O23JGF.js";
+import "../chunk-BK7IBLJL.js";
+export {
+  agentEventToResponseEvents,
+  coalesceResponseAgentEvents,
+  createResponseLifecycleEvents,
+  createResponsesEventState,
+  createResponsesHandlerForAgent,
+  finalizeCancelled,
+  finalizeCompleted,
+  finalizeFailed
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuylabs/agent-foundry-hosting",
-  "version": "4.8.0",
+  "version": "4.9.0",
   "description": "Foundry Hosting integration for @cuylabs/agent-core (agent-core ↔ Invocations protocol bridge; mirrors agent-framework-foundry-hosting)",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,6 +15,11 @@
       "types": "./dist/invocations/index.d.ts",
       "import": "./dist/invocations/index.js",
       "default": "./dist/invocations/index.js"
+    },
+    "./responses": {
+      "types": "./dist/responses/index.d.ts",
+      "import": "./dist/responses/index.js",
+      "default": "./dist/responses/index.js"
     }
   },
   "files": [
@@ -27,14 +32,16 @@
     "tsup": "^8.0.0",
     "typescript": "^5.7.0",
     "vitest": "^4.0.18",
-    "@cuylabs/agent-core": "^4.8.0",
-    "@cuylabs/agent-server": "^4.8.0",
-    "@cuylabs/agent-foundry-agentserver-invocations": "^4.8.0"
+    "@cuylabs/agent-core": "^4.9.0",
+    "@cuylabs/agent-server": "^4.9.0",
+    "@cuylabs/agent-foundry-agentserver-responses": "^4.9.0",
+    "@cuylabs/agent-foundry-agentserver-invocations": "^4.9.0"
   },
   "peerDependencies": {
-    "@cuylabs/agent-core": "^4.8.0",
-    "@cuylabs/agent-server": "^4.8.0",
-    "@cuylabs/agent-foundry-agentserver-invocations": "^4.8.0"
+    "@cuylabs/agent-core": "^4.9.0",
+    "@cuylabs/agent-server": "^4.9.0",
+    "@cuylabs/agent-foundry-agentserver-responses": "^4.9.0",
+    "@cuylabs/agent-foundry-agentserver-invocations": "^4.9.0"
   },
   "keywords": [
     "agent",
@@ -58,8 +65,8 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/invocations/index.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts src/invocations/index.ts --format esm --dts --watch",
+    "build": "tsup src/index.ts src/invocations/index.ts src/responses/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/invocations/index.ts src/responses/index.ts --format esm --dts --watch",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",