Add @trigger.dev/ai package with chat transport and tests

Co-authored-by: Eric Allam <eric@trigger.dev>

Author: cursoragent

packages/ai/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@trigger.dev/ai",
+  "version": "4.3.3",
+  "description": "Trigger.dev AI SDK integrations and chat transport",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/triggerdotdev/trigger.dev",
+    "directory": "packages/ai"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "tshy": {
+    "selfLink": false,
+    "main": true,
+    "module": true,
+    "project": "./tsconfig.json",
+    "exports": {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts"
+    },
+    "sourceDialects": [
+      "@triggerdotdev/source"
+    ]
+  },
+  "scripts": {
+    "clean": "rimraf dist .tshy .tshy-build .turbo",
+    "build": "tshy && pnpm run update-version",
+    "dev": "tshy --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "update-version": "tsx ../../scripts/updateVersion.ts",
+    "check-exports": "attw --pack ."
+  },
+  "dependencies": {
+    "@trigger.dev/core": "workspace:^4.3.3"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.15.4",
+    "ai": "^6.0.0",
+    "rimraf": "^3.0.2",
+    "tshy": "^3.0.2",
+    "tsx": "4.17.0",
+    "zod": "3.25.76"
+  },
+  "peerDependencies": {
+    "ai": "^4.2.0 || ^5.0.0 || ^6.0.0",
+    "zod": "^3.0.0 || ^4.0.0"
+  },
+  "engines": {
+    "node": ">=18.20.0"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "@triggerdotdev/source": "./src/index.ts",
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    }
+  },
+  "main": "./dist/commonjs/index.js",
+  "types": "./dist/commonjs/index.d.ts",
+  "module": "./dist/esm/index.js"
+}

packages/ai/src/ai.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import { ai } from "./ai.js";
+import type { TaskWithSchema } from "@trigger.dev/core/v3";
+
+describe("ai helper", function () {
+  it("creates a tool from a schema task and executes through triggerAndWait", async function () {
+    let receivedInput: unknown = undefined;
+
+    const fakeTask = {
+      id: "fake-task",
+      description: "A fake task",
+      schema: z.object({
+        name: z.string(),
+      }),
+      triggerAndWait: function (payload: { name: string }) {
+        receivedInput = payload;
+        const resultPromise = Promise.resolve({
+          ok: true,
+          id: "run_123",
+          taskIdentifier: "fake-task",
+          output: {
+            greeting: `Hello ${payload.name}`,
+          },
+        });
+
+        return Object.assign(resultPromise, {
+          unwrap: async function () {
+            return {
+              greeting: `Hello ${payload.name}`,
+            };
+          },
+        });
+      },
+    } as unknown as TaskWithSchema<
+      "fake-task",
+      z.ZodObject<{ name: z.ZodString }>,
+      { greeting: string }
+    >;
+
+    const tool = ai.tool(fakeTask);
+    const result = await tool.execute?.(
+      {
+        name: "Ada",
+      },
+      undefined as never
+    );
+
+    expect(receivedInput).toEqual({
+      name: "Ada",
+    });
+    expect(result).toEqual({
+      greeting: "Hello Ada",
+    });
+  });
+
+  it("throws when creating a tool from a task without schema", function () {
+    const fakeTask = {
+      id: "no-schema",
+      description: "No schema task",
+      schema: undefined,
+      triggerAndWait: async function () {
+        return {
+          unwrap: async function () {
+            return {};
+          },
+        };
+      },
+    } as unknown as TaskWithSchema<"no-schema", undefined, unknown>;
+
+    expect(function () {
+      ai.tool(fakeTask);
+    }).toThrowError("task has no schema");
+  });
+
+  it("returns undefined for current tool options outside task execution context", function () {
+    expect(ai.currentToolOptions()).toBeUndefined();
+  });
+});

packages/ai/src/ai.ts

@@ -0,0 +1,131 @@
+import {
+  AnyTask,
+  isSchemaZodEsque,
+  runMetadata,
+  Task,
+  type inferSchemaIn,
+  type TaskSchema,
+  type TaskWithSchema,
+} from "@trigger.dev/core/v3";
+import {
+  dynamicTool,
+  jsonSchema,
+  JSONSchema7,
+  Schema,
+  Tool,
+  ToolCallOptions,
+  zodSchema,
+} from "ai";
+
+const METADATA_KEY = "tool.execute.options";
+
+export type ToolCallExecutionOptions = Omit<ToolCallOptions, "abortSignal">;
+
+type ToolResultContent = Array<
+  | {
+      type: "text";
+      text: string;
+    }
+  | {
+      type: "image";
+      data: string;
+      mimeType?: string;
+    }
+>;
+
+export type ToolOptions<TResult> = {
+  experimental_toToolResultContent?: (result: TResult) => ToolResultContent;
+};
+
+function toolFromTask<TIdentifier extends string, TInput = void, TOutput = unknown>(
+  task: Task<TIdentifier, TInput, TOutput>,
+  options?: ToolOptions<TOutput>
+): Tool<TInput, TOutput>;
+function toolFromTask<
+  TIdentifier extends string,
+  TTaskSchema extends TaskSchema | undefined = undefined,
+  TOutput = unknown,
+>(
+  task: TaskWithSchema<TIdentifier, TTaskSchema, TOutput>,
+  options?: ToolOptions<TOutput>
+): Tool<inferSchemaIn<TTaskSchema>, TOutput>;
+function toolFromTask<
+  TIdentifier extends string,
+  TTaskSchema extends TaskSchema | undefined = undefined,
+  TInput = void,
+  TOutput = unknown,
+>(
+  task: TaskWithSchema<TIdentifier, TTaskSchema, TOutput> | Task<TIdentifier, TInput, TOutput>,
+  options?: ToolOptions<TOutput>
+): TTaskSchema extends TaskSchema
+  ? Tool<inferSchemaIn<TTaskSchema>, TOutput>
+  : Tool<TInput, TOutput> {
+  if (("schema" in task && !task.schema) || ("jsonSchema" in task && !task.jsonSchema)) {
+    throw new Error(
+      "Cannot convert this task to to a tool because the task has no schema. Make sure to either use schemaTask or a task with an input jsonSchema."
+    );
+  }
+
+  const toolDefinition = dynamicTool({
+    description: task.description,
+    inputSchema: convertTaskSchemaToToolParameters(task),
+    execute: async (input, options) => {
+      const serializedOptions = options ? JSON.parse(JSON.stringify(options)) : undefined;
+
+      return await task
+        .triggerAndWait(input as inferSchemaIn<TTaskSchema>, {
+          metadata: {
+            [METADATA_KEY]: serializedOptions,
+          },
+        })
+        .unwrap();
+    },
+    ...options,
+  });
+
+  return toolDefinition as TTaskSchema extends TaskSchema
+    ? Tool<inferSchemaIn<TTaskSchema>, TOutput>
+    : Tool<TInput, TOutput>;
+}
+
+function getToolOptionsFromMetadata(): ToolCallExecutionOptions | undefined {
+  let tool: unknown;
+  try {
+    tool = runMetadata.getKey(METADATA_KEY);
+  } catch {
+    return undefined;
+  }
+
+  if (!tool) {
+    return undefined;
+  }
+
+  return tool as ToolCallExecutionOptions;
+}
+
+function convertTaskSchemaToToolParameters(
+  task: AnyTask | TaskWithSchema<any, any, any>
+): Schema<unknown> {
+  if ("schema" in task) {
+    if ("toJsonSchema" in task.schema && typeof task.schema.toJsonSchema === "function") {
+      return jsonSchema((task.schema as any).toJsonSchema());
+    }
+
+    if (isSchemaZodEsque(task.schema)) {
+      return zodSchema(task.schema as any);
+    }
+  }
+
+  if ("jsonSchema" in task) {
+    return jsonSchema(task.jsonSchema as JSONSchema7);
+  }
+
+  throw new Error(
+    "Cannot convert task to a tool. Make sure to use a task with a schema or jsonSchema."
+  );
+}
+
+export const ai = {
+  tool: toolFromTask,
+  currentToolOptions: getToolOptionsFromMetadata,
+};