fixed more pr comments

Author: pipewrk

examples/agentic/client/src/app/transport-helpers.ts

@@ -148,11 +148,12 @@ const applyModelIdChange = (
   },
   modelId: string | null,
 ) => {
-  input.setModelId(modelId);
+  const normalized = modelId === "" ? null : modelId;
+  input.setModelId(normalized);
   updateTransportData(input, {
     adapterSource: input.adapterSource,
     providerId: input.providerId,
-    modelId,
+    modelId: normalized,
   });
   return true;
 };

examples/agentic/client/src/components/assistant-ui/tool-fallback.tsx

@@ -39,12 +39,22 @@ const ToolFallbackImpl = ({ toolName, argsText, result, status }: ToolFallbackPr
           {isCancelled ? "Cancelled tool: " : "Used tool: "}
           <b>{toolName}</b>
         </p>
-        <Button onClick={() => setIsCollapsed(!isCollapsed)} size="icon" variant="ghost">
+        <Button
+          onClick={() => setIsCollapsed(!isCollapsed)}
+          size="icon"
+          variant="ghost"
+          aria-expanded={!isCollapsed}
+          aria-controls="tool-fallback-content"
+          aria-label={isCollapsed ? "Expand tool details" : "Collapse tool details"}
+        >
           {isCollapsed ? <ChevronUpIcon /> : <ChevronDownIcon />}
         </Button>
       </div>
       {!isCollapsed && (
-        <div className="aui-tool-fallback-content flex flex-col gap-2 border-t pt-2">
+        <div
+          id="tool-fallback-content"
+          className="aui-tool-fallback-content flex flex-col gap-2 border-t pt-2"
+        >
           {cancelledReason && (
             <div className="aui-tool-fallback-cancelled-root px-4">
               <p className="aui-tool-fallback-cancelled-header font-semibold text-muted-foreground">

examples/agentic/server/index.ts

@@ -315,36 +315,43 @@ const applyMissingInputError = (input: RunOutcomeInput) => {
 };
 
 const runChatRequest = (socket: ServerWebSocket<SocketData>, message: ClientChatRequest) => {
-  const model = selectModel(toModelSelection({ data: message.data, tokens: socket.data.tokens }));
-  const coreMessages = toCoreMessages(message.messages);
-  const text = readUserInputText(coreMessages);
-  const config = message.data?.agentConfig;
-  const context = buildAgentContext({ config, context: message.data?.context ?? null });
-  const threadId = message.data?.threadId ?? message.chatId;
-
-  const writer = createWebSocketUiWriter(socket, message.requestId);
-  const eventStream = createAiSdkInteractionEventStream({ writer });
-
   const outcomeInput: RunOutcomeInput = { socket, requestId: message.requestId };
-  if (!text) {
-    return applyMissingInputError(outcomeInput);
+  try {
+    const model = selectModel(toModelSelection({ data: message.data, tokens: socket.data.tokens }));
+    const coreMessages = toCoreMessages(message.messages);
+    const text = readUserInputText(coreMessages);
+    const config = message.data?.agentConfig;
+    const context = buildAgentContext({ config, context: message.data?.context ?? null });
+    const threadId = message.data?.threadId ?? message.chatId;
+
+    const writer = createWebSocketUiWriter(socket, message.requestId);
+    const eventStream = createAiSdkInteractionEventStream({ writer });
+
+    if (!text) {
+      return applyMissingInputError(outcomeInput);
+    }
+    const runtime = createAgentRuntime({
+      model,
+      config,
+      subagents: message.data?.subagents,
+    });
+    const runResult = runtime.stream({
+      text,
+      context: context ?? undefined,
+      threadId,
+      eventStream,
+      interactionId: message.chatId,
+      correlationId: message.requestId,
+    });
+    const handlerInput = createRunChatHandlerInput(outcomeInput, runResult);
+
+    return maybeTry(
+      bindFirst(applyRunError, outcomeInput),
+      bindFirst(handleRunResult, handlerInput),
+    );
+  } catch (error) {
+    return applyRunError(outcomeInput, error);
   }
-  const runtime = createAgentRuntime({
-    model,
-    config,
-    subagents: message.data?.subagents,
-  });
-  const runResult = runtime.stream({
-    text,
-    context: context ?? undefined,
-    threadId,
-    eventStream,
-    interactionId: message.chatId,
-    correlationId: message.requestId,
-  });
-  const handlerInput = createRunChatHandlerInput(outcomeInput, runResult);
-
-  return maybeTry(bindFirst(applyRunError, outcomeInput), bindFirst(handleRunResult, handlerInput));
 };
 
 const handleAssistantTransport = (req: Request): MaybePromise<Response> => {
@@ -362,30 +369,42 @@ const handleAssistantBodyOrError = (body: unknown) => {
   return handleAssistantBody(body);
 };
 
+const reportAssistantError = (error: unknown) => {
+  console.error(error);
+  return true;
+};
+
 const handleAssistantBody = (body: unknown): Response => {
   const parsed = parseAssistantTransportRequest(body);
   if (!parsed) {
     return new Response("Invalid assistant transport payload", { status: 400 });
   }
-
-  const model = selectModel(toModelSelection({ data: parsed.data }));
-  const coreMessages = toCoreMessagesFromAssistantCommands(parsed.commands);
-  const chatId = parsed.data?.chatId ?? crypto.randomUUID();
-
-  const streamAdapter = createAssistantUiInteractionStream({ includeReasoning: true });
-  const eventStream = streamAdapter.eventStream;
-
-  const recipeId = resolveInteractionRecipeId(parsed.data?.recipeId);
-  const runResult = runInteractionRequest({
-    recipeId,
-    model,
-    messages: coreMessages,
-    eventStream,
-    interactionId: chatId,
-    correlationId: chatId,
-  });
-  finalizeAssistantRun(runResult, streamAdapter.controller);
-  return AssistantStream.toResponse(streamAdapter.stream, new DataStreamEncoder());
+  let streamAdapter: ReturnType<typeof createAssistantUiInteractionStream> | null = null;
+
+  try {
+    const model = selectModel(toModelSelection({ data: parsed.data }));
+    const coreMessages = toCoreMessagesFromAssistantCommands(parsed.commands);
+    const chatId = parsed.data?.chatId ?? crypto.randomUUID();
+
+    streamAdapter = createAssistantUiInteractionStream({ includeReasoning: true });
+    const eventStream = streamAdapter.eventStream;
+
+    const recipeId = resolveInteractionRecipeId(parsed.data?.recipeId);
+    const runResult = runInteractionRequest({
+      recipeId,
+      model,
+      messages: coreMessages,
+      eventStream,
+      interactionId: chatId,
+      correlationId: chatId,
+    });
+    finalizeAssistantRun(runResult, streamAdapter.controller);
+    return AssistantStream.toResponse(streamAdapter.stream, new DataStreamEncoder());
+  } catch (error) {
+    reportAssistantError(error);
+    closeAssistantControllerIfPresent(streamAdapter ? streamAdapter.controller : null);
+    return new Response("Internal server error", { status: 500 });
+  }
 };
 
 const readRequestBody = (req: Request): MaybePromise<unknown> =>
@@ -400,6 +419,13 @@ const closeAssistantController = (controller: { close: () => void }) => {
   return true;
 };
 
+const closeAssistantControllerIfPresent = (controller: { close: () => void } | null) => {
+  if (!controller) {
+    return null;
+  }
+  return closeAssistantController(controller);
+};
+
 const ignoreAssistantRunError = (_error: unknown) => null;
 
 const finalizeAssistantRun = (run: MaybePromise<unknown>, controller: { close: () => void }) =>

examples/components/model-catalog.ts

@@ -398,9 +398,31 @@ const withAuthHeader = (token: string, headers: HeadersInit) => ({
   Authorization: `Bearer ${token}`,
 });
 
-const fetchOpenAiModels = async (token: string): Promise<ModelEntry[]> => {
+const MODEL_CATALOG_TIMEOUT_MS = 8000;
+
+const abortControllerAbort = (controller: AbortController) => {
+  controller.abort();
+  return true;
+};
+
+const startAbortTimer = (controller: AbortController, timeoutMs: number) =>
+  setTimeout(bindFirst(abortControllerAbort, controller), timeoutMs);
+
+const clearAbortTimer = (timerId: ReturnType<typeof setTimeout>) => {
+  clearTimeout(timerId);
+  return true;
+};
+
+const createTimeoutSignal = (timeoutMs: number) => {
+  const controller = new AbortController();
+  const timerId = startAbortTimer(controller, timeoutMs);
+  return { signal: controller.signal, timerId };
+};
+
+const fetchOpenAiModels = async (token: string, signal?: AbortSignal): Promise<ModelEntry[]> => {
   const response = await fetch("https://api.openai.com/v1/models", {
     headers: withAuthHeader(token, {}),
+    signal,
   });
   if (!response.ok) {
     throw new Error(`OpenAI models error (${response.status}).`);
@@ -416,12 +438,13 @@ const fetchOpenAiModels = async (token: string): Promise<ModelEntry[]> => {
   return entries;
 };
 
-const fetchAnthropicModels = async (token: string): Promise<ModelEntry[]> => {
+const fetchAnthropicModels = async (token: string, signal?: AbortSignal): Promise<ModelEntry[]> => {
   const response = await fetch("https://api.anthropic.com/v1/models", {
     headers: {
       "x-api-key": token,
       "anthropic-version": "2023-06-01",
     },
+    signal,
   });
   if (!response.ok) {
     throw new Error(`Anthropic models error (${response.status}).`);
@@ -439,8 +462,8 @@ const fetchAnthropicModels = async (token: string): Promise<ModelEntry[]> => {
   return entries;
 };
 
-const fetchOllamaModels = async (): Promise<ModelEntry[]> => {
-  const response = await fetch("http://127.0.0.1:11434/api/tags");
+const fetchOllamaModels = async (signal?: AbortSignal): Promise<ModelEntry[]> => {
+  const response = await fetch("http://127.0.0.1:11434/api/tags", { signal });
   if (!response.ok) {
     throw new Error(`Ollama models error (${response.status}).`);
   }
@@ -456,19 +479,24 @@ const fetchOllamaModels = async (): Promise<ModelEntry[]> => {
 };
 
 const fetchProviderModels = async (input: ModelCatalogRequest): Promise<ModelOption[]> => {
-  if (input.providerId === "ollama") {
-    return toModelOptions(await fetchOllamaModels());
-  }
-  if (!input.token) {
-    throw new Error(`Missing API token for ${input.providerId}.`);
-  }
-  if (input.providerId === "openai") {
-    return toModelOptions(await fetchOpenAiModels(input.token));
-  }
-  if (input.providerId === "anthropic") {
-    return toModelOptions(await fetchAnthropicModels(input.token));
+  const timeout = createTimeoutSignal(MODEL_CATALOG_TIMEOUT_MS);
+  try {
+    if (input.providerId === "ollama") {
+      return toModelOptions(await fetchOllamaModels(timeout.signal));
+    }
+    if (!input.token) {
+      throw new Error(`Missing API token for ${input.providerId}.`);
+    }
+    if (input.providerId === "openai") {
+      return toModelOptions(await fetchOpenAiModels(input.token, timeout.signal));
+    }
+    if (input.providerId === "anthropic") {
+      return toModelOptions(await fetchAnthropicModels(input.token, timeout.signal));
+    }
+    throw new Error(`Unsupported provider ${input.providerId}.`);
+  } finally {
+    clearAbortTimer(timeout.timerId);
   }
-  throw new Error(`Unsupported provider ${input.providerId}.`);
 };
 
 const buildModelResponse = (input: ModelCatalogResponse) =>

examples/components/select.tsx

@@ -10,7 +10,7 @@ export type SelectProps = {
   id: string;
   value: string;
   options: SelectOption[];
-  suffix: string;
+  suffix?: string;
   onChange: (event: ChangeEvent<HTMLSelectElement>) => void;
 };
 

examples/components/toggle.tsx

@@ -3,11 +3,12 @@ import type { ChangeEvent, FC } from "react";
 export type ToggleProps = {
   id: string;
   checked: boolean;
-  suffix: string;
+  suffix?: string;
   onChange: (event: ChangeEvent<HTMLInputElement>) => void;
 };
 
 export const Toggle: FC<ToggleProps> = ({ id, checked, suffix, onChange }) => {
+  const hasSuffix = Boolean(suffix && suffix.trim().length > 0);
   return (
     <div className="agentic-control">
       <div className="agentic-field agentic-field--toggle">
@@ -16,9 +17,11 @@ export const Toggle: FC<ToggleProps> = ({ id, checked, suffix, onChange }) => {
           <span>{checked ? "On" : "Off"}</span>
         </label>
 
-        <span className="agentic-suffix" aria-hidden="true">
-          {suffix}
-        </span>
+        {hasSuffix ? (
+          <span className="agentic-suffix" aria-hidden="true">
+            {suffix}
+          </span>
+        ) : null}
       </div>
     </div>
   );

examples/kitchen-sink/client/src/styles.css

@@ -310,9 +310,3 @@ body {
     justify-content: flex-start;
   }
 }
-
-@media (min-width: 1024px) {
-  .ks-chat-scroll {
-    /* @apply px-10 py-10; */
-  }
-}

src/interaction/agent-runtime-subagents-helpers.ts

@@ -221,7 +221,7 @@ export function applySubagentCompleted(record: SubagentRecord, outcome: Outcome<
 
 export function applySubagentFailed(record: SubagentRecord, error: unknown) {
   record.status = "idle";
-  record.lastOutcome = null;
+  record.lastOutcome = toSubagentErrorOutcome(error);
   return error;
 }
 

tests/interaction/agent-runtime-subagents-helpers.test.ts

@@ -3,6 +3,7 @@ import type { EventStreamEvent } from "../../src/adapters/types";
 import { createAgentEventState } from "../../src/interaction/agent-runtime-events";
 import type { AgentRuntimeInput } from "../../src/interaction/agent-runtime";
 import type { Outcome } from "../../src/workflow/types";
+import type { MaybePromise } from "../../src/shared/maybe";
 import {
   applySubagentOutcome,
   buildMissingResult,
@@ -74,6 +75,9 @@ const createManager = (stream: RecordingStream): SubagentManager => ({
 const createRecord = (manager: SubagentManager, agentId = "agent-1"): SubagentRecord =>
   createSubagentRecord(manager, { agentId });
 
+const readLastOutcome = async (outcome: MaybePromise<Outcome<unknown>> | null) =>
+  outcome ? await outcome : null;
+
 const requireRecord = (records: SubagentRecord[]): SubagentRecord => {
   const record = records[0];
   if (!record) {
@@ -147,7 +151,12 @@ describe("subagent helpers", () => {
     const errorRecord = requireRecord(manager.records);
     setRecordStatus(errorRecord, "running");
     await applySubagentOutcome({ manager, record: errorRecord }, createErrorOutcome());
-    expect(errorRecord.lastOutcome).toBeNull();
+    const lastOutcome = await readLastOutcome(errorRecord.lastOutcome ?? null);
+    const isError = lastOutcome?.status === "error";
+    expect(isError).toBe(true);
+    if (isError && lastOutcome) {
+      expect(lastOutcome.error).toBeInstanceOf(Error);
+    }
   });
 
   it("wraps last outcomes into wait results", async () => {