feat: Update interrupt semantics

sdk-node/src/execute-fn.test.ts

@@ -1,7 +1,30 @@
+import { executeFn } from "./execute-fn";
+import { Interrupt } from "./util";
+
 describe("executeFn", () => {
   it("should run a function with arguments", async () => {
     const fn = (val: { [key: string]: string }) => Promise.resolve(val.foo);
-    const result = await fn({ foo: "bar" });
+    const result = await executeFn(fn, [{foo: "bar"}] as any);
     expect(result).toBe("bar");
   });
+
+  it("should extract interrupt from resolution", async () => {
+    const fn = (_: string) => Promise.resolve(Interrupt.approval());
+    const result = await executeFn(fn, [{}] as any);
+    expect(result).toEqual({
+      content: { type: "approval" },
+      type: "interrupt",
+      functionExecutionTime: expect.any(Number),
+    });
+  });
+
+  it("should extract interrupt from rejection", async () => {
+    const fn = () => Promise.reject(Interrupt.approval());
+    const result = await executeFn(fn, [{}] as any);
+    expect(result).toEqual({
+      content: { type: "approval" },
+      type: "interrupt",
+      functionExecutionTime: expect.any(Number),
+    });
+  });
 });

sdk-node/src/execute-fn.ts

@@ -32,6 +32,14 @@ export const executeFn = async (
       functionExecutionTime: Date.now() - start,
     };
   } catch (e) {
+    const interupt = extractInterrupt(e);
+    if (interupt) {
+      return {
+        content: interupt,
+        type: "interrupt",
+        functionExecutionTime: Date.now() - start,
+      };
+    }
     const functionExecutionTime = Date.now() - start;
     if (e instanceof Error) {
       return {

sdk-node/src/util.test.ts

@@ -2,6 +2,8 @@ import {
   ajvErrorToFailures,
   blob,
   extractBlobs,
+  extractInterrupt,
+  Interrupt,
   validateFunctionSchema,
 } from "./util";
 
@@ -64,6 +66,21 @@ describe("ajvErrorToFailures", () => {
   });
 });
 
+describe("extractInterrupt", () => {
+  it("should extract extract interrupt", () => {
+    const interrupt = extractInterrupt(Interrupt.approval());
+    expect(interrupt).toEqual({
+      type: "approval",
+    })
+  })
+
+  it("should not extract interrupt from non-interrupt", () => {
+    const interrupt = extractInterrupt({ foo: "bar" });
+    expect(interrupt).toBeUndefined();
+  })
+
+});
+
 describe("extractBlobs", () => {
   it("should extract blobs from content", () => {
     const initialContent = {

sdk-node/src/util.ts

@@ -279,6 +279,7 @@ export const blob = ({
 
 
 export const INTERRUPT_KEY = "__inferable_interrupt";
+type VALID_INTERRUPT_TYPES = "approval";
 const interruptResultSchema = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("approval"),
@@ -297,6 +298,25 @@ export const extractInterrupt = (input: unknown): z.infer<typeof interruptResult
   }
 }
 
+export class Interrupt {
+  [INTERRUPT_KEY]: {
+    type: VALID_INTERRUPT_TYPES
+  }
+
+  constructor(type: VALID_INTERRUPT_TYPES) {
+    this[INTERRUPT_KEY] = {
+      type
+    }
+  }
+
+  static approval() {
+    return new Interrupt("approval");
+  }
+}
+
+/**
+ * @deprecated Use Interrupt.approval() instea
+  */
 export const approvalRequest = () => {
   return {
     [INTERRUPT_KEY]: {