Add use fallback to run request

packages/workflowai/README.md

@@ -48,13 +48,19 @@ const getCapitalInfo = workflowAI.agent<
   id: 'get-capital-info',
   schemaId: 1,
   version: '1.4',
-  // Cache options:
+  // Cache options (can also be passed to the run function):
   // - "auto" (default): if a previous run exists with the same version and input, and if
   // the temperature is 0, the cached output is returned
   // - "always": the cached output is returned when available, regardless
   // of the temperature value
   // - "never": the cache is never used
   useCache: 'auto',
+  // Customize model fallback,  (can also be passed to the run function):
+  // - defaults to 'auto' meaning that the model to fallback to is picked by WorkflowAI
+  // The selected model is in the same price range and depends on the error that was triggered
+  // - "never": the fallback is never used
+  // - list of model names: models to try in order after the primary model fails
+  useFallback: ['gpt-4o-mini', 'gpt-4o'],
 });
 
 // Run Your AI agent
@@ -69,6 +75,12 @@ async function getCapitalInfoRun() {
       data: { duration_seconds, cost_usd, version },
     } = await getCapitalInfo(input);
 
+    // Also possible to pass options to the run function:
+    // const { output } = await getCapitalInfo(input, {
+    //   useCache: 'always',
+    //   useFallback: 'never',
+    // });
+
     console.log(output);
     console.log('\nModel: ', version?.properties?.model);
     console.log('Cost: $', cost_usd);

packages/workflowai/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflowai/workflowai",
-  "version": "1.6.7",
+  "version": "1.6.8",
   "type": "module",
   "description": "WorkflowAI JS SDK",
   "author": "WorkflowAI",

packages/workflowai/src/WorkflowAI.ts

@@ -37,7 +37,8 @@ function optionsToRunRequest(
   input: Record<string, never>,
   options: Omit<RunOptions<true | false>, 'fetch'>
 ): RunRequest {
-  const { version, stream, metadata, useCache, privateFields } = options;
+  const { version, stream, metadata, useCache, privateFields, useFallback } =
+    options;
 
   return {
     task_input: input,
@@ -46,6 +47,7 @@ function optionsToRunRequest(
     metadata,
     use_cache: useCache || 'auto',
     private_fields: privateFields,
+    use_fallback: useFallback,
   };
 }
 

packages/workflowai/src/api/generated/openapi.ts

@@ -83,6 +83,11 @@ export interface components {
        * @description Fields marked as private will not be saved, none by default.
        */
       private_fields?: ('task_input' | string)[] | null;
+      /**
+       * Use Fallback
+       * @description Whether to use fallback models if the primary model fails.
+       */
+      use_fallback?: 'never' | 'auto' | string[] | null;
     };
     /**
      * TaskGroupProperties

packages/workflowai/src/types.ts

@@ -14,6 +14,7 @@ export type RunOptions<Stream extends true | false = false> = {
   stream?: Stream;
   fetch?: FetchOptions;
   privateFields?: ('task_input' | 'task_output' | string)[];
+  useFallback?: 'never' | 'auto' | string[];
 };
 
 export type FileContentType =

tests/integration/agent.test.ts

@@ -202,4 +202,73 @@ describe('run', () => {
       expect(error.errorCode).toBeFalsy();
     }
   });
+
+  it('correctly handles useFallback when passed to the run function', async () => {
+    const run1Fixture = await readFile(fixturePath('run1.json'), 'utf-8');
+    mockFetch.mockResponseOnce(run1Fixture);
+
+    const result = await run({ animal: 'platypus' }, { useFallback: 'never' });
+    expect(result.output).toEqual({
+      is_cute: true,
+      is_dangerous: true,
+      explanation_of_reasoning: 'Plat plat',
+    });
+
+    expect(mockFetch.mock.calls.length).toEqual(1);
+    const req = mockFetch.mock.calls[0][0] as Request;
+    expect(req.url).toEqual(
+      'https://run.workflowai.com/v1/_/agents/animal-classification/schemas/4/run'
+    );
+    expect(req.method).toEqual('POST');
+    expect(req.headers.get('Authorization')).toEqual('Bearer hello');
+    const body = await req.json();
+    expect(body).toEqual({
+      version: 'production',
+      stream: false,
+      task_input: {
+        animal: 'platypus',
+      },
+      use_cache: 'auto',
+      use_fallback: 'never',
+    });
+  });
+
+  it('correctly handles useFallback when passed to the agent', async () => {
+    const run2 = workflowAI.agent<
+      AnimalClassificationInput,
+      AnimalClassificationOutput
+    >({
+      id: 'animal-classification',
+      schemaId: 4,
+      version: 'production',
+      useFallback: ['gpt-4o-mini', 'gpt-4o'],
+    });
+    const run1Fixture = await readFile(fixturePath('run1.json'), 'utf-8');
+    mockFetch.mockResponseOnce(run1Fixture);
+
+    const result = await run2({ animal: 'platypus' });
+    expect(result.output).toEqual({
+      is_cute: true,
+      is_dangerous: true,
+      explanation_of_reasoning: 'Plat plat',
+    });
+
+    expect(mockFetch.mock.calls.length).toEqual(1);
+    const req = mockFetch.mock.calls[0][0] as Request;
+    expect(req.url).toEqual(
+      'https://run.workflowai.com/v1/_/agents/animal-classification/schemas/4/run'
+    );
+    expect(req.method).toEqual('POST');
+    expect(req.headers.get('Authorization')).toEqual('Bearer hello');
+    const body = await req.json();
+    expect(body).toEqual({
+      version: 'production',
+      stream: false,
+      task_input: {
+        animal: 'platypus',
+      },
+      use_cache: 'auto',
+      use_fallback: ['gpt-4o-mini', 'gpt-4o'],
+    });
+  });
 });