Function createWorkflowRunTool

src/node/services/tools/workflow_run.ts:81–186

(config: ToolConfiguration)

}

export const createWorkflowRunTool: ToolFactory = (config: ToolConfiguration) => {
  return tool({
    description: TOOL_DEFINITIONS.workflow_run.description,
    inputSchema: TOOL_DEFINITIONS.workflow_run.schema,
    execute: async (args, options): Promise<unknown> => {
      const workspaceId = requireWorkspaceId(config, "workflow_run");
      const workflowService = requireWorkflowService(config);
      const toolCallId = options.toolCallId;

      const script = await resolveWorkflowScript({
        scriptPath: args.script_path,
        scriptSource: args.script_source,
        runtime: config.runtime,
        workspacePath: config.cwd,
        projectTrusted: config.trusted === true,
        ...(config.agentSkillsRoots != null ? { roots: config.agentSkillsRoots } : {}),
      });
      const createdRun: { id: string | null } = { id: null };
      const startInput = {
        script,
        workspaceId,
        projectTrusted: config.trusted === true,
        args: args.args ?? {},
        onRunCreated: async (event: { runId: string; run: unknown }) => {
          createdRun.id = event.runId;
          await emitWorkflowRunAttachedEvent({
            config,
            workspaceId,
            toolCallId,
            runId: event.runId,
            run: event.run,
          });
        },
      };
      const invocationStartedAtMs = Date.now();
      let result: { runId: string; status: string; result: unknown };
      try {
        result =
          args.run_in_background === true
            ? await requireBackgroundWorkflowStart(workflowService)({
                ...startInput,
                // Background runs are non-blocking; terminal result is delivered by
                // AIService.onBackgroundRunTerminal rather than a forced task_await.
                attentionPolicy: "notify_on_terminal",
              })
            : await requireForegroundWorkflowStart(workflowService)({
                ...startInput,
                ...(options.abortSignal != null ? { abortSignal: options.abortSignal } : {}),
              });
      } catch (error: unknown) {
        const createdRunId = createdRun.id;
        if (createdRunId == null) {
          throw error;
        }
        if (workflowService.getRun == null) {
          throw new Error(
            `${getErrorMessage(error)} (workflow_run created durable run ${createdRunId} before failing)`
          );