Enhance output handling: improve tool output processing and error message handling

Author: habedi

src/agent/state.ts

@@ -306,11 +306,33 @@ export const useStore = create<AppState & AppActions>((set, get) => ({
                                 { toolName: toolCall.toolName, args: toolCall.input },
                                 config,
                             );
-                            const output =
-                                result === "" || result === null || result === undefined
-                                    ? "Tool executed successfully and produced no output."
-                                    : result;
-                            logger.info("Tool executed successfully.", { toolCall, output });
+
+                            let finalOutput: object;
+
+                            if (result === "" || result === null || result === undefined) {
+                                finalOutput = {
+                                    result: "Tool executed successfully and produced no output.",
+                                };
+                            } else if (typeof result === "string") {
+                                finalOutput = { result: result };
+                            } else if (
+                                typeof result === "object" &&
+                                Object.keys(result).length === 0
+                            ) {
+                                // The AI SDK expects a non-empty object for the tool output.
+                                finalOutput = {
+                                    result: "Tool executed successfully and produced an empty object.",
+                                };
+                            } else {
+                                // Assuming result is a non-empty object that fits the expected type
+                                finalOutput = result;
+                            }
+
+                            logger.info("Tool executed successfully.", {
+                                toolCall,
+                                output: finalOutput,
+                            });
+
                             toolResults.push({
                                 id: crypto.randomUUID(),
                                 role: "tool",
@@ -319,8 +341,11 @@ export const useStore = create<AppState & AppActions>((set, get) => ({
                                         type: "tool-result",
                                         toolCallId: toolCall.toolCallId,
                                         toolName: toolCall.toolName,
-                                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                                        output: output as any,
+                                        // We use `as any` here because the exact type of the tool output
+                                        // is not known at compile time and can vary between tools.
+                                        // The logic above ensures that the output is always a non-empty
+                                        // object, which satisfies the AI SDK's runtime validation.
+                                        output: finalOutput as any,
                                     },
                                 ],
                             });
@@ -360,7 +385,18 @@ export const useStore = create<AppState & AppActions>((set, get) => ({
                     logger.info("No tool calls, agent is now idle.");
                 }
             } catch (error) {
-                if (error instanceof TransientError && retryCount < MAX_RETRIES) {
+                let typedError = error;
+                const errorMessage =
+                    typedError instanceof Error ? typedError.message : "An unknown error occurred.";
+
+                // This is a workaround for a generic error thrown by the AI SDK when the LLM
+                // returns an empty response (no text, no tool calls). We treat it as a
+                // transient error and retry.
+                if (errorMessage.includes("No output generated")) {
+                    typedError = new TransientError(errorMessage);
+                }
+
+                if (typedError instanceof TransientError && retryCount < MAX_RETRIES) {
                     logger.warn(`Transient error caught, retrying... (${retryCount + 1})`);
                     set({ status: "idle" });
                     const backoff = INITIAL_BACKOFF_MS * 2 ** retryCount;
@@ -371,15 +407,15 @@ export const useStore = create<AppState & AppActions>((set, get) => ({
                     return;
                 }
 
-                const errorMessage =
-                    error instanceof Error ? error.message : "An unknown error occurred.";
+                const finalErrorMessage =
+                    typedError instanceof Error ? typedError.message : "An unknown error occurred.";
 
-                if (error instanceof FatalError) {
-                    logger.error(`Fatal error: ${errorMessage}`);
-                    set({ error: errorMessage, status: "error" });
+                if (typedError instanceof FatalError) {
+                    logger.error(`Fatal error: ${finalErrorMessage}`);
+                    set({ error: finalErrorMessage, status: "error" });
                 } else {
-                    logger.error(`Unhandled error in agent logic: ${errorMessage}`);
-                    set({ error: errorMessage, status: "error" });
+                    logger.error(`Unhandled error in agent logic: ${finalErrorMessage}`);
+                    set({ error: finalErrorMessage, status: "error" });
                 }
             }
         },