@noodleseed/assistant 1.13.0 → 1.14.0

package/dist/client.cjs

@@ -22643,7 +22643,7 @@ var AssistantChatStateStore = class {
         this.#writeText(event.data.delta);
         return;
       case "tool_proposed":
-        this.#writeConfirmation(event.data);
+        this.#writeStandaloneData(() => this.#writeConfirmation(event.data));
         return;
       case "interaction_proposed":
         this.#writeData("confirmation", event.data.id, {
@@ -22652,10 +22652,12 @@ var AssistantChatStateStore = class {
         });
         return;
       case "input_requested":
-        this.#writeData("input-request", event.data.id, {
-          ...event.data,
-          status: "pending"
-        });
+        this.#writeStandaloneData(
+          () => this.#writeData("input-request", event.data.id, {
+            ...event.data,
+            status: "pending"
+          })
+        );
         return;
       case "tool_completed":
         this.#writeData("tool-result", event.data.id, event.data);
@@ -22762,6 +22764,12 @@ var AssistantChatStateStore = class {
   #writeConfirmation(data) {
     this.#writeData("confirmation", data.id, { ...data, status: "pending" });
   }
+  #writeStandaloneData(write) {
+    const standalone = this.#operation === void 0;
+    if (standalone) this.#startOperation();
+    write();
+    if (standalone) this.#closeOperation("ready");
+  }
   #writeData(name21, id, data) {
     const operation = this.#operation;
     if (!operation || operation.closed) return;
@@ -23240,6 +23248,7 @@ var DefaultAssistantClient = class {
   #context;
   #modelContext;
   #active;
+  #pendingAppInteractions = /* @__PURE__ */ new Map();
   constructor(options) {
     if (!options.sessionEndpoint) throw new Error("sessionEndpoint is required");
     this.#sessionEndpoint = options.sessionEndpoint;
@@ -23281,6 +23290,7 @@ var DefaultAssistantClient = class {
     }
     await this.#singleFlight(async (signal) => {
       await this.#runChatOperation(signal, async () => {
+        const pendingApp = this.#pendingAppInteractions.get(id);
         const session = this.#session;
         if (!session) {
           throw clientError("confirmation_expired", "assistant session is not active", false);
@@ -23300,32 +23310,67 @@ var DefaultAssistantClient = class {
           ...resolution.action === "accept" && resolution.content !== void 0 ? { content: resolution.content } : {}
         } : { id };
         this.#emit({ event: "interaction_started", data: { id, action: resolution.action } });
-        const response = await this.#request(
-          endpoint,
-          {
-            method: "POST",
-            headers: authorizedHeaders(session.token, "text/event-stream"),
-            body: JSON.stringify(body),
-            signal
-          },
-          "confirmation_failed"
-        );
-        if (response.status === 401) {
-          this.#session = void 0;
-          this.#emit({ event: "session_expired", data: {} });
-        }
-        if (!response.ok) {
-          const serverCode = await readStableErrorCode(response);
-          const expired = response.status === 401 || response.status === 409;
-          throw clientError(
-            serverCode ?? (expired ? "confirmation_expired" : "confirmation_failed"),
-            `Assistant interaction failed (${response.status})`,
-            false,
-            response.status
+        try {
+          const response = await this.#request(
+            endpoint,
+            {
+              method: "POST",
+              headers: authorizedHeaders(session.token, "text/event-stream"),
+              body: JSON.stringify(body),
+              signal
+            },
+            "confirmation_failed"
           );
+          if (response.status === 401) {
+            this.#session = void 0;
+            this.#emit({ event: "session_expired", data: {} });
+          }
+          if (!response.ok) {
+            const serverCode = await readStableErrorCode(response);
+            const expired = response.status === 401 || response.status === 409;
+            throw clientError(
+              serverCode ?? (expired ? "confirmation_expired" : "confirmation_failed"),
+              `Assistant interaction failed (${response.status})`,
+              false,
+              response.status
+            );
+          }
+          let completedResult;
+          let nextInteractionId;
+          await this.#consume(response, (event) => {
+            if (event.event === "tool_completed" && event.data.id === id) {
+              completedResult = event.data.result;
+            }
+            if ((event.event === "tool_proposed" || event.event === "input_requested") && event.data.id !== id) {
+              nextInteractionId = event.data.id;
+            }
+          });
+          this.#emit({ event: "interaction_completed", data: { id, action: resolution.action } });
+          if (pendingApp) {
+            this.#pendingAppInteractions.delete(id);
+            if (nextInteractionId) {
+              this.#pendingAppInteractions.set(nextInteractionId, pendingApp);
+            } else if (resolution.action !== "accept") {
+              pendingApp.resolve(appInteractionStopped(resolution.action));
+            } else if (completedResult !== void 0) {
+              pendingApp.resolve(appToolResult(completedResult));
+            } else {
+              pendingApp.reject(
+                clientError(
+                  "invalid_response",
+                  "Assistant app interaction completed without a tool result",
+                  false
+                )
+              );
+            }
+          }
+        } catch (error51) {
+          if (pendingApp && this.#pendingAppInteractions.get(id) === pendingApp) {
+            this.#pendingAppInteractions.delete(id);
+            pendingApp.reject(error51);
+          }
+          throw error51;
         }
-        await this.#consume(response);
-        this.#emit({ event: "interaction_completed", data: { id, action: resolution.action } });
       });
     });
   }
@@ -23366,12 +23411,29 @@ var DefaultAssistantClient = class {
         response.status
       );
     }
-    return response.json();
+    const value = await response.json();
+    const interaction = parseAppInteraction(value);
+    if (!interaction) return value;
+    return new Promise((resolve2, reject) => {
+      const id = interaction.data.id;
+      const replaced = this.#pendingAppInteractions.get(id);
+      if (replaced) {
+        replaced.reject(
+          clientError("invalid_response", "Assistant returned a duplicate app interaction", false)
+        );
+      }
+      this.#pendingAppInteractions.set(id, { resolve: resolve2, reject });
+      this.#emit(interaction);
+      void this.#chat.flush();
+    });
   }
   appSandboxUrl() {
     return this.#session?.endpoints.sandbox;
   }
   resetSession() {
+    this.#rejectPendingAppInteractions(
+      clientError("confirmation_expired", "assistant session is not active", false)
+    );
     this.#session = void 0;
     this.#emit({ event: "session_reset", data: {} });
   }
@@ -23492,12 +23554,13 @@ var DefaultAssistantClient = class {
     });
     return session;
   }
-  async #consume(response) {
+  async #consume(response, observe) {
     let streamError;
     try {
       await consumeAssistantEvents(response, (event) => {
         const clientEvent = toAssistantClientEvent(event);
         this.#emit(clientEvent);
+        observe?.(clientEvent);
         if (clientEvent.event !== "error" || typeof clientEvent.data.code !== "string") return;
         streamError = {
           code: clientEvent.data.code,
@@ -23566,6 +23629,10 @@ var DefaultAssistantClient = class {
       }
     }
   }
+  #rejectPendingAppInteractions(error51) {
+    for (const pending of this.#pendingAppInteractions.values()) pending.reject(error51);
+    this.#pendingAppInteractions.clear();
+  }
 };
 function createAssistantClient(options) {
   return new DefaultAssistantClient(options);
@@ -23577,6 +23644,30 @@ function authorizedHeaders(token, accept) {
     Accept: accept
   };
 }
+function parseAppInteraction(value) {
+  if (!isRecord4(value) || !isRecord4(value.interaction)) return void 0;
+  const event = value.interaction.event;
+  const data = value.interaction.data;
+  if (event !== "tool_proposed" && event !== "input_requested" || !isRecord4(data)) {
+    return void 0;
+  }
+  const parsed = toAssistantClientEvent({ event, data });
+  return parsed.event === "tool_proposed" || parsed.event === "input_requested" ? parsed : void 0;
+}
+function appToolResult(result) {
+  const text2 = typeof result === "string" ? result : JSON.stringify(result);
+  return result !== null && typeof result === "object" && !Array.isArray(result) ? {
+    content: [{ type: "text", text: text2 }],
+    structuredContent: result,
+    isError: false
+  } : { content: [{ type: "text", text: text2 }], isError: false };
+}
+function appInteractionStopped(action) {
+  return {
+    content: [{ type: "text", text: `interaction_${action}` }],
+    isError: true
+  };
+}
 function parseSession(value) {
   if (!isRecord4(value) || !isRecord4(value.endpoints)) {
     throw clientError("session_failed", "Assistant session response is invalid", true);